');
return;
}
var url = $.hosts.code['/inlineEdit'].edit(obj, objName, prop);
var memo = {
type: 'iframe',
url: url,
alt: 'Edit ' + prop + ' on ' + objName
};
cmd.user.readMemo(memo);
};
Object.setOwnerOf($.user.inlineEdit, $.physicals.Maximilian);
$.user.inlineEdit.verb = 'edit';
$.user.inlineEdit.dobj = 'any';
$.user.inlineEdit.prep = 'on top of/on/onto/upon';
$.user.inlineEdit.iobj = 'any';
$.user.describe = function describe(cmd) {
if (typeof this.description === 'function') {
cmd.user.narrate("Can't set description since it is a function.");
return;
}
this.description = cmd.iobjstr;
cmd.user.narrate($.utils.string.capitalize(String(this)) + '\'s description set to "' + this.description + '".');
};
Object.setOwnerOf($.user.describe, $.physicals.Neil);
Object.setOwnerOf($.user.describe.prototype, $.physicals.Neil);
$.user.describe.verb = 'describe';
$.user.describe.dobj = 'this';
$.user.describe.prep = 'as';
$.user.describe.iobj = 'any';
$.user.lookJssp = "\n \n \n \n <%= $.utils.object.getValue(this, 'svgText') %>\n \n \n \n <%: this %><%= $.utils.commandMenu(this.getCommands(request.user)) %> \n <%= $.utils.html.preserveWhitespace($.utils.object.getValue(this, 'description')) %>
\n<%\nvar contents = this.getContents();\nif (contents.length) {\n var contentsHtml = [];\n for (var i = 0; i < contents.length; i++) {\n contentsHtml[i] = $.utils.html.escape(contents[i].name) +\n $.utils.commandMenu(contents[i].getCommands(request.user));\n }\n response.write('Contents: ' + contentsHtml.join(', ') + '
');\n}\nif (this.location) {\n response.write('Location: ' + $.utils.html.escape(this.location.name) +\n $.utils.commandMenu(this.location.getCommands(request.user)) + '
');\n}\n%>\n \n \n
";
$.room = (new 'Object.create')($.physical);
$.room.name = 'Room prototype';
$.room.svgText = '\n \n \n \n <%= $.utils.object.getValue(this, 'svgText') %>\n \n \n \n <%: this %><%= $.utils.commandMenu(this.getCommands(request.user)) %> \n <%= $.utils.html.preserveWhitespace($.utils.object.getValue(this, 'description')) %>
\n It is <%= this.isOpen ? 'open' : 'closed' %>.
\n<%\nif (this.isOpen ? this.contentsVisibleWhenOpen : this.contentsVisibleWhenClosed) {\n var contents = this.getContents();\n if (contents.length) {\n var contentsHtml = [];\n for (var i = 0; i < contents.length; i++) {\n var commands = [\n 'look ' + contents[i].name + ' in ' + this.name,\n 'get ' + contents[i].name + ' from ' + this.name\n ];\n contentsHtml[i] = $.utils.html.escape(contents[i].name) +\n $.utils.commandMenu(commands);\n }\n response.write('Contents: ' + contentsHtml.join(', ') + '
');\n }\n}\nif (this.location) {\n response.write('Location: ' + $.utils.html.escape(this.location.name) +\n $.utils.commandMenu(this.location.getCommands(request.user)) + '
');\n}\n%>\n \n \n
";
$.container.lookIn = function lookIn(cmd) {
var thing = cmd.dobj
if ($.utils.command.matchFailed(thing)) {
thing = $.utils.command.match(cmd.dobjstr, this);
}
if ($.utils.command.matchFailed(thing, cmd.dobjstr, cmd.user)) return;
if (this.location !== cmd.user.location && this.location !== cmd.user) {
cmd.user.narrate($.utils.string.capitalize(String(this)) + ' is not here.');
return;
}
if (thing.location !== this) {
cmd.user.narrate($.utils.string.capitalize(String(thing)) + ' is not in ' + String(this) + '.');
return;
}
if (this.isOpen) {
if (!this.contentsVisibleWhenOpen) {
cmd.user.narrate('You can\'t see inside ' + String(this) + '.');
return;
}
} else {
if (!this.contentsVisibleWhenClosed) {
cmd.user.narrate($.utils.string.capitalize(String(this)) + ' is closed.');
return;
}
}
var html = thing.lookJssp.toString(thing, {user: cmd.user});
cmd.user.readMemo({type: "html", htmlText: html});
};
Object.setOwnerOf($.container.lookIn, $.physicals.Neil);
Object.setOwnerOf($.container.lookIn.prototype, $.physicals.Neil);
$.container.lookIn.verb = 'l(ook)?';
$.container.lookIn.dobj = 'any';
$.container.lookIn.prep = 'in/inside/into';
$.container.lookIn.iobj = 'this';
$.container.toFloor = false;
$.container.svgText = function svgText() {
return this.isOpen ? this.svgTextOpen : this.svgTextClosed;
};
Object.setOwnerOf($.container.svgText, $.physicals.Neil);
Object.setOwnerOf($.container.svgText.prototype, $.physicals.Maximilian);
$.physicals['User prototype'] = $.user;
$.physicals['Room prototype'] = $.room;
$.physicals['Thing prototype'] = $.thing;
$.physicals['Container prototype'] = $.container;
================================================
FILE: core/core_34_$.servers.login.js
================================================
/**
* @license
* Copyright 2021 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Login service backend server for Code City.
*/
//////////////////////////////////////////////////////////////////////
// AUTO-GENERATED CODE FROM DUMP. EDIT WITH CAUTION!
//////////////////////////////////////////////////////////////////////
$.servers.login = {};
Object.setOwnerOf($.servers.login, $.physicals.Neil);
$.servers.login.connection = (new 'Object.create')($.connection);
$.servers.login.connection.onReceiveLine = function onReceiveLine(line) {
line = line.trim();
try {
var loginData = JSON.parse(line);
var cookie = $.servers.login.getCookie(loginData);
this.write(cookie);
} catch (err) {
// Just log error.
suspend();
$.system.log('$.servers.login: ' + String(err));
} finally {
suspend();
this.close();
}
};
Object.setOwnerOf($.servers.login.connection.onReceiveLine, $.physicals.Maximilian);
Object.setOwnerOf($.servers.login.connection.onReceiveLine.prototype, $.physicals.Neil);
$.servers.login.getCookie = function getCookie(loginData) {
/* Get the ID cookie for the given loginData.
*
* Arguments:
* - loginData: !Object - the loginData object from loginServer.
* Returns: string - the ID cookie to set. Empty string denotes
* invalid login.
*/
var id = loginData.id;
if (typeof(id) !== 'string') {
return '';
} else if ($.userDatabase.get(id)) { // User already exists.
return id;
} else { // Create new user object.
var name = loginData.given_name || loginData.name ||
loginData.email && loginData.email.replace(/@.*$/, '');
this.createUser(id, name);
return id;
}
};
Object.setOwnerOf($.servers.login.getCookie, $.physicals.Maximilian);
Object.setOwnerOf($.servers.login.getCookie.prototype, $.physicals.Maximilian);
$.servers.login.createUser = function createUser(id, name) {
/* Create a $.user object for the given id.
*
* Arguments:
* - id: string - the ID cookie for the given user.
* - name?: string - the name for the new user. Default: 'Guest'.
* Returns: Object - the new $.user object
*/
if ($.userDatabase.get(id)) throw new TypeError('user already exists');
// Create new $.user.
var user = Object.create($.user);
user.setName(name || 'Guest', /*tryAlternative:*/ true);
$.userDatabase.set(id, user);
/*
(function() {
setPerms(user);
var home = Object.create($.room);
home.setName(user.name + "'s room", true);
home.description = 'A quiet place for ' + user.name + ' to work.';
user.home = home;
user.moveTo(home);
})();
*/
return user;
};
Object.setOwnerOf($.servers.login.createUser, $.physicals.Maximilian);
Object.setOwnerOf($.servers.login.createUser.prototype, $.physicals.Maximilian);
================================================
FILE: core/core_34_$.servers.telnet.js
================================================
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Telnet server for Code City.
*/
//////////////////////////////////////////////////////////////////////
// AUTO-GENERATED CODE FROM DUMP. EDIT WITH CAUTION!
//////////////////////////////////////////////////////////////////////
$.servers.telnet = {};
$.servers.telnet.connection = (new 'Object.create')($.connection);
$.servers.telnet.connection.onReceiveLine = function onReceiveLine(text) {
if (this.user) { // Logged in?
// Set 'user' for this thread, and permissions for call
Object.setOwnerOf(Thread.current(), this.user);
setPerms(this.user);
this.user.onInput(text);
return;
}
// Remainder of function handles login.
// TODO(fraser): Make sure that no security issues exist due to
// called code suspending or timing out unexpectedly.
var m = text.match(/identify as ([0-9a-f]+)/);
if (!m) {
this.write('{type: "narrate", text: "Unknown command: ' +
$.utils.html.preserveWhitespace(text) + '"}');
return;
}
var id = m[1];
var user = $.userDatabase.get(id) || $.servers.login.createUser(id);
this.user = user;
var rebind = false;
if (user.connection) {
rebind = true;
try {
user.connection.close();
} catch (e) {
// Ignore; maybe connection already closed (e.g., due to crash/reboot).
}
$.system.log('Rebinding connection to ' + user.name);
} else {
$.system.log('Binding connection to ' + user.name);
}
user.connection = this;
Object.setOwnerOf(Thread.current(), user);
setPerms(this.user);
new Thread(user.onConnect, 0, user, rebind);
};
Object.setOwnerOf($.servers.telnet.connection.onReceiveLine, $.physicals.Maximilian);
$.servers.telnet.connection.onEnd = function onEnd() {
var user = this.user;
// Mark connection as closed.
$.connection.onEnd.call(this);
if (user) {
// Unbind connection from user.
this.user = null;
if (user.connection === this) {
user.connection = null;
$.system.log('Unbinding connection from ' + user.name);
(function () {
setPerms(user);
new Thread(user.onDisconnect, 0, user);
})();
}
}
// Remove this and any other closed / debound connections from array of open connections.
$.servers.telnet.validate();
};
Object.setOwnerOf($.servers.telnet.connection.onEnd, $.physicals.Maximilian);
$.servers.telnet.connection.onConnect = function onConnect() {
// super call. Records .connectTime (as number of ms since epoch).
$.connection.onConnect.apply(this, arguments);
// Add this connection to list of active telnet connections.
$.servers.telnet.connected.push(this);
setTimeout((function onConnect_timeout() {
if (!this.user) this.close();
}).bind(this), $.servers.telnet.LOGIN_TIMEOUT_MS);
};
Object.setOwnerOf($.servers.telnet.connection.onConnect, $.physicals.Maximilian);
Object.setOwnerOf($.servers.telnet.connection.onConnect.prototype, $.physicals.Maximilian);
$.servers.telnet.validate = function validate() {
// Examine supposedly-open connections and close and/or remove
// closed / timed-out / debound ones from the .connected arary.
var limit = Date.now() - this.LOGIN_TIMEOUT_MS;
this.connected = this.connected.filter(function(c) {
// Close any connections that haven't logged in promptly.
if (!c.user && c.connectTime < limit) {
try {
// Call .close(). Note that that this won't result in the
// object's .connected property being set to false
// immediately, but only after an async callback to
// connection.onEnd() - which will result in another call
// to $.servers.telnet.validate().
c.close();
} catch (e) {
// Connection was already closed. Mark it as such.
c.connected = false;
}
}
return c.connected && (!c.user || c.user.connection === c);
});
};
Object.setOwnerOf($.servers.telnet.validate, $.physicals.Maximilian);
Object.setOwnerOf($.servers.telnet.validate.prototype, $.physicals.Maximilian);
$.servers.telnet.LOGIN_TIMEOUT_MS = 20000;
$.servers.telnet.connected = [];
================================================
FILE: core/core_40_$.startRoom.js
================================================
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Initial starting room for Code City.
*/
//////////////////////////////////////////////////////////////////////
// AUTO-GENERATED CODE FROM DUMP. EDIT WITH CAUTION!
//////////////////////////////////////////////////////////////////////
$.startRoom = (new 'Object.create')($.room);
$.startRoom.location = null;
$.startRoom.contents_ = [];
$.startRoom.contents_.forObj = $.startRoom;
Object.defineProperty($.startRoom.contents_, 'forObj', {writable: false, enumerable: false, configurable: false});
$.startRoom.contents_.forKey = 'contents_';
Object.defineProperty($.startRoom.contents_, 'forKey', {writable: false, enumerable: false, configurable: false});
$.startRoom.name = 'Hangout';
$.startRoom.description = 'A place to hang out, chat, and program.';
$.startRoom.roll = function roll(cmd) {
var memo = {
type: 'iframe',
url: 'https://www.youtube.com/embed/dQw4w9WgXcQ?autoplay=1'
};
this.sendMemo(memo);
};
$.startRoom.roll.verb = 'roll';
$.startRoom.roll.dobj = 'none';
$.startRoom.roll.prep = 'none';
$.startRoom.roll.iobj = 'none';
$.clock = (new 'Object.create')($.thing);
$.clock.name = 'clock';
$.clock.location = $.startRoom;
$.clock.chime = function chime(silent) {
// Chiming only. Timer management all handled by .onTimeout.
var hours = (new Date().getHours() %12) || 12;
var text = [];
for (var i = 0; i < hours; i++) {
text.push('Bong.');
}
this.location.narrate(text.join(' '), undefined, this);
};
Object.setOwnerOf($.clock.chime, $.physicals.Maximilian);
$.clock.contents_ = [];
$.clock.contents_.forObj = $.clock;
Object.defineProperty($.clock.contents_, 'forObj', {writable: false, enumerable: false, configurable: false});
$.clock.contents_.forKey = 'contents_';
Object.defineProperty($.clock.contents_, 'forKey', {writable: false, enumerable: false, configurable: false});
$.clock.validate = function validate() {
$.thing.validate.call(this);
// Reset timer that runs the chime.
this.onTimer();
};
Object.setOwnerOf($.clock.validate, $.physicals.Maximilian);
Object.setOwnerOf($.clock.validate.prototype, $.physicals.Maximilian);
$.clock.onTimer = function onTimer() {
/* Function that creates a thread to call itself at the next hour
* (and calls this.chime() if it is the right time to do so.)
*/
var time = new Date();
// Chime during first minute past the hour. If we got called early
// we'll automatically try again at (hopefully) the correct time.
var doChime = (time.getMinutes() === 0);
// Compute next hour in local timezone.
time.setMilliseconds(0);
time.setSeconds(0);
time.setMinutes(0);
time.setHours(time.getHours() + 1); // Automagically increments date if required.
// Kill any other thread associated with this clock.
clearTimeout(this.thread_);
// Schedule ourselves to be run again at time.
this.thread_ = new Thread(this.onTimer, time - Date.now(), this);
if (doChime) this.chime();
};
Object.setOwnerOf($.clock.onTimer, $.physicals.Maximilian);
Object.setOwnerOf($.clock.onTimer.prototype, $.physicals.Maximilian);
$.clock.movable = false;
$.clock.description = function description() {
return 'It is currently ' + Date();
};
Object.setOwnerOf($.clock.description, $.physicals.Neil);
Object.setOwnerOf($.clock.description.prototype, $.physicals.Neil);
$.clock.svgText = function svgText() {
var svg = 'Translation API Tutorial ',
'This tutorial will teach you how to use the Google machine',
'translation API to create a room that will automatically',
'translate everything said to the language of your choice.
',
'Type continue tutorial to continue.
'
];
break;
case 1:
lines = [
'Step 1: Create a new room ',
'Run the following command:
',
'create $.room as Deutsche Zimmer ',
'(Click to run, or type your own variation.)
',
];
break;
case 2:
lines = [
'Step 2: Move to the newly-created room ',
'You\'ve created a room named "' + this.room.name + '". Now type',
"continue tutorial and you'll be transported there",
'automagically.
',
];
break;
case 3:
lines = [
'Step 3: Give your new room a description',
" You're now in you're newly-created room. Let's give it a",
'description using the eval command:
',
'eval here.description = "Wir sprechen Deutsch hier." ',
];
break;
case 4:
lines = [
'Step 4: Open code editor ',
"We'll use the code editor to add a translate method to this room.",
'When you type continue tutorial the code inspector/editor',
'will open in another tab. (You might need to enable pop-ups!)',
'Click back to this tab to see the next set of instructions.',
];
break;
case 5:
lines = [
'
Step 5: Add a translate() method ',
'Make sure the status bar of the code inspector says',
'$.tutorial.room.translate, then replace "undefined" with the',
'following code (and save it):
',
'',
'function translate(text) {',
' // Try to translate text into German. If successful, return the translation.',
' // If not, narrate an indication of failure and return the original text.',
' try {',
" var json = $.system.xhr('https://translate-service.scratch.mit.edu' +",
" '/translate?language=de&text=' + encodeURIComponent(text));",
' return JSON.parse(json).result;',
' } catch (e) {',
" this.narrate('There is a crackling noise.');",
' return text;',
' }',
'};',
' ',
];
break;
case 6:
lines = [
'Step 6: Test the translate() method ',
'Let\'s use the eval command to test the the new translate',
'method:
',
'eval here.translate("Good morning.") ',
'You should see output that looks like this:
',
'=> "Guten Morgen."
',
];
break;
case 7:
lines = [
'Step 7: Override the "say" verb ',
'Use the top part of the inspector to navigate to the "say"',
'function, and replace it with the following:
',
'',
'function say(cmd) {',
' // Format: "Hello. -or- say Hello.',
' var text = (cmd.cmdstr[0] === \'"\') ? cmd.cmdstr.substring(1) : cmd.argstr;',
' cmd.cmdstr = [];',
' cmd.argstr = this.translate(text);',
' return $.room.say.call(this, cmd);',
'}',
' ',
];
break;
case 8:
lines = [
'Step 8: Test out the new "say" verb ',
'The function you created in the last step, $.tutorial.room.say,',
'overrides the default $.room.say function by translating the text to',
'be said and then passing it along to the latter to actually say.
',
"Let's test it it out by saying something!:
",
'say Now I can speak German! ',
];
break;
case 9:
lines = [
'Step 9: Finish up ',
"Feel free to hang around an play with the room you've created.",
'Can you change the language it translates into?',
'(Hint: look in $.tutorial.room.translate, and remever that "de" is',
'the two-letter code for the German language.)
',
"When you're done, type continue tutorial and you'll",
'be taken back to where you came from. You can delete this room ',
'when you no longer want it by typing destroy ' +
$.Selector.for(this.room).toString() + ' .',
];
break;
case 10:
this.user.moveTo($.startRoom);
this.room = undefined;
// FALLTTHROUGH
default:
lines = [
'
Tutorial Ended ',
"You've either finished the tutorial, or you've found a bug in it.",
'Either way: contratulations!',
'You can always reset tutorial to do it all again.
',
];
}
this.user.readMemo({type: 'html', htmlText: lines.join('\n')});
};
Object.setOwnerOf($.tutorial.show, $.physicals.Maximilian);
$.tutorial.contents_ = [];
$.tutorial.contents_.forObj = $.tutorial;
Object.defineProperty($.tutorial.contents_, 'forObj', {writable: false, enumerable: false, configurable: false});
$.tutorial.contents_.forKey = 'contents_';
Object.defineProperty($.tutorial.contents_, 'forKey', {writable: false, enumerable: false, configurable: false});
$.tutorial.location = undefined;
$.tutorial.user = undefined;
$.tutorial.thread = undefined;
$.tutorial.step = undefined;
$.tutorial.room = undefined;
$.tutorial.origFunc = undefined;
$.physicals.tutorial = $.tutorial;
================================================
FILE: core/core_42_plant.js
================================================
/**
* @license
* Copyright 2018 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Plant demo for Code City.
*/
//////////////////////////////////////////////////////////////////////
// AUTO-GENERATED CODE FROM DUMP. EDIT WITH CAUTION!
//////////////////////////////////////////////////////////////////////
$.seed = (new 'Object.create')($.thing);
$.seed.name = 'Generic Seed';
$.seed.aliases = [];
$.seed.aliases[0] = 'seed';
$.seed.description = 'A harmless looking seed. Try planting it in a pot, then watering it.';
$.seed.svgText = '\n ';
$.pot.stages[5] = '';
$.physicals['Genetics Lab'].contents_ = [];
$.physicals['Genetics Lab'].contents_.forObj = $.physicals['Genetics Lab'];
Object.defineProperty($.physicals['Genetics Lab'].contents_, 'forObj', {writable: false, enumerable: false, configurable: false});
$.physicals['Genetics Lab'].contents_.forKey = 'contents_';
Object.defineProperty($.physicals['Genetics Lab'].contents_, 'forKey', {writable: false, enumerable: false, configurable: false});
$.cage = (new 'Object.create')($.container);
$.cage.name = 'cage';
$.cage.contents_ = [];
$.cage.contents_.forObj = $.cage;
Object.defineProperty($.cage.contents_, 'forObj', {writable: false, enumerable: false, configurable: false});
$.cage.contents_.forKey = 'contents_';
Object.defineProperty($.cage.contents_, 'forKey', {writable: false, enumerable: false, configurable: false});
$.cage.isOpen = true;
$.cage.variation = 1;
$.cage.tempo = 30;
$.cage.maxPopulation = 50;
$.cage.fight = function fight(aggressor, defender) {
var capitalizedAggressorName = $.utils.string.capitalize(String(aggressor)) + '(' + aggressor.size + ' cm)';
var defenderName = String(defender) + '(' + defender.size + ' cm)';
aggressor.aggressiveness--;
var point = Math.floor(Math.random() * (aggressor.size + defender.size));
var victim = null;
if (point > defender.size) {
victim = defender;
} else if (point < defender.size) {
victim = aggressor;
}
if (victim === defender) {
this.location.narrate(capitalizedAggressorName + ' fights and kills ' + defenderName + '.');
} else if (victim === aggressor) {
this.location.narrate(capitalizedAggressorName + ' fights and is killed by ' + defenderName + '.');
} else {
this.location.narrate(capitalizedAggressorName + ' fights ' + defenderName + ' to a draw.');
}
if (victim) {
this.kill(victim);
}
};
Object.setOwnerOf($.cage.fight, $.physicals.Neil);
$.cage.kill = function kill(victim) {
if (!this.isMouse(victim)) {
this.location.narrate('ERROR: Cannot kill ' + String(victim) + " since it doesn't appear to be a mouse in here.");
return;
}
var owner = Object.getOwnerOf(victim);
if (this === $.physicals.cage.mousePrototype) {
// Can't happen. But would be catastrophic, so check anyway.
victim.moveTo(null);
throw Error('Tried to kill the prototype mouse.');
} else if (owner === this) {
// This mouse is a child.
victim.destroy();
} else {
// This mouse belongs to a user.
victim.moveTo(owner);
this.location.narrate($.utils.string.capitalize(String(victim)) + ' is ejected from ' + String(this));
}
};
Object.setOwnerOf($.cage.kill, $.physicals.Neil);
$.cage.breed = function breed(mother, father) {
mother.fertility--;
father.fertility--;
if (mother.fertility < 0 || father.fertility < 0) {
this.location.narrate('Mating failed since one of them is sterile.');
return;
}
if (mother.sex === father.sex) {
var sex = mother.sex;
if (sex === 'M') {
sex = 'male';
} else if (sex === 'F') {
sex = 'female';
}
this.location.narrate('Mating failed since both are ' + mother.sex + '.');
return;
}
var mice = this.getContents();
if (mice.length >= this.maxPopulation) {
var oldest = mice[0];
for (var i = 1; i < mice.length; i++) {
if (mice[i].generation < oldest.generation) {
oldest = mice[i];
}
}
this.location.narrate('Maximum population (' + this.maxPopulation, ') reached; ' + String(oldest) + ' dies of old age.');
this.kill(oldest);
}
var kid = Object.create(this.mousePrototype);
Object.setOwnerOf(kid, this);
kid.init(mother, father, this.variation);
kid.moveTo(this);
this.location.narrate($.utils.string.capitalize(String(kid)) + ' has been born to ' + String(mother) + ' & ' + String(father) + '.');
this.tasks.push(setTimeout(this.life.bind(this, kid), 0));
};
Object.setOwnerOf($.cage.breed, $.physicals.Neil);
$.cage.tasks = [];
$.cage.setOpen = function setOpen(newState) {
var success = Object.getPrototypeOf($.cage).setOpen.call(this, newState);
if (!success) {
return false;
}
while (this.tasks.length) {
clearTimeout(this.tasks.pop());
}
var location = this.location;
var mice = this.getContents();
if (this.isOpen) {
for (var i = mice.length - 1; i >= 0; i--) {
this.kill(mice[i]);
}
location.narrate('All mice in ' + String(this) + ' have been exterminated.');
} else {
location.narrate($.utils.string.capitalize(String(this)) + ' starts running.');
for (var i = mice.length - 1; i >= 0; i--) {
var mouse = mice[i];
if (this.isMouse(mouse)) {
location.narrate($.utils.string.capitalize(String(mouse)) + ' starts moving.');
this.startMouse(mouse);
} else {
location.narrate($.utils.string.capitalize(String(mouse)) + " isn't a valid mouse and gets thrown out.");
mouse.moveTo(location);
}
}
}
return true;
};
Object.setOwnerOf($.cage.setOpen, $.physicals.Maximilian);
Object.setOwnerOf($.cage.setOpen.prototype, $.physicals.Maximilian);
$.cage.life = function life(mouse) {
if (!this.isMouse(mouse)) {
throw Error(String(mouse) + ' is not a valid mouse.');
}
var capitalizedMouseName = $.utils.string.capitalize(String(mouse));
var self = 'itself';
if (mouse.sex === 'M') {
self = 'himself';
} else if (mouse.sex === 'F') {
self = 'herself';
}
while (true) {
this.tasks.push(suspend(Math.random() * this.tempo * 1000));
if (mouse.location !== this) {
return;
}
if (mouse.aggressiveness < 1 && mouse.fertility < 1) {
this.location.narrate(capitalizedMouseName + ' dies after a productive life.');
this.kill(mouse);
return;
}
if (mouse.aggressiveness > 0) {
try {
var victim = mouse.pickFight();
} catch (e) {
this.kill(mouse);
this.location.narrate(capitalizedMouseName + ' threw "' + e + '" in .pickFight function.');
this.location.narrate(capitalizedMouseName + ' is being executed to put it out of its misery.');
}
if (!victim) {
this.location.narrate(capitalizedMouseName + ' decides not to fight ever again.');
mouse.aggressiveness = 0;
} else if (mouse === victim) {
this.location.narrate(capitalizedMouseName + ' fights and kills ' + self + '.');
this.kill(mouse);
return;
} else if (this.isMouse(victim)) {
this.fight(mouse, victim);
} else {
this.location.narrate(capitalizedMouseName + ' returned "' + String(victim) + '" from .pickFight function.');
this.location.narrate(capitalizedMouseName + ' is being executed to put it out of its misery.');
this.kill(mouse);
return;
}
} else if (mouse.fertility > 0) {
try {
var target = mouse.proposeMate();
} catch (e) {
this.kill(mouse);
this.location.narrate($.utils.string.capitalize(String(target)) + ' threw "' + e + '" in .proposeMate function.');
this.location.narrate($.utils.string.capitalize(String(mouse)) + ' is being executed to put it out of its misery.');
}
if (!target) {
this.location.narrate(capitalizedMouseName + ' decides not to mate ever again.');
mouse.fertility = 0;
} else if (mouse === target) {
mouse.fertility--;
this.location.narrate(capitalizedMouseName + ' is caught trying to mate with ' + self + '.');
} else if (this.isMouse(target)) {
try {
var answer = target.acceptMate(mouse);
} catch (e) {
this.location.narrate($.utils.string.capitalize(String(target)) + ' threw "' + e + '" in .acceptMate function.');
this.location.narrate($.utils.string.capitalize(String(target)) + ' is being executed to put it out of its misery.');
this.kill(target);
}
if (answer) {
this.location.narrate(capitalizedMouseName + ' asked ' + String(target) + ' to mate. The answer is YES!');
this.breed(mouse, target);
} else {
this.location.narrate(capitalizedMouseName + ' asked ' + String(target) + ' to mate. The answer is NO!');
}
} else {
this.location.narrate(capitalizedMouseName + ' returned "' + String(target) + '" from .proposeMate function.');
this.location.narrate(capitalizedMouseName + ' is being executed to put it out of its misery.');
this.kill(mouse);
return;
}
}
}
};
Object.setOwnerOf($.cage.life, $.physicals.Neil);
$.cage.willAccept = function willAccept(what, src) {
// Returns true iff this is willing to accept what arriving from src.
//
// This function (or its overrides) MUST NOT have any kind of
// observable side-effect (making noise, causing some other action,
// etc.).
return this.isOpen || (this.mousePrototype.isPrototypeOf(what) && !src);
};
Object.setOwnerOf($.cage.willAccept, $.physicals.Neil);
Object.setOwnerOf($.cage.willAccept.prototype, $.physicals.Maximilian);
$.cage.mousePrototype = (new 'Object.create')($.thing);
$.cage.mousePrototype.name = 'Genetic Mouse Prototype';
$.cage.mousePrototype.location = null;
$.cage.mousePrototype.contents_ = [];
$.cage.mousePrototype.contents_.forObj = $.cage.mousePrototype;
Object.defineProperty($.cage.mousePrototype.contents_, 'forObj', {writable: false, enumerable: false, configurable: false});
$.cage.mousePrototype.contents_.forKey = 'contents_';
Object.defineProperty($.cage.mousePrototype.contents_, 'forKey', {writable: false, enumerable: false, configurable: false});
$.cage.mousePrototype.size = 10;
$.cage.mousePrototype.generation = 0;
$.cage.mousePrototype.sex = NaN;
$.cage.mousePrototype.proposeMate = function proposeMate() {
// Return who you'd like to mate with!
// Returning null will pass on this mating and all future ones.
// Reprogram this function to make it smarter!
var mice = this.location.getContents();
return mice[Math.floor(Math.random() * mice.length)];
};
Object.setOwnerOf($.cage.mousePrototype.proposeMate, $.physicals.Neil);
$.cage.mousePrototype.acceptMate = function acceptMate(whom) {
// The mouse 'whom' wishes to mate with you!
// Return true to mate with it, or false to tell it to go away.
// Reprogram this function to make it smarter!
return Math.random() > 0.5;
};
Object.setOwnerOf($.cage.mousePrototype.acceptMate, $.physicals.Neil);
$.cage.mousePrototype.pickFight = function pickFight() {
// Return who you'd like to fight with!
// Returning null will pass on this fight and all future ones.
// The bigger mouse (based on .size) usually wins.
// Reprogram this function to make it smarter!
var mice = this.location.getContents();
return mice[Math.floor(Math.random() * mice.length)];
};
Object.setOwnerOf($.cage.mousePrototype.pickFight, $.physicals.Neil);
$.cage.mousePrototype.toString = function toString() {
var prototype = Object.getPrototypeOf(this);
var pickFightOwner = (this.pickFight === prototype.pickFight) ?
null : Object.getOwnerOf(this.pickFight);
var proposeMateOwner = (this.proposeMate === prototype.proposeMate) ?
null : Object.getOwnerOf(this.proposeMate);
var acceptMateOwner = (this.acceptMate === prototype.acceptMate) ?
null : Object.getOwnerOf(this.acceptMate);
return this.name + ' (' + String(pickFightOwner) +
'/' + String(proposeMateOwner) +
'/' + String(acceptMateOwner) + ')';
};
Object.setOwnerOf($.cage.mousePrototype.toString, $.physicals.Neil);
$.cage.mousePrototype.init = function init(mother, father, variation) {
// Blend together the numeric attributes from the parents.
var thisMouse = this;
function blend(name) {
var average = (mother[name] + father[name]) / 2;
var mutation = Math.random() * 2 * variation - variation;
thisMouse[name] = Math.max(1, Math.round(average + mutation));
}
blend('size');
blend('startFertility');
this.fertility = this.startFertility;
blend('startAggressiveness');
this.aggressiveness = this.startAggressiveness;
this.generation = 1 + Math.max(mother.generation, father.generation);
// Random sex and name.
this.sex = Math.random() > 0.5 ? 'M' : 'F';
var name = '';
for (var i = 0; i < 6; i++) {
var letters = ((i % 2) == (this.sex === 'F') ? $.utils.string.VOWELS : $.utils.string.CONSONANTS);
name += $.utils.string.randomCharacter(letters);
}
this.setName($.utils.string.capitalize(name), /*tryAlternative:*/ true);
// Copy the three 'genetic' functions.
// Take two from one parent, and one from the other.
var f1 = Math.floor(Math.random() * 2);
var f2 = Math.floor(Math.random() * 2);
var f3 = (f1 === f2) ? 1 - f1 : Math.floor(Math.random() * 2);
this.proposeMate = (f1 ? mother : father).proposeMate;
this.acceptMate = (f2 ? mother : father).acceptMate;
this.pickFight = (f3 ? mother : father).pickFight;
};
Object.setOwnerOf($.cage.mousePrototype.init, $.physicals.Neil);
$.cage.mousePrototype.svgText = 'Code City: Genetics Editor \n
\n \n Save All \n
\n \n \n .pickFight.proposeMate.acceptMateReference\n
\n \n
\n
\n
\n
\n
Properties on the mice:
\n
\n .generation → integer \n The initial mice placed in the cage are generation 0.\n Their children are generation 1, and so on. \n .sex → 'M' or 'F' or NaN \n Generation 0 mice have a sex of NaN, which means they are hermaphrodites\n and can be both male and female as needed for any given mating.\n Subsequent generations have a sex set randomly at birth to be either \"M\" or \"F\".\n JavaScript tip: NaN does not equal NaN. \n .size → integer \n Larger mice are more likely to win a fight against a smaller mouse.\n Generation 0 mice are all 10 cm. Subsequent births are the average of\n their parents' sizes, plus/minus a random variation. \n .startFertility → integer \n The total number of attempts a mouse has to produce offspring during its life.\n Generation 0 mice all have a startFertility of 4. Subsequent births\n are the average of their parents' fertility, plus/minus a random variation. \n .fertility → integer \n The number of remaining attempts a mouse has to produce offspring.\n This is set to startFertility at birth, and decrements with every mating attempt. \n .startAggressiveness → integer \n The total number of fights a mouse may start during its life.\n Generation 0 mice all have a startAggressiveness of 2. Subsequent births\n are the average of their parents' aggressiveness, plus/minus a random variation. \n .aggressiveness → integer \n The number of remaining fights a mouse may start. Generation 0 mice\n have their aggressiveness set to 0 (they can't start fights). Subsequent births\n have their aggressiveness set to startAggressiveness, and decrements with every\n fight started. \n .location → cage \n This is the cage in which the mouse is located. The cage has a getContents function\n that returns an array of all mice. this.location.getContents() will always include you. \n \n
Functions on the mice:
\n
\n .pickFight → mouse or null \n Return the mouse you'd like to fight with.\n Returning null will pass on this fight and all future ones.\n The bigger mouse (based on .size) usually wins, ties are possible.\n The loser (if there is one) dies and is removed from the cage. \n .proposeMate() → mouse or null \n Return the mouse you'd like to mate with.\n Returning null will pass on this mating and all future ones.\n Only opposite-sex matings (or those involving a NaN hermaphrodite) will produce a child.\n Each proposal decrements fertility by one, regardless of whether mating is successful. \n .acceptMate(mouse) → boolean \n The mouse passed in as the first variable wishes to mate with you.\n Return true to mate with it, or false to tell it to go away. Your fertility decrements\n by one if you say yes. \n Ownership \n The owner of any function can be obtained using Object.getOwnerOf(...). This\n might be used to conduct surveys of the genes currently in the cage, and adjusting\n behaviours accordingly. \n \n
Lifecycle
\n
\n Each mouse (other than generation 0) is given a number of opportunites to\n fight other mice. The pickFight functions on each mouse are called one by\n one as many times as needed. \n Each mouse is then given a number of opportunities to mate other mice.\n The proposeMate functions on each mouse are called one by one as many times\n as needed. When a mouse returns another mouse it wishes to mate with, that\n mouse's acceptMate function is called. If this call returns true, then a mating\n is attempted. \n If a mating is successful (proposed mouse says yes, proposed mouse has remaining\n fertility, mice have opposite genders or are hermaphrodites), a new mouse is born.\n This mouse will inherit traits randomly from its two parents, namely the properties\n and the three functions. \n Shortly after a mouse has run out of all its opportunities to fight and all\n its opportunities to mate, it dies and is remove from the cage. \n \n
Your mouse will die. The question is can your genes (functions) spread across the\n population. There are a lot of strategies, have fun!
\n
\n
".
this.lastActivated = Date.now()
// Process command.
this.onCommand(m[1] || '');
};
Object.setOwnerOf($.assistant.onMemo, $.physicals.Maximilian);
$.assistant.say = function say(speech) {
if (!this.location) return;
var memo = {
type: 'say',
source: this,
where: this.location,
text: speech
};
this.location.sendMemo(memo);
};
$.assistant.onCommand = function onCommand(command) {
/* Attempt to find a handler for command, by calling methods on this
* named cmd_* until one of them returns true.
*/
suspend(2000);
var raw = String(command);
command = command.replace(/[.,!?]*$/, ''); // Trim trailing punctuation.
command = command.replace(/\s+/, ' '); // Normalise whitespace.
if (!command) {
this.say('How can I help?');
return;
}
// Look for properties on this named 'cmd_'.
var done = false;
for (var key in this) {
if (key.lastIndexOf('cmd_', 0) !== 0) continue;
var func = this[key];
if (typeof func !== 'function') continue;
if (func.call(this, command, raw)) {
done = true;
break;
}
}
if (!done) this.say('Sorry, I don\'t understand "' + command + '".');
};
Object.setOwnerOf($.assistant.onCommand, $.physicals.Maximilian);
$.assistant.cmd_time = function cmd_time(command, raw) {
// First check to see if the command looked like a request for the time.
if (!command.match(/what time is it|what('s| is) the time/i)) return false;
// It did. Tell the time.
this.say('The current time is ' + new Date().toTimeString());
return true;
};
Object.setOwnerOf($.assistant.cmd_time, $.physicals.Maximilian);
Object.setOwnerOf($.assistant.cmd_time.prototype, $.physicals.Maximilian);
$.assistant.cmd_translate = function cmd_translate(command, raw) {
// First check to see if the command looked like a request to translate some text.
var m = raw.match(/(?:what\s+is|how\s+do\s+you\s+say)\s+(?:"([^"]+)"|(.*))\s+in\s+(\w+)/i);
if (!m) return false; // Nope; try another handler.
// It did. Try to tranlsate it.
var phrase = m[1] || m[2];
var code = this.cmd_translate.languages[m[3].toLowerCase()];
var language = $.utils.string.capitalize(m[3]);
if (!code) {
this.say("Sorry; I don't know how to speak " + language);
return true;
}
try {
var translation = $.utils.string.translate(phrase, code);
this.say('"' + phrase + '" in ' + language + ' is "' + translation + '"');
} catch (e) {
this.say('Sorry: I seem to have forotten how to speak ' + language + '.');
}
return true;
};
Object.setOwnerOf($.assistant.cmd_translate, $.physicals.Maximilian);
Object.setOwnerOf($.assistant.cmd_translate.prototype, $.physicals.Maximilian);
$.assistant.cmd_translate.languages = (new 'Object.create')(null);
$.assistant.cmd_translate.languages.german = 'de';
$.assistant.cmd_translate.languages.italian = 'it';
$.assistant.cmd_translate.languages.french = 'fr';
$.assistant._README = 'The assistant works as follows:\n\nThe .onMemo handler looks for a "say" memo from $.user. If one is received, and no other has been received too recently, it calls .onCommand, passing it what was said.\n\nThe .onCommand handler waits a respectable amount of time (2s) and then attempts to find a handler for the command. It canonicalises the command, and then iterates through its own and inherited properties. Any property whose name begins with "cmd_" and whose value is a function will get called, being passed the canonicalised and raw command.\n\nEach cmd_* method is expected to do some kind of string match against the command (perhaps using a RegExp) to see if if it knows how to handle that sort of command. If it does, it should respond (perhaps using the .say method to reply to the user) and return true. If it does not know how to handle the command, it should return false.\n\n.onCommand will iterate through the .cmd_* methods until one of them returns true. If none do it will announce that it did not understand the command.';
$.assistant.description = "A squat grey cylinder that looks like it's listening.";
$.assistant.location = undefined;
$.assistant.lastActivated = undefined;
$.physicals.assistant = $.assistant;
================================================
FILE: core/core_45_Challenge_Room.js
================================================
/**
* @license
* Copyright 2020 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Challenge room demo for Code City.
*/
//////////////////////////////////////////////////////////////////////
// AUTO-GENERATED CODE FROM DUMP. EDIT WITH CAUTION!
//////////////////////////////////////////////////////////////////////
$.physicals['Challenge room'] = (new 'Object.create')($.room);
Object.setOwnerOf($.physicals['Challenge room'], $.physicals.Neil);
$.physicals['Challenge room'].name = 'Challenge room';
$.physicals['Challenge room'].location = null;
$.physicals['Challenge room'].contents_ = [];
$.physicals['Challenge room'].contents_[0] = (new 'Object.create')($.thing);
$.physicals['Challenge room'].contents_[1] = (new 'Object.create')($.container);
$.physicals['Challenge room'].contents_[2] = (new 'Object.create')($.thing);
$.physicals['Challenge room'].contents_.forObj = $.physicals['Challenge room'];
Object.defineProperty($.physicals['Challenge room'].contents_, 'forObj', {writable: false, enumerable: false, configurable: false});
$.physicals['Challenge room'].contents_.forKey = 'contents_';
Object.defineProperty($.physicals['Challenge room'].contents_, 'forKey', {writable: false, enumerable: false, configurable: false});
$.physicals['Challenge room'].reset = function reset(cmd) {
this.switch.state = false;
this.switch.movable = true;
this.switch.moveTo(this);
this.switch.movable = false;
for (var x = 0; x < 1000; x++) {
this.safe.setOpen(true, x);
}
this.food.moveTo(this.safe);
this.food.svgText = this.food.svgTextReset;
this.safe.setOpen(false);
this.safe.crack = this.safe.crackReset;
this.chest.movable = true;
this.chest.moveTo(this);
this.chest.movable = false;
this.chest.setOpen(true);
this.safe.moveTo(this.chest);
this.chest.setOpen(false);
this.girl.movable = true;
this.girl.moveTo(this);
this.girl.movable = false;
this.girl.attempts = 0;
if (cmd) {
this.sendScene(cmd.user, true);
this.narrate(cmd.user.name + ' resets ' + String(this) + '.', cmd.user);
cmd.user.narrate('You reset ' + String(this) + '.');
}
};
Object.setOwnerOf($.physicals['Challenge room'].reset, $.physicals.Neil);
Object.setOwnerOf($.physicals['Challenge room'].reset.prototype, $.physicals.Neil);
$.physicals['Challenge room'].reset.verb = 'reset';
$.physicals['Challenge room'].reset.dobj = 'none';
$.physicals['Challenge room'].reset.prep = 'none';
$.physicals['Challenge room'].reset.iobj = 'none';
$.physicals['Challenge room'].chest = $.physicals['Challenge room'].contents_[1];
$.physicals['Challenge room'].safe = (new 'Object.create')($.container);
$.physicals['Challenge room'].girl = $.physicals['Challenge room'].contents_[2];
$.physicals['Challenge room'].food = (new 'Object.create')($.thing);
$.physicals['Challenge room'].switch = $.physicals['Challenge room'].contents_[0];
$.physicals['Challenge room'].svgTextNight = '\n ';
$.physicals['light switch'].getCommands = function getCommands(who) {
var commands = $.thing.getCommands.call(this, who);
if (this.state) {
commands.push('turn off ' + String(this));
} else {
commands.push('turn on ' + String(this));
}
return commands;
};
Object.setOwnerOf($.physicals['light switch'].getCommands, $.physicals.Neil);
Object.setOwnerOf($.physicals['light switch'].getCommands.prototype, $.physicals.Maximilian);
$.physicals['light switch'].aliases = [];
Object.setOwnerOf($.physicals['light switch'].aliases, $.physicals.Maximilian);
$.physicals['light switch'].aliases[0] = 'lightswitch';
$.physicals['light switch'].aliases[1] = 'switch';
$.physicals['light switch'].movable = false;
$.physicals['light switch'].svgTextDay = '\n ';
$.physicals.chest = $.physicals['Challenge room'].chest;
Object.setOwnerOf($.physicals.chest, $.physicals.Neil);
$.physicals.chest.name = 'chest';
$.physicals.chest.location = $.physicals['Challenge room'];
$.physicals.chest.contents_ = [];
$.physicals.chest.contents_[0] = $.physicals.chest.location.safe;
$.physicals.chest.contents_.forObj = $.physicals.chest;
Object.defineProperty($.physicals.chest.contents_, 'forObj', {writable: false, enumerable: false, configurable: false});
$.physicals.chest.contents_.forKey = 'contents_';
Object.defineProperty($.physicals.chest.contents_, 'forKey', {writable: false, enumerable: false, configurable: false});
$.physicals.chest.svgTextClosed = '<%= this.name %> Home \n\n \n \n<% include(\'footer\'); %>';
$.securityCourse.storePagePrototype.wwwBasket = '<% include(\'header\'); %>\n<%= this.name %> Basket \n\n\n<%\nvar staticUrl = request.hostUrl(\'static\');\nvar total = 0; \nvar order = {};\nfor (var param in request.parameters) {\n if (!param.startsWith(\'item\')) continue;\n var item = this.inventory[Number(param.substring(4))];\n var quant = Number(request.parameters[param]);\n if (!item || !quant) continue;\n var lineTotal = quant * item.price;\n total += lineTotal;\n order[item.id] = quant;\n%>\n\n <%=item.name%> \n <%=quant%> x <%=item.price%> = <%=lineTotal%> \n \n<% } %>\n
\n\nTotal: <%=total%>
\n\n \n \n<% include(\'footer\'); %>';
$.securityCourse.storePagePrototype.wwwConfirm = "<% include('header'); %>\n<%= this.name %> Confirm \n\nThank you <%=request.parameters.name%>!
\n
Your credit card has been billed for <%=request.parameters.total%> .
\n
Your order will be shipped as soon as this store's massive security holes have been patched.
\n\n<% include('footer'); %>";
$.securityCourse.storePagePrototype.escape = $.utils.html.escape;
$.securityCourse.storePagePrototype.header = '\n \n Security Store \n engEDU Security Course \n \n engEDU Security Course \n \n <% if (!storeKey) { %>\n \n
\n \n <% } %>\n\n <% if (Object.getOwnPropertyNames(storeHosts).length) { %>\n \n
\n \n <% } %>\n \n \n
\n \n';
$.securityCourse.storeHosts = (new 'Object.create')(null);
$.hosts.root['/securitycourse'] = $.securityCourse;
================================================
FILE: core/core_99_startup.js
================================================
/**
* @license
* Copyright 2020 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Start core database. Note that, unlike most of the
* rest of the files in the core/ directory, this is hand-written.
*
* It assumed this file will be used when starting a full database
* dump; for that, a file in database/, generated by dump, will
* restart listeners intead.
*/
/* Optional (but recommended) configuration. The web server is
* capable of guessing its own hostname, but will be more efficient
* and secure if its configuration is specified explicitly.
*/
/* Set .hostname to the canonical hostname (including the port number,
* if non-default).
*/
// $.hosts.root.hostname = 'example.codecity.world';
// $.hosts.root.hostname = 'localhost:8080';
/* If your host has more than one name, set .hostRegExp to a regular
* expression that matches all valid name+port combinations for this
* host. It is recommended that it end with /$/, but do NOT start it
* with /^/ unless you want to break wildcard subdomains. Make sure
* it matches .hostname!
*/
// Accept either of two different hostnames.
// $.hosts.root.hostRegExp = /example.codecity.world$|codecity.example.com$/;
// Match any TLD and optional port.
// $.hosts.root.hostRegExp = /example.codecity.\w+(?::\d+)?$/;
/* Set .pathToSubdomain to true if you don't have a wildcard DNS entry
* and wildcard TLS certificate for your hostname (false if you do);
* this will enable accessing pages usually served on subdomains (such
* as the code editor) via the root hostname instead.
*
* Normally the nginx reverse proxy sends a CodeCity-pathToSubdomain
* header which will automatically enable or disable this feature, but
* you can override it here.
*/
// $.hosts.root.pathToSubdomain = false;
// Set up.
$.system.onStartup();
// Tidy up.
$.clock.movable = true;
$.clock.moveTo($.startRoom);
$.clock.movable = false;
$.tutorial.moveTo($.startRoom);
$.tutorial.reset();
$.pot.moveTo($.startRoom);
$.pot.stage = 0;
$.seed.moveTo($.startRoom);
$.thrower.moveTo($.startRoom);
$.cage.moveTo($.physicals['Genetics Lab']);
$.assistant.moveTo($.startRoom);
================================================
FILE: core/dump_spec.json
================================================
[
{
"options": {"skipBindings": ["lastModifiedTime", "lastModifiedUser"]}
}, {
"header": [
"/**",
" * @license",
" * Copyright Google LLC",
" *",
" * Licensed under the Apache License, Version 2.0 (the \"License\");",
" * you may not use this file except in compliance with the License.",
" * You may obtain a copy of the License at",
" *",
" * http://www.apache.org/licenses/LICENSE-2.0",
" *",
" * Unless required by applicable law or agreed to in writing, software",
" * distributed under the License is distributed on an \"AS IS\" BASIS,",
" * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.",
" * See the License for the specific language governing permissions and",
" * limitations under the License.",
" */",
"",
"/**",
" * @fileoverview ",
" */",
"",
"//////////////////////////////////////////////////////////////////////",
"// AUTO-GENERATED CODE FROM DUMP. EDIT WITH CAUTION!",
"//////////////////////////////////////////////////////////////////////",
"\n"
],
"filename": "../var/dump/core_00_es5.js",
"headerSubs": {
"": "2017",
"": [
"Load builtins and add polyfills to bring the server's partial",
" * JavaScript implementation up to ECMAScript 5.1 (or close to it)."
]
},
"contents": [
"Object",
"Function",
"Array",
"String",
"Boolean",
"Number",
"Date",
"RegExp",
"Error",
"EvalError",
"RangeError",
"ReferenceError",
"SyntaxError",
"TypeError",
"URIError",
"Math",
"JSON",
"decodeURI",
"decodeURIComponent",
"encodeURI",
"encodeURIComponent",
"escape",
"isFinite",
"isNaN",
"parseFloat",
"parseInt",
"unescape"
]
}, {
"filename": "../var/dump/core_00_es6.js",
"headerSubs": {
"": "2017",
"": [
"Load builtins and add polyfills to bring the server's partial",
" * JavaScript implementation to include some features of ECMAScript 6."
]
},
"contents": [
"Object.is",
"Object.assign",
"Object.setPrototypeOf",
"Array.from",
"Array.prototype.find",
"Array.prototype.findIndex",
"String.prototype.endsWith",
"String.prototype.includes",
"String.prototype.repeat",
"String.prototype.startsWith",
"Number.isFinite",
"Number.isNaN",
"Number.isSafeInteger",
"Number.EPSILON",
"Number.MAX_SAFE_INTEGER",
"Math.sign",
"Math.trunc",
"WeakMap"
]
}, {
"filename": "../var/dump/core_00_es7.js",
"headerSubs": {
"": "2017",
"": [
"Load builtins and add polyfills to bring the server's partial",
" * JavaScript implementation to include some features of ECMAScript 7."
]
},
"contents": [
"Array.prototype.includes"
]
}, {
"filename": "../var/dump/core_00_esx.js",
"headerSubs": {
"": "2017",
"": [
"Load builtins and add polyfills for Code City-specific extensions to",
" * JavaScript."
]
},
"contents": [
"Object.getOwnerOf",
"Object.setOwnerOf",
"Thread",
"PermissionError",
"Array.prototype.join",
"suspend",
"setTimeout",
"clearTimeout"
]
},
{
"filename": "core_10_base.js",
"headerSubs": {
"": "2017",
"": "Database core for Code City."
},
"prune": ["$.system.onStartup.thread_"],
"contents": [
"perms",
"setPerms",
{"path": "$", "do": "DONE"},
"$.root",
{"path": "$.physicals", "do": "DONE"},
{"path": "$.physicals.Maximilian", "do": "DONE"},
{"path": "$.physicals.Neil", "do": "DONE"},
"$.system",
"user",
{"path": "$.utils", "do": "DONE"},
{"path": "$.utils.validate", "do": "DONE"},
{"path": "$.servers", "do": "DONE"}
]
}, {
"filename": "core_11_$.utils.js",
"headerSubs": {
"": "2020",
"": "Basic utilities for Code City."
},
"contents": [
"$.utils",
"$.utils.array",
"$.utils.object",
"$.utils.string"
]
}, {
"filename": "core_12_$.utils.code.js",
"headerSubs": {
"": "2018",
"": "Code utilities for Code City."
},
"contents": ["$.utils.code"]
}, {
"filename": "core_13_$.Selector.js",
"headerSubs": {
"": "2018",
"": "Selector implementation for Code City core."
},
"pruneRest": ["$.Selector.cache_", "$.Selector.sortByBadness.cache_"],
"contents": [
"$.Selector",
"$.utils.Binding",
{"path": "$.Selector.cache_", "do": "DONE"},
{"path": "$.Selector.sortByBadness.cache_", "do": "DONE"}
]
},
{
"filename": "core_20_$.utils.html.js",
"headerSubs": {
"": "2018",
"": "HTML utilities for Code City."
},
"contents": ["$.utils.html"]
}, {
"filename": "core_21_$.jssp.js",
"headerSubs": {
"": "2017",
"": "JavaScript Server Pages for Code City."
},
"contents": ["$.jssp"]
}, {
"filename": "core_22_$.connection.js",
"headerSubs": {
"": "2017",
"": "Connection object for Code City."
},
"contents": ["$.connection"]
}, {
"filename": "core_23_$.servers.http.js",
"headerSubs": {
"": "2017",
"": "Webserver for Code City."
},
"contents": [
"$.utils.url",
"$.servers.http",
{"path": "$.servers.http.hosts", "do": "DONE"}
]
}, {
"filename": "core_24_$.hosts.js",
"headerSubs": {
"": "2017",
"": "Host objects for Code City."
},
"contents": [
{"path": "$.hosts", "do": "DONE"},
{"path": "$.hosts.root", "do": "DONE"},
{"path": "$.hosts.root.subdomains", "do": "DONE"},
"$.hosts.root['/']",
"$.hosts.root['/mirror']",
"$.hosts.root['/robots.txt']",
"$.hosts.system",
"$.hosts.dummy",
"$.hosts.root.subdomains.system",
"$.hosts.root.subdomains.connect",
"$.hosts.root.subdomains.login",
"$.hosts.root.subdomains.mobwrite",
"$.hosts.root.subdomains.static",
"$.hosts.root.subdomains.system",
{"path": "$.servers.http.hosts[0]", "do": "DONE"}
]
}, {
"filename": "core_25_$.db.tempId.js",
"headerSubs": {
"": "2018",
"": "Temporary ID database for Code City."
},
"contents": [
{"path": "$.db", "do": "DONE"},
"$.db.tempId",
{"path": "$.db.tempId.tempIds_", "do": "DONE"},
{"path": "$.db.tempId.cleanThread_", "do": "DECL"}
]
}, {
"filename": "core_25_$.userDatabase.js",
"headerSubs": {
"": "2017",
"": "User database for Code City."
},
"contents": [
"$.userDatabase",
{"path": "$.userDatabase.byMd5", "do": "DONE"}
]
}, {
"filename": "core_26_inline_editor.js",
"headerSubs": {
"": "2017",
"": "Inline code editor for Code City."
},
"contents": [
{"path": "$.hosts.code", "do": "DONE"},
"$.hosts.code['/inlineEdit']",
{"path": "$.hosts.root.subdomains.code", "do": "DONE"}
]
}, {
"filename": "core_27_editor.js",
"headerSubs": {
"": "2018",
"": "Web-based code explorer/editor for Code City."
},
"contents": [
"$.hosts.code"
]
}, {
"filename": "core_28_$.servers.eval.js",
"headerSubs": {
"": "2020",
"": "Eval server for Code City."
},
"contents": [
"$.servers.eval"
]
},
{
"filename": "core_30_$.utils.command.js",
"headerSubs": {
"": "2017",
"": "Command parser for Code City"
},
"contents": ["$.utils.command"]
}, {
"filename": "core_31_$.utils_world.js",
"headerSubs": {
"": "2017",
"": "World-related utils for Code City."
},
"contents": [
"$.utils.commandMenu",
"$.utils.replacePhysicalsWithName"
]
}, {
"filename": "core_32_physical.js",
"headerSubs": {
"": "2017",
"": "Physical object prototype for Code City."
},
"contents": [
"$.physical",
{"path": "$.physicals", "do": "DONE"},
{"path": "$.physicals['Physical object prototype']", "do": "DONE"},
"$.utils.validate.physicals",
"$.garbage"
]
}, {
"filename": "core_33_world.js",
"headerSubs": {
"": "2017",
"": "Generic physical object types for Code City."
},
"contents": [
"$.user",
"$.room",
"$.thing",
"$.container",
{"path": "$.physicals['User prototype']", "do": "DONE"},
{"path": "$.physicals['Room prototype']", "do": "DONE"},
{"path": "$.physicals['Thing prototype']", "do": "DONE"},
{"path": "$.physicals['Container prototype']", "do": "DONE"}
]
}, {
"filename": "core_34_$.servers.login.js",
"headerSubs": {
"": "2021",
"": "Login service backend server for Code City."
},
"contents": [
"$.servers.login"
]
}, {
"filename": "core_34_$.servers.telnet.js",
"headerSubs": {
"": "2017",
"": "Telnet server for Code City."
},
"pruneRest": ["$.servers.telnet.connected"],
"contents": [
"$.servers.telnet",
{"path": "$.servers.telnet.connected", "do": "DONE"}
]
},
{
"headerSubs": {
"": "2017",
"": "Initial starting room for Code City."
},
"filename": "core_40_$.startRoom.js",
"prune": ["$.clock.thread_"],
"contents": [
{"path": "$.startRoom", "do": "DONE"},
"$.startRoom{proto}",
"$.startRoom{owner}",
"$.startRoom.location",
{"path": "$.startRoom.contents_", "do": "DONE"},
{"path": "$.startRoom.contents_.forObj", "do": "DONE"},
{"path": "$.startRoom.contents_.forKey", "do": "DONE"},
"$.startRoom.name",
"$.startRoom.description",
"$.startRoom.roll",
"$.clock",
{"path": "$.clock.thread_", "do": "DONE"}
]
}, {
"headerSubs": {
"": "2018",
"": "Translation room and tutorial demo for Code City."
},
"filename": "core_41_deutsche_zimmer.js",
"contents": [
"$.physicals['Das deutsche Zimmer']",
"$.tutorial",
{"path": "$.tutorial.location", "do": "DECL"},
{"path": "$.tutorial.user", "do": "DECL"},
{"path": "$.tutorial.thread", "do": "DECL"},
{"path": "$.tutorial.step", "do": "DECL"},
{"path": "$.tutorial.room", "do": "DECL"},
{"path": "$.tutorial.origFunc", "do": "DECL"},
{"path": "$.physicals.tutorial", "do": "DONE"}
]
}, {
"filename": "core_42_plant.js",
"headerSubs": {
"": "2018",
"": "Plant demo for Code City."
},
"contents": [
"$.seed",
{"path": "$.seed.location", "do": "DECL"},
{"path": "$.physicals['Generic Seed']", "do": "DONE"},
"$.pot",
{"path": "$.pot.location", "do": "DECL"},
{"path": "$.pot.seed", "do": "DECL"},
{"path": "$.pot.stage", "do": "DECL"},
"$.pot.stages",
{"path": "$.physicals['flower pot']", "do": "DONE"},
"$.thrower",
{"path": "$.thrower.location", "do": "DECL"},
{"path": "$.thrower.savedSvg", "do": "DECL"},
{"path": "$.physicals['a flame thrower']", "do": "DONE"}
]
}, {
"filename": "core_43_genetics_lab.js",
"headerSubs": {
"": "2020",
"": "Genetics lab demo for Code City."
},
"contents": [
"$.physicals['Genetics Lab']",
{"path": "$.physicals['Genetics Lab'].contents_", "do": "DONE"},
{"path": "$.physicals['Genetics Lab'].contents_.forObj", "do": "DONE"},
{"path": "$.physicals['Genetics Lab'].contents_.forKey", "do": "DONE"},
"$.cage",
{"path": "$.cage.location", "do": "DECL"},
{"path": "$.physicals.cage", "do": "DONE"},
"$.physicals['Genetic Mouse Prototype']",
"$.hosts.genetics",
"$.hosts.root.subdomains.genetics"
]
}, {
"filename": "core_44_$.assistant.js",
"headerSubs": {
"": "2020",
"": "Voice-activated assistant demo for Code City."
},
"contents": [
"$.assistant",
{"path": "$.assistant.location", "do": "DECL"},
{"path": "$.assistant.lastActivated", "do": "DECL"},
{"path": "$.physicals.assistant", "do": "DONE"}
]
}, {
"filename": "core_45_Challenge_Room.js",
"headerSubs": {
"": "2020",
"": "Challenge room demo for Code City."
},
"contents": [
"$.physicals['Challenge room']",
"$.physicals['light switch']",
"$.physicals.chest",
"$.physicals.safe",
"$.physicals.food",
"$.physicals.girl"
]
}, {
"filename": "core_46_$.secuityCourse.js",
"headerSubs": {
"": "2021",
"": "Security course demo for Code City."
},
"contents": [
"$.securityCourse",
{"path": "$.securityCourse.storeHosts", "do": "DONE"},
{"path": "$.hosts.root['/securitycourse']", "do": "DONE"}
]
},
{
"options": {"skipBindings": []}
}, {
"filename": "../database/db_00_core_lastModified.js",
"headerSubs": {
"": "2020",
"": "Edit history info for Code City core."
},
"contents": [
"Object",
"Function",
"Array",
"String",
"Boolean",
"Number",
"Date",
"RegExp",
"Error",
"EvalError",
"RangeError",
"ReferenceError",
"SyntaxError",
"TypeError",
"URIError",
"Math",
"JSON",
"decodeURI",
"decodeURIComponent",
"encodeURI",
"encodeURIComponent",
"escape",
"isFinite",
"isNaN",
"parseFloat",
"parseInt",
"unescape",
"Object.is",
"Object.assign",
"Object.setPrototypeOf",
"Array.from",
"Array.prototype.find",
"Array.prototype.findIndex",
"String.prototype.endsWith",
"String.prototype.includes",
"String.prototype.repeat",
"String.prototype.startsWith",
"Number.isFinite",
"Number.isNaN",
"Number.isSafeInteger",
"Number.EPSILON",
"Number.MAX_SAFE_INTEGER",
"Math.sign",
"Math.trunc",
"WeakMap",
"Array.prototype.includes",
"Object.getOwnerOf",
"Object.setOwnerOf",
"Thread",
"PermissionError",
"Array.prototype.join",
"suspend",
"setTimeout",
"clearTimeout",
"perms",
"setPerms",
"$.root",
"$.system",
"user",
"$.utils",
"$.utils.array",
"$.utils.object",
"$.utils.string",
"$.utils.code",
"$.Selector",
"$.utils.Binding",
"$.utils.html",
"$.jssp",
"$.connection",
"$.utils.url",
"$.servers.http",
"$.hosts.root['/']",
"$.hosts.root['/mirror']",
"$.hosts.root['/robots.txt']",
"$.hosts.system",
"$.hosts.dummy",
"$.hosts.root.subdomains.connect",
"$.hosts.root.subdomains.login",
"$.hosts.root.subdomains.mobwrite",
"$.hosts.root.subdomains.static",
"$.hosts.root.subdomains.system",
"$.db.tempId",
"$.userDatabase",
"$.hosts.code['/inlineEdit']",
"$.hosts.code",
"$.servers.eval",
"$.utils.command",
"$.utils.commandMenu",
"$.utils.replacePhysicalsWithName",
"$.physical",
"$.utils.validate.physicals",
"$.garbage",
"$.user",
"$.room",
"$.thing",
"$.container",
"$.servers.login",
"$.servers.telnet",
"$.startRoom{proto}",
"$.startRoom{owner}",
"$.startRoom.location",
"$.startRoom.name",
"$.startRoom.description",
"$.startRoom.roll",
"$.clock",
"$.physicals['Das deutsche Zimmer']",
"$.tutorial",
"$.seed",
"$.pot",
"$.pot.stages",
"$.thrower",
"$.physicals['Genetics Lab']",
"$.cage",
"$.physicals['Genetic Mouse Prototype']",
"$.hosts.genetics",
"$.hosts.root.subdomains.genetics",
"$.assistant",
"$.physicals['Challenge room']",
"$.physicals['light switch']",
"$.physicals.chest",
"$.physicals.safe",
"$.physicals.food",
"$.physicals.girl",
"$.securityCourse",
"$.hosts.root['/securitycourse']"
]
}, {
"filename": "../database/db_01_world.js",
"headerSubs": {
"": "2017",
"": "Main database for google.codecity.world."
},
"contents": [
"$.servers.http.Host.prototype.access",
"$.hosts.root.access",
"$.hosts.system.access",
"$.db.tempId.tempIds_",
"$"
]
}, {
"options": {"treeOnly": false}
}, {
"filename": "../database/db_99_leftovers.js",
"header": "",
"rest": true
}
]
================================================
FILE: database/README
================================================
On startup, if no .city database file exists, the server will read and
execute all .js files in this directory in asciibetical order. The
following naming convention has been established to keep things
organised:
core*.js - The Code City core.
db*.js - A dumped databse, if available, less core.
test*.js - Any tests to be run against the databse.
================================================
FILE: database/codecity.cfg
================================================
{
"databaseDirectory": "./",
"checkpointInterval": 60,
"checkpointAtShutdown": true,
"checkpointMinFiles": 10,
"checkpointMaxDirectorySize": 2048
}
================================================
FILE: docs/setup.md
================================================
# Setting up a Code City Instance
This document describes how to recreate a Code City server from bare
metal. For reference, the starting point is a Google Cloud Platform
account in good standing.
## Google Compute Engine Setup
We recommend running your Code City server on a [Google Compute
Engine](https://cloud.google.com/compute) (GCE) virtual
machine[[?]](
https://en.wikipedia.org/wiki/Virtual_machine) (VM)—it’s
reliable, minimal hassle, and, thanks to [Google Cloud Platform’s
“Always Free” tier](https://cloud.google.com/free), can be (very
nearly) free!
### Create a GCE instance
This will create a dedicated GCE instance (VM) on which to run Code
City. You can skip this step if you intend to run your instance on
your own machine or another cloud provider’s hardware.
Before you begin: the GCE instance (VM) you create will run using the
permissions of a service account[[?]](
https://cloud.google.com/iam/docs/service-accounts) . There is a
“Compute Engine default service account” which will work fine but has
quite broad permissions. You may wish to create a service account
with more limited permissions, to reduce the amount of damage an
attacker can do if they compromise your Code City instance and gain
control of the VM on which it runs. This is especially so if your GCP
project contains other resources (user data, etc.) which you wish to
protect. See [Appendix A: Creating a Service Account](
#appendix-a-creating-a-service-account) for instructions.
1. Go to the [Google Compute Engine
console](https://console.cloud.google.com/compute/instances).
0. Under VM Instances, click the create instance button . Enter details as follows:
* Name: choose a name for the instance. (This can be any name,
but we recommend you use a name matching your intended domain
name—e.g., `google.codecity.world` runs on an instance named
`google`.)
* Region: choose a region near where you expect your users to
be. Note that [instance pricing varies by
zone](https://cloud.google.com/compute/vm-instance-pricing).
* Zone: choose any.
* Machine type: choose an appropriate size.
* [GCP’s “Always Free” tier][always-free] offers one free
`f1-micro` instance in any of `us-west1`, `us-central1` or
`us-east1`. This size will be sufficient for many smaller
organisations/groups.
* Because of the architecture of the Code City server, there
is unlikely to be any benefit to having more than two
vCPUs (and one is generally sufficient).
* Container: no.
* Boot disk: under “Public images”, choose:
* Operating system: Debian
* Version: choose the most recent version—“Debian GNU/Linux
10 (buster)” as of this writing.
* Boot disk type: Standard persistent disk.
* Size: the default 10GB is likely to be sufficient for most
cases, but the “Always Free” program offers up to 30GB
(total, not per-instance) of persistent disk free of
charge.
* Identity and API access:
* Service account: use the default “Compute Engine default
service account” or select the one you created by
following the instructions in [appendix A](
#appendix-a-creating-a-service-account).
* Access scopes: Allow default access.
* Firewall: Allow both HTTP and HTTPS traffic.
* Management:
* Recommended: tick “Enable deletion protection” to make it
harder to inadvertently delete your Code City instance.
* Security:
* Recommended: tick “Turn on Secure Boot”.
* SSH Keys: you can add your ssh public key(s) here if you
wish; doing so will cause them to be automatically added
to the corresponding `~userid/.ssh/authorized_keys` file,
but note:
* Keys added here apply only to this GCE instance. If
you expect your project to have multiple instances you
may prefer to add your SSH keys on [the Compute Engine
metadata page](
https://pantheon.corp.google.com/compute/metadata/sshKeys)
instead: keys added there will have access to all the
project's GCE instances by default (i.e., unless you
tick "Block project-wide SSH keys" on a particular
instance).
* Even if you don’t add any SSH keys now you will in any
case be able to SSH to the machine from [GCE instances
page](
https://console.cloud.google.com/compute/instances).
* Disks:
* Recommended: **un**tick “Delete boot disk when instance
deleted” so that if you _do_ delete your instance you can
recreate it easily and without losing user data.
* Networking:
* Under Network interfaces, click the pencil icon next to
the default interface.
* External IP: ignore this section for now.
* Public DNS PTR Record: optionally click “Enable” and enter
the [domain name](#set-up-an-ip-address-and-domain-name)
you intend to use for your instance,
e.g. example .codecity.world[[?]](
https://en.wikipedia.org/wiki/IP_address) (like 192.0.2.1) so that
traffic can be routed to it.
1. Go to the [Networking / External IP addresses
console](https://console.cloud.google.com/networking/addresses).
0. Click “+ Reserve Static Address”. Enter details as follows:
* Name: can be any value, but we recommend you use the same name
as for your instance. This is just used to identify the
address reservation.
* Description: enter any text you like—e.g.: “Static IP
address for example .codecity.world.”
* Network Service Tier: choose either. See [description of
options](https://cloud.google.com/network-tiers/) and [pricing
information](https://cloud.google.com/network-tiers/pricing).
* IP vesion: IPv4.
* Type: Regional.
* Region: choose the same region as your instance was
created in.
* Attached to: choose your instance from the drop-down.
0. Click “Reserve”.
0. Make a note of the external address (like 192.0.2.1) which you
have just reserved for your instance.
### Give Your Instance a Domain Name
The Domain Name System[[?]](
https://en.wikipedia.org/wiki/Domain_Name_System) is a
distributed global database that maps domain names (like
`example.org`) to IP addresses (like 192.0.2.1).
In order for users to be able to access your instance without having
to know the numeric static IP address you reserved in the previous
section, you must create a human-readable domain mame[[?]](
https://en.wikipedia.org/wiki/Domain_name) for it.
The details of this process are outside of the scope of this document,
but we have the following observations and recommendations:
* Setting up DNS involves two distinct entities: a domain name
registrar[[?]](
https://en.wikipedia.org/wiki/Domain_name_registrar) , from
whom you can purchase a domain name (like `example.org`), and a
DNS provider, who runs the name servers[[?]](
https://en.wikipedia.org/wiki/Name_server) that resolve
individual DNS entries (like `www.example.com`) to specific
numeric IP addresses like the one created in the previous section.
In many cases both these services will be provided by the same
company, but many organisations will typically run their own DNS
servers, or outsource it to a [managed DNS provider](
https://en.wikipedia.org/wiki/List_of_managed_DNS_providers).
* If you are using your own domain name (e.g.,
codecity.example.org ) this will be done
through your DNS provider’s configuration console or via your
internal organisational DNS service configuration.
* Alternatively we may in some cases be able to offer you the
use of a Code City subdomain (e.g.,
example .codecity.world[[?]](
https://en.wikipedia.org/wiki/Wildcard_DNS_record) , so that
each user can serve their content on an isolated subdomain (like
username .example.codecity.world[[?]](
https://en.wikipedia.org/wiki/Wildcard_certificate) , we
recommend you use a [DNS provider who easily integrates with
Let’s Encrypt DNS validation][dns-providers], such as [Google
Cloud DNS](https://cloud.google.com/dns/), if possible.
[same origin policy]: https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy
[dns-providers]: https://community.letsencrypt.org/t/dns-providers-who-easily-integrate-with-lets-encrypt-dns-validation/86438
### Recommended: schedule regular, automatic backups of your instance’s disk
It’s always best to back up! Even though the Code City server
regularly checkpoints its database to the instance’s persistent disk,
setting up regular snapshotting of that disk will give you a separate
backup of the whole system in case of disaster.
Snapshots are [not free], but [are cheap]. A few dollars a month buys a
lot of peace of mind!
[not free]: https://cloud.google.com/compute/disks-image-pricing#persistentdisk
[are cheap]: https://cloud.google.com/compute/disks-image-pricing#persistent_disk_snapshots_storage_charges
First, create a snapshot schedule:
1. Go to the [GCE Snapshots page](
https://console.cloud.google.com/compute/snapshots) and click on
the “Snapshot Schedules” tab.
0. Click on Create Snapshot Schedule. Enter details as follows:
* Name: choose a name for the schedule, e.g. `daily-14`.
* Description: anything, e.g. “Daily snapshots, kept for 14
days”.
* Snapshot location: Regional.
* Region: choose the same region as your instance.
* Schedule frequency: hourly, daily or weekly as you prefer; for
this example: daily. (N.B.: more frequent snapshots will
result in more data to be stored and thus higher costs.)
* Start time: any. Snapshotting will not affect the running
instance, so choose whatever time of day you wish.
* Auto-delete snapshots after: choose a suitable period of time;
for this example: 14 days.
* Deletion rule: as you wish: “keep snapshots” better protects
against data loss in the event that your instance is
*inadvertently* deleted; “delete snapshots after _N_ days”
better protects against continuing to be charged fees after
you *deliberately* delete your instance.
* Enable VSS: no. (Not applicable to non-Windows instances.)
* Snapshot labels: not needed.
0. Click “Create” to create the schedule.
Now apply the schedule to your instance’s persistent disk:
4. Go to the [GCE Disks page](
https://console.cloud.google.com/compute/disks).
0. Click on the name of the persistent disk for your instance. (By
default it will have the same name you gave to your instance.)
0. Click on “Edit” at the top of the screen.
0. Under Snapshot schedule, select the schedule you created in steps
1–3.
0. Click Save.
## Set Up Machine and Install Code City
These instructions assume you are using a GCE instance running Debian
GNU/Linux 10 "buster", but feel free to adapt to your particular
set-up.
1. Log into your instance. (See instructions in first section if
using GCE.)
0. If your machine has less than 2GB of memory (check with `free -h`;
the very first number shown is total RAM), you will need to create
a swap file (this is mandatory on `f1-micro` instances):
```
sudo -i
fallocate -l 2G /swapfile
chmod 600 /swapfile
mkswap /swapfile
swapon /swapfile
swapon -s
sh -c 'echo "/swapfile none swap sw 0 0" >> /etc/fstab'
exit
```
0. Check for and install system updates, then install
[nginx](https://en.wikipedia.org/wiki/Nginx) and
[git](https://git-scm.com/):
```
sudo apt-get update
sudo apt-get upgrade –y
sudo apt-get install -y nginx git
```
0. Optionally install a text editor of your choice. Debian comes
with [`vim`](https://www.vim.org/) and
[`nano`](https://www.nano-editor.org/) preinstalled; Emacs users
might feel more at home with the lightweight editors
[`mg`](https://github.com/hboetes/mg),
[`jove`](https://github.com/jonmacs/jove) or
[`zile`](https://www.gnu.org/software/zile/), or opt for
`emacs-nox` which is GNU Emacs without X Windows bindings.
```
sudo apt-get install mg
```
0. Install [node.js](https://nodejs.org/). Code City depends on
version 12, which is more recent than the version included in
Debian 10, so we will obtain it via [NodeSource](
https://github.com/nodesource/distributions):
```
sudo -i
curl -sL https://deb.nodesource.com/setup_12.x | bash -
apt-get install -y nodejs
exit
```
0. Verify the correct version of node is installed:
```
$ node –-version
v12.18.4
```
(Actual version may be later than 12.18.)
### Get TLS Certificates
In order to allow incoming HTTPS connections, you will need an
TLS[[?]](https://en.wikipedia.org/wiki/Transport_Layer_Security)
server certificate[[?]](
https://en.wikipedia.org/wiki/Public_key_certificate#TLS/SSL_server_certificate
) . There are two types:
* An ordinary certificate covers one or more specific domain names,
like `www.example.org`.
* A wildcard certificate includes one or more wildcard domains, like
`*.example.org`.
You will need to get a TLS certificate covering the [set of DNS entries
you [created earlier](#set-up-an-ip-address-and-domain-name). If (as
recommended) you created a wildcard DNS entry, you will also need a
corresponding wildcard TLS certificate.
There are various ways to get a TLS certificate, but a free and easy
way is to use [Certbot](https://certbot.eff.org/) to get one from
[Let’s Encrypt](https://letsencrypt.org/). That’s what we’ll do here.
#### Getting a wildcard certificate
To use Certbot to get a wildcard certificate, you will need to use the
[`dns-01` challenge](
https://letsencrypt.org/docs/challenge-types/#dns-01-challenge), which
requires being able to create DNS TXT records[[?]](
https://en.wikipedia.org/wiki/TXT_record) for your domain name.
Here’s an example of how to do this if using Google Cloud DNS; see
[full instructions on the certbot website](
https://certbot.eff.org/lets-encrypt/debianbuster-nginx) if you use
another provider.
1. Install certbot and the required plug-ins:
```
sudo apt-get install -y certbot python3-certbot-dns-google
```
0. Obtain credentials from your DNS provider, to allow Certbot to
create TXT records, proving to Let’s Encrypt that you control your
domain. It [should be possible to skip this step](
https://certbot-dns-google.readthedocs.io/en/stable/#credentials)
when using Google Cloud DNS and running Certbot on GCE instance,
but alas [due to a bug](
https://github.com/certbot/certbot/issues/7933) this doesn’t yet
work in Debian 10.
1. Go to the [Service Accounts](
https://console.cloud.google.com/iam-admin/serviceaccounts)
tab of the IAM & Admin section of the GCP console.
0. Find the service account under which your GCE instance runs;
unless you elected otherwise above, this will be the one named
“Compute Engine default service account”. Click on the email
address for the key to open the details pane.
0. Click on the keys tab.
0. From the Add Key pop-up menu, select “Create new key”.
* Choose Key Type: JSON.
* Click “Create”.
0. Your browser will download a file with a name of the form
scp projectID–XXXXXXXXXXXX .json. Now,
transfer this file to your GCE instance using
[`scp`](https://en.wikipedia.org/wiki/Secure_copy) **on your
local machine**, e.g. scp
projectID–XXXXXXXXXXXX .json
example .codecity.world:service-account.json,
or by pasting it into a terminal window, as follows:
* Open the `.json` file you downloaded in step 2.iv. in a
text editor, select the whole contents and copy it to the
clipboard.
* **On your instance**, enter the command `cat - >
service-account.json `
* Paste the contents of the `.json` into the SSH window.
* Type `^D` to indicate end of file.
0. This credentials file will be needed when initially obtaining
the TLS certificate as well as every few months when [Certbot
will automatically renew it](
https://certbot.eff.org/docs/using.html#automated-renewals),
so move it to a safe place and protect it from tampering:
```
sudo mv service-account.json /etc/service-account.json
sudo chown root:root /etc/service-account.json
sudo chmod 600 /etc/service-account.json
```
0. Request a certificate for both the base domain name for your
instance and the corresponding wildcard entry:
```
sudo certbot certonly --dns-google \
--dns-google-credentials /etc/service-account.json \
--post-hook 'systemctl reload nginx' \
-d 'example.codecity.world,*.example.codecity.world'
```
If you have more than one DNS entry pointing at your instance,
just add further comma-separated entries to the list after the
`-d` directive. (N.B.: No spaces between entries in this list!)
* Enter your email address when prompted.
* Agree the terms of service.
* Optionally agree to share your email address with the EFF.
#### Getting a non-wildcard certificate
This process is a little simpler and does not require the ability to
modify DNS TXT records.
1. Install certbot (only):
```
sudo apt-get install -y certbot
```
0. Request a certificate for the base domain name for your instance
(only):
```
sudo certbot certonly --webroot --webroot-path /var/www/html \
--post-hook 'systemctl reload nginx' \
-d example.codecity.world
```
* Enter your email address at the prompt
* Agree the terms of service.
* Optionally agree to share your email address with the EFF.
### Install Code City
1. Create an account for Code City to run under. This is to isolate
it from any other users/services on the machine, and contain the
damage in the event that the server sandbox be compromised. We’ll
call the account `codecity` here, but any username is fine:
```
sudo useradd -rms /bin/bash codecity
```
0. Become the code city account:
```
sudo -iu codecity
```
0. Clone the [Code City
repo](https://github.com/google/CodeCity). (If you are a
project collaborator, see below for [instructions on how to use
SSH instad of HTTPS](#git-code-city-by-ssh-instead-of-https).)
```
git clone https://github.com/google/CodeCity.git
```
0. Install required NPMs:
```
(cd CodeCity/server && npm ci --only=prod)
(cd CodeCity/login && npm ci --only=prod)
```
0. Exit from the `codecity` account. We’re done with it for now, and
we need to be able to sudo, which that account (deliberately) does
not have permission to do.
```
exit
```
### Configure NGINX
On Debian, per-host `nginx` configuration files are stored in
`/etc/nginx/sites-available` and enabled by symlinking them into
`/etc/nginx-sites-enabled`. There is a `default` config supplied by
the `nginx` package, which should be disabled (unless you have already
modified it to serve other virutal hosts).
1. Install the NGINX configuration file. If you have a wildcard DNS
record and corresponding wildcard TLS certificate, use the
“subdomain” configuration:
```
sudo cp ~codecity/CodeCity/etc/cc-subdomain.conf \
/etc/nginx/sites-available/codecity
```
Otherwise, use the “onedomain” configuration:
```
sudo cp ~codecity/CodeCity/etc/cc-onedomain.conf \
/etc/nginx/sites-available/codecity
```
0. Edit /etc/nginx/sites-enabled to replace INSTANCENAME with the
name(s) of your instance. (See comments for details. You may use
another editor instead of nano if you wish!)
```
sudo nano /etc/nginx/sites-available/codecity
```
0. Enable the new configuration and reload (or restart) NGINX:
```
sudo rm /etc/nginx/sites-enabled/default
sudo ln -s /etc/nginx/sites-available/codecity \
/etc/nginx/sites-enabled/codecity
sudo systemctl reload-or-restart nginx
```
### Create an API Key for OAuth
The usual set-up for public Code City instances is to use [OAuth
2.0](https://oauth.net/2/) via Google’s OAuth service for logins.
This step will set up the necessary credentials to allow users to log
in to your instance using their Google (Gmail) account. You can skip
this step if you intend to use a different login mechanism.
This must be done after installing nginx and CodeCity and obtaining a
TLS certificate because it depends on `logo-auth.png` being served by
nginx.
1. Optionally replace `~codecity/CodeCity/static/logo-auth.png` with
a logo representing your instance or organisation. It should be a
120x120px PNG image.
0. Make sure you can access your desired logo using your web browser.
If you are using a wildcard DNS configuration, it should be
accessible via a URL like
static.example .codecity.world/logo-auth.png;
for a single-domain configuration it will instead be
example .codecity.world/static/logo-auth.pngexample .codecity.worldcodecity.yourdomain.tld )
* Product logo URL: Should point at the URL for your your logo,
as determined in step 2 above.
* Privacy policy URL: Provide a link to your privacy policy.
* Terms of service URL: may be left blank.
0. Go to the [APIs & Services > Credentials
console](https://console.cloud.google.com/apis/credentials).
0. Click “Create credentials”; choose OAuth client ID. Enter details
as follows:
* Application type: Web application
* Name: a suitable full name for your instance, (e.g. “Code City
for Springfield Highschool”).
* Authorized JavaScript origins: may be left blank.
* Authorized redirect URIs: for wildcard DNS configurations this
will be of the form `https://login.example.codecity.world/`;
for single-domain configurations it will instead be
`https://example.codecity.world/login/`.
0. Click Save.
0. Now click on the newly-created client ID. Make a note of the
Client ID (it will be a long string like
“00000000000-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.apps.googleusercontent.com”)
and the Client Secret (a shorter but similarly opaque jumble of
characters). You will need these later.
See also the [complete GCP OAuth 2.0 documentation](
https://support.google.com/cloud/answer/6158849) for more information.
### Configure Code City
1. Become the code city account:
```
sudo -iu codecity
```
0. Create a config file for loginServer:
* Run loginServer once to create an empty config file:
```
(cd ~/CodeCity/login && ./loginServer)
```
Open `~/CodeCity/login/loginServer.cfg` in the text editor of
your choice.
* Set `connectUrl` to the URL for the connect server. If using
a wildcard DNS entry for your instance, it will be the
`connect.` subdomain of your instance’s name; otherwise it
will be the `/connect` path on your instance. For example:
* With wildcard DNS: `https://connect.example.codecity.world/`
* Without wildcard DNS:`https://example.codecity.world/connect/`
* Set `staticUrl` to the URL nginx will serve static content on.
This works similarly to the previous entry, e.g.:
* With wildcard DNS: `https://static.example.codecity.world/`
* Without wildcard DNS:`https://example.codecity.world/static/`
* Set `clientID` and `clientSecret` to the values obtained
earlier from [Google’s API Console](
https://console.developers.google.com/apis).
* Set `cookieDomain` to your instance’s base domain name, e.g.:
`example.codecity.world`.
* Set `password` to a secret, random string. If you don’t have
a convenient way to generate one locally, you can copy a
[random string from random.org].
* Optionally, set `emailRegexp` to a [JavaScript regexp]
matching email addresses which should be permitted to log in
to your instance—e.g., `^.*@myorganisation\\.org$`.
0. Create and edit a config file for connectServer:
* Run connectServer once to create an empty config file:
```
(cd ~/CodeCity/connect && ./connectServer)
```
Open `~/CodeCity/connect/connectServer.cfg` in the text editor
of your choice.
* Set `loginUrl` to the URL for the login server, e.g.:
* With wildcard DNS: `https://login.example.codecity.world/`
* Without wildcard DNS:`https://example.codecity.world/login/`
* Set `staticUrl` and `password` to the _same_
values used in `loginServer.cfg`.
0. Modify the configuration for the in-core HTTP server:
* Open the file `~/CodeCity/core/core_99_startup.js` in the text
editor of your choice. Find the optional configuration
section near the top of the file.
* Set `$.hosts.root.hostname` to your instance’s domain
name—e.g., $.hosts.root.hostname =
'example .codecity.world';
* Set `$.hosts.root.pathToSubdomain = false;` if you are using a
wildcard DNS entry for your instance; otherwise set it to
`true`.
* If you have more than one DNS entry for your instance, set
`$.hosts.root.hostRegExp` according to the instructions
provided.
0. Save the file, exit your editor and exit from the `codecity`
account.
```
exit
```
[JavaScript regexp]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions
[random string from random.org]: https://www.random.org/strings/?num=1&len=20&digits=on&upperalpha=on&loweralpha=on&unique=on&format=html&rnd=new
### Configure Systemd and Start Code City Servers
1. Install the systemd config files:
```
sudo cp ~codecity/CodeCity/etc/*.service /etc/systemd/system
```
0. Check the contents of `/etc/systemd/system/codecity.service`,
…`codecity-login.service` and …`codecity-connect.service`; verify
paths, usernames etc. all match the values created in previous
steps.
0. Enable Code City services with systemd:
```
sudo systemctl enable --now codecity
```
0. Verify you can connect to your new Code City instance by pointing
your web browser its domain name—e.g., `https://example.codecity.world`.
Congratulations, you're done!
## Appendix A: Creating a Service Account
To protect any other Google Cloud Platform services you run against
the consequences of your Code City instance being compromised, you can
have the GCE VM it runs on use only the limited permissions of a
custom service account, rather than the extensive permissions held by
the Compute Engine default service account. To do this there are three
steps:
1. Creating one or more roles for the service account.
0. Creating a service account
0. Applying the service account to the GCE instance.
### Create Role(s)
You should create one role for running CodeCity instances on GCE, and
optionally create a second role if you intend to have your GCE
instance [obtain wildcard TLS certificates using certbot via the ACME
HTTP-01 challenge](#getting-a-wildcard-certificate).
1. Go to the [Roles tab of IAM & Admin](
https://console.cloud.google.com/iam-admin/roles).
0. Create a role for running a Code City instance by clicking “+
Create Role” then enter details as follows:
* Title: “CodeCity Instance”.
* Description: “Base role for all CodeCity instances. Created
on: …”.
* ID: `instance`.
* Add the following permissions by clicking “+ Add Permissions”
button, typing the name of the permission into the “Filter
table” field (*not* the “Filter permissions by role” field),
selecting required permission, and clicking Add:
* `compute.globalOperations.get`
* `compute.zoneOperations.get`
* `logging.logEntries.create`
* Click “Create”.
0. Optionally create a second role for obtaining wildcard certs by
again clicking “+ Create Role” and entering:
* Title: “CodeCity Cert-via-DNS”
* Description: “Add-on permission to allow an instance to update
its own wildcard letsencrypt SSL cert via an ACME dns-01
challenge. Created on: …”.
* ID: `dnscert`.
* Add the following permisions:
* `dns.changes.create`
* `dns.changes.get`
* `dns.managedZones.list`
* `dns.resourceRecordSets.create`
* `dns.resourceRecordSets.delete`
* `dns.resourceRecordSets.list`
* `dns.resourceRecordSets.update`
* Click “Create”.
### Create a Service Account
Now you can create a service account for your instance.
1. Go to the [Service Accounts tab of IAM & Admin](
https://console.cloud.google.com/iam-admin/serviceaccounts).
0. Click “+ Create Servce Account” and enter details as follows:
* Service account name: choose and appropriate name such as
“CodeCity instance” or “instance-myInstanceName ”.
* Service account ID: modify suggested ID if desired.
* Service account description: “Service account for the
example .codecity.world instance” or similar.
0. Click “Create”.
* Where it says “Select a role”, select “CodeCity Instance”.
* If you intend to use certbot to obtain a wildcare DNS cert,
click “+ Add Another Role” and select “CodeCity Cert-via-DNS”.
0. Click “Continue”.
0. Click “Done.
### Use the Service Account to run your GCE Instance
If you have not yet done so, simply [follow the instructions to create
a GCE instance for Code City](#create-a-gce-instance) and, when you
get to the “Identity and API access” section of the creation wizard,
select the service account you created previously.
Otherwise, if you have already created your GCE instance, configure it
to use the newly-create service account as follows:
1. Go to the [VM instances tab](
https://console.cloud.google.com/compute/instances).
0. Select the VM instance you created previously.
0. Click the stop button at the top of the page to stop it, if it is
running.
0. Click the name of your instance to view its “VM instnace details”
page.
0. Click “Edit”.
0. Scroll down to “Service account” and select the service account
you created previously.
## Appendix B: Remote Debugging
If you need to debug the server because it has stopped responding to
network activity, here’s how to do that:
1. SSH in to the GCE instance and enable the inspector on the running server:
* $ sudo kill -s SIGUSR1 `pidof codecity`
0. Look in /var/log/daemon.log for a message like:
```
Feb 26 01:22:49 google codecity[19464]: Debugger listening on ws://127.0.0.1:9229/8df977b7-024d-464d-84c2-44321dd5b398
Feb 26 01:22:49 google codecity[19464]: For help, see: https://nodejs.org/en/docs/inspector
```
Note the port number (in this case 9229).
0. SSH in to the GCE instance again, enabling port forwarding:
```
ssh -L 9229:localhost:9229 google.codecity.world
```
* The initial 9229 can be replaced with a local port number of
your choice.
* The `:localhost:` directive ensures that only processes
running on your local machine can make use of the port
forward.
0. Open the inspector in Chrome by going to
[`chrome://inspect`](chrome://inspect).
(Based on [node.js debugging documentation](
https://nodejs.org/en/docs/guides/debugging-getting-started/) and [a
related blog post](
https://hackernoon.com/debugging-node-without-restarting-processes-bd5d5c98f200).)
## Appendix C: Additional Instructions for Code City Collaborators
### GIT Code City by SSH instead of HTTPS
During early development, the Code City repository was private so it
was necessary to do the `git clone` by SSH instead of HTTPS. We
continue to do this on our production instance to allow commits to the
`prod` branch to be made from there if necessary.
To avoid putting SSH private keys on the instance, we use SSH agent
forwarding. This would mostly be automatic except that we also need
to be able to use our personal credentials as the user `codecity`.
The solution is adapted [from Server Fault](
https://serverfault.com/questions/107187).
#### Preparation (do once)
1. Add your SSH public key (ideally, one from a hardware token or the
like) to [your GitHub account](https://github.com/settings/keys).
0. Verify that you can ssh to GitHub from your local workstation:
```
ssh -T git@github.com
```
Output should look like “Hi username ! You've
successfully authenticated, but GitHub does not provide shell
access.”
0. Edit `~/.ssh/config` to add the following directive, if not
already present:
```
ForwardAgent yes
```
This will enable agent forwarding by default.
#### When setting up a CodeCity GCE instance
These instructions replace step 3 of [Install & Configure Code
City](#install--configure-code-city).
4. Ensure that your SSH public key can be used to log in to the
instance. This can be done in two ways:
* Preferred: add it to [the Compute Engine metadata page](
https://pantheon.corp.google.com/compute/metadata/sshKeys).
* Alternatively: add it to the instance at creation or by
editing the instance on [the GCE instances page](
https://console.cloud.google.com/compute/instances).
* Alternatively: log into the instance initially using the
browser-based SSH available via the GCE console. Use the text
editor of your choice to append your SSH public key to
`~/.ssh/authorized_keys`.
0. Ensure you can ssh to your instance from the command line of your
local machine. Use `-A` to enable agent forwarding (`ssh -A
example.codecity.world`) or add `ForwardAgent yes` to your
`~/.ssh/config` file.
0. From your instance, verify that agent forwarding is working:
```
ssh -T git@github.com
```
(Expected output similar to step 2 above above.)
0. Install the acl package:
```
sudo apt-get install -y acl
```
0. On your instance, after creating the `codecity` user, add the
following to your `.bashrc` or `.bash_login`:
```
setfacl -m codecity:x $(dirname "$SSH_AUTH_SOCK")
setfacl -m codecity:rw "$SSH_AUTH_SOCK"
```
0. Modify the machine’s sudo config to tell sudo not to wipe
`SSH_AUTH_SOCK` from the environment:
```
sudo visudo -f /etc/sudoers.d/ssh-agent-forwarding
```
* Add the line
```
Defaults env_keep+=SSH_AUTH_SOCK
```
then save and exit.
0. When becoming the codecity user, be sure to use “`sudo -iu
codecity`” instead of “`sudo su - cc`”—the latter will clear the
needed `SSH_AUTH_SOCK` environment variable.
0. Install Code City using the SSH repository path:
```
git clone git@github.com:google/CodeCity.git
```
#### Getting SSL Certificates
Google-internal GCE instances are by default firewalled to prevent
inbound access from the Internet; this causes Certbot’s ACME checks to
fail. The preferred solution is to use the DNS-01 challenge, even if
no wildcard cert is required.
================================================
FILE: etc/apache.conf
================================================
# Template for Apache configuration.
# HTTP should redirect to HTTPS.
RewriteEngine On
RewriteRule ^/?(.*) https://%{SERVER_NAME}/$1 [R,L]
# '.academy' should redirect to '.world'.
ServerName XXXXX.codecity.academy
RewriteEngine On
RewriteRule ^/?(.*) https://XXXXX.codecity.world/$1 [R,L]
SSLEngine on
Include /etc/letsencrypt/options-ssl-apache.conf
SSLCertificateFile /etc/letsencrypt/live/XXXXX.codecity.world/fullchain.pem
SSLCertificateKeyFile /etc/letsencrypt/live/XXXXX.codecity.world/privkey.pem
# '.games' should redirect to '.world'.
ServerName XXXXX.codecity.games
RewriteEngine On
RewriteRule ^/?(.*) https://XXXXX.codecity.world/$1 [R,L]
SSLEngine on
Include /etc/letsencrypt/options-ssl-apache.conf
SSLCertificateFile /etc/letsencrypt/live/XXXXX.codecity.world/fullchain.pem
SSLCertificateKeyFile /etc/letsencrypt/live/XXXXX.codecity.world/privkey.pem
ServerName XXXXX.codecity.world
Alias /static /home/cc/CodeCity/static
Options Indexes Includes FollowSymLinks
AllowOverride All
Require all granted
ProxyPass /login http://localhost:7781/login
ProxyPassReverse /login http://localhost:7781/login
ProxyPass /connect http://localhost:7782/connect
ProxyPassReverse /connect http://localhost:7782/connect
ProxyPass /mobwrite http://localhost:7783/mobwrite
ProxyPassReverse /mobwrite http://localhost:7783/mobwrite
# Must be last, or else it will grab all requests.
ProxyPass /static !
ProxyPass / http://localhost:7780/
ProxyPassReverse / http://localhost:7780/
ErrorLog /home/cc/error.log
CustomLog /home/cc/access.log combined
SSLEngine on
Include /etc/letsencrypt/options-ssl-apache.conf
SSLCertificateFile /etc/letsencrypt/live/XXXXX.codecity.world/fullchain.pem
SSLCertificateKeyFile /etc/letsencrypt/live/XXXXX.codecity.world/privkey.pem
================================================
FILE: etc/cc-localhost.conf
================================================
# Nginx configuration for Code City on localhost.
# Warning: This configuration is insecure, users can hijack each other's perms.
#
# The easiest way to use this file is to leave it unedited and instead
# start nginx using bin/nginx-dev, which will dynamically create
# suitable config files on the fly.
# Configuration applying to all servers.
error_page 502 503 504 =503 /static/503.html;
# Configuration applying to all proxy forwarding.
proxy_set_header Host $http_host;
proxy_set_header Forwarded $proxy_add_forwarded; # See below.
proxy_set_header CodeCity-pathToSubdomain "?1";
proxy_pass_header Server;
proxy_next_upstream_tries 1;
proxy_max_temp_file_size 0;
proxy_connect_timeout 10s;
proxy_send_timeout 10s;
proxy_read_timeout 10s;
server {
# Listen on port 8080 for both IPv6 and IPv4.
listen [::]:8080 ipv6only=off;
location / {
# Proxy to Code City port 7780.
proxy_pass http://127.0.0.1:7780/;
}
location /static/ {
# Static files.
autoindex on;
index index.html;
# Edit to be full path to CodeCity directory.
# E.g. /home/userid/src/CodeCity
root REPOSITORY;
}
location /login {
# Proxy to loginServer.js port 7781.
proxy_pass http://127.0.0.1:7781/login;
}
location /connect {
# Proxy to connectServer.js port 7782.
proxy_pass http://127.0.0.1:7782/connect;
}
location /mobwrite {
# Proxy to mobwrite_server.py port 7783.
proxy_pass http://127.0.0.1:7783/mobwrite;
}
}
# Configuration for generating Forwarded: header, based on example from
# https://www.nginx.com/resources/wiki/start/topics/examples/forwarded/
#
# Conceal the IP address of incoming connections by default, as it is
# PII and we try to avoid giving users any chance to get their hands
# on each other's PII. To enable inclusion of actual IP addresses of
# incoming connections in the Forwarded header, uncomment the first
# two matchers below.
map $remote_addr $proxy_forwarded_for {
# IPv4 addresses can be sent as-is.
# ~^[0-9.]+$ "for=$remote_addr";
# IPv6 addresses need to be bracketed and quoted.
# ~^[0-9A-Fa-f:.]+$ "for=\"[$remote_addr]\"";
# Unix domain socket names cannot be represented in RFC 7239 syntax.
default "for=unknown";
}
# Append host and proto.
map $proxy_forwarded_for $proxy_forwarded_elem {
default "$proxy_forwarded_for;host=\"$http_host\";proto=$scheme";
}
map $http_forwarded $proxy_add_forwarded {
# If the incoming Forwarded header is syntactically valid, append to it.
"~^(,[ \\t]*)*([!#$%&'*+.^_`|~0-9A-Za-z-]+=([!#$%&'*+.^_`|~0-9A-Za-z-]+|\"([\\t \\x21\\x23-\\x5B\\x5D-\\x7E\\x80-\\xFF]|\\\\[\\t \\x21-\\x7E\\x80-\\xFF])*\"))?(;([!#$%&'*+.^_`|~0-9A-Za-z-]+=([!#$%&'*+.^_`|~0-9A-Za-z-]+|\"([\\t \\x21\\x23-\\x5B\\x5D-\\x7E\\x80-\\xFF]|\\\\[\\t \\x21-\\x7E\\x80-\\xFF])*\"))?)*([ \\t]*,([ \\t]*([!#$%&'*+.^_`|~0-9A-Za-z-]+=([!#$%&'*+.^_`|~0-9A-Za-z-]+|\"([\\t \\x21\\x23-\\x5B\\x5D-\\x7E\\x80-\\xFF]|\\\\[\\t \\x21-\\x7E\\x80-\\xFF])*\"))?(;([!#$%&'*+.^_`|~0-9A-Za-z-]+=([!#$%&'*+.^_`|~0-9A-Za-z-]+|\"([\\t \\x21\\x23-\\x5B\\x5D-\\x7E\\x80-\\xFF]|\\\\[\\t \\x21-\\x7E\\x80-\\xFF])*\"))?)*)?)*$" "$http_forwarded, $proxy_forwarded_elem";
# Otherwise, replace it.
default "$proxy_forwarded_elem";
}
================================================
FILE: etc/cc-onedomain.conf
================================================
# Nginx configuration for Code City using a single domain.
# Warning: This configuration is insecure, users can hijack each other's perms.
# Configuration applying to all servers.
error_page 502 503 504 =503 /static/503.html;
# Configuration applying to all proxy forwarding.
proxy_set_header Host $http_host;
proxy_set_header Forwarded $proxy_add_forwarded; # See below.
proxy_set_header CodeCity-pathToSubdomain "?1";
proxy_pass_header Server;
proxy_next_upstream_tries 1;
proxy_max_temp_file_size 0;
proxy_connect_timeout 10s;
proxy_send_timeout 10s;
proxy_read_timeout 10s;
# Redirect all http traffic to https, except for ACME HTTP-01 challenges.
server {
# Listen on port 80 for both IPv6 and IPv4.
listen [::]:80 ipv6only=off;
location / {
return 301 https://$host$request_uri;
}
# Serve ACME challenge files to enable automatic Certbot SSL
# certificate renewals using HTTP-01 challenges.
location /.well-known/ {
# Serve these from the usual Debain default path so it doesn't
# matter whether this config file is installed yet or not, and to
# avoid having certbot have to write to /home/codecity/
root /var/www/html;
}
}
# Code City configuration
server {
# Listen on port 443 for both IPv6 and IPv4.
listen [::]:443 ssl ipv6only=off;
# Replace INSTANCENAME with the domain name of your instance. Make
# sure that the resulting filenames point at the certificate files
# created by certbot.
ssl_certificate /etc/letsencrypt/live/INSTANCENAME/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/INSTANCENAME/privkey.pem;
# Canonicalise to a single domain.
#
# Replace INSTANCENAME (both places) with the domain name of your
# instance. If you have more than one domain name for you instance,
# put the canonical one here.
if ( $host != INSTANCENAME ) {
return 301 https://INSTANCENAME$request_uri;
}
location / {
# Proxy to Code City port 7780.
proxy_pass http://127.0.0.1:7780/;
}
location /static/ {
# Static files.
autoindex on;
index index.html;
# If requried, edit to be full path to CodeCity directory. Nginx
# will add /static/ automatically since that's the location.
# E.g.: /home/codecity/CodeCity;
root /home/codecity/CodeCity;
}
location /login {
# Proxy to loginServer.js port 7781.
proxy_pass http://127.0.0.1:7781/login;
}
location /connect {
# Proxy to connectServer.js port 7782.
proxy_pass http://127.0.0.1:7782/connect;
}
location /mobwrite {
# Proxy to mobwrite_server.py port 7783.
proxy_pass http://127.0.0.1:7783/mobwrite;
}
}
# Configuration for generating Forwarded: header, based on example from
# https://www.nginx.com/resources/wiki/start/topics/examples/forwarded/
#
# Conceal the IP address of incoming connections by default, as it is
# PII and we try to avoid giving users any chance to get their hands
# on each other's PII. To enable inclusion of actual IP addresses of
# incoming connections in the Forwarded header, uncomment the first
# two matchers below.
map $remote_addr $proxy_forwarded_for {
# IPv4 addresses can be sent as-is.
# ~^[0-9.]+$ "for=$remote_addr"
# IPv6 addresses need to be bracketed and quoted.
# ~^[0-9A-Fa-f:.]+$ "for=\"[$remote_addr]\"";
# Unix domain socket names cannot be represented in RFC 7239 syntax.
default "for=unknown";
}
# Append host and proto.
map $proxy_forwarded_for $proxy_forwarded_elem {
default "$proxy_forwarded_for;host=\"$http_host\";proto=$scheme";
}
map $http_forwarded $proxy_add_forwarded {
# If the incoming Forwarded header is syntactically valid, append to it.
"~^(,[ \\t]*)*([!#$%&'*+.^_`|~0-9A-Za-z-]+=([!#$%&'*+.^_`|~0-9A-Za-z-]+|\"([\\t \\x21\\x23-\\x5B\\x5D-\\x7E\\x80-\\xFF]|\\\\[\\t \\x21-\\x7E\\x80-\\xFF])*\"))?(;([!#$%&'*+.^_`|~0-9A-Za-z-]+=([!#$%&'*+.^_`|~0-9A-Za-z-]+|\"([\\t \\x21\\x23-\\x5B\\x5D-\\x7E\\x80-\\xFF]|\\\\[\\t \\x21-\\x7E\\x80-\\xFF])*\"))?)*([ \\t]*,([ \\t]*([!#$%&'*+.^_`|~0-9A-Za-z-]+=([!#$%&'*+.^_`|~0-9A-Za-z-]+|\"([\\t \\x21\\x23-\\x5B\\x5D-\\x7E\\x80-\\xFF]|\\\\[\\t \\x21-\\x7E\\x80-\\xFF])*\"))?(;([!#$%&'*+.^_`|~0-9A-Za-z-]+=([!#$%&'*+.^_`|~0-9A-Za-z-]+|\"([\\t \\x21\\x23-\\x5B\\x5D-\\x7E\\x80-\\xFF]|\\\\[\\t \\x21-\\x7E\\x80-\\xFF])*\"))?)*)?)*$" "$http_forwarded, $proxy_forwarded_elem";
# Otherwise, replace it.
default "$proxy_forwarded_elem";
}
================================================
FILE: etc/cc-subdomain.conf
================================================
# Nginx configuration for Code City using multiple subdomains.
# Configuration applying to all servers.
# Replace INSTANCENAME with the domain name of your instance; make
# sure the result is prefixed with the 'static' subdomain.
# E.g.: static.example.codecity.world
error_page 502 503 504 =503 https://static.INSTANCENAME/503.html;
# Configuration applying to all proxy forwarding.
proxy_set_header Host $http_host;
proxy_set_header Forwarded $proxy_add_forwarded; # See below.
proxy_set_header CodeCity-pathToSubdomain "?0";
proxy_pass_header Server;
proxy_next_upstream_tries 1;
proxy_max_temp_file_size 0;
proxy_connect_timeout 10s;
proxy_send_timeout 10s;
proxy_read_timeout 10s;
# Redirect all http traffic to https.
server {
# Listen on port 80 for both IPv6 and IPv4.
listen [::]:80 ipv6only=off;
return 301 https://$host$request_uri;
}
# Code City configuration
server {
# Listen on port 443 for both IPv6 and IPv4.
listen [::]:443 ssl ipv6only=off;
# Replace INSTANCENAME with the domain name of your instance. Make
# sure that the resulting filenames point at the certificate files
# created by certbot.
ssl_certificate /etc/letsencrypt/live/INSTANCENAME/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/INSTANCENAME/privkey.pem;
# # Canonicalise to a single domain.
# #
# # Replace regular expression with one that matches all non-canonical
# # domains.
# if ( $host ~ ^example\.codecity\.(academy|games)$ ) {
# # Replace INSTANCENAME with the canonical domain name of your instance.
# # E.g.: https://example.codecity.world$request_uri
# return 301 https://INSTANCENAME$request_uri;
# }
# # Replace regular expression with one that matches all non-canonical
# # subdomains.
# if ( $host ~ ^(.*)\.example\.codecity\.(academy|games)$ ) {
# # Replace INSTANCENAME with the canonical domain name of your instance.
# # E.g.: https://$1.example.codecity.world$request_uri
# return 301 https://$1.INSTANCENAME$request_uri;
# }
location / {
# Proxy to Code City port 7780.
proxy_pass http://127.0.0.1:7780/;
}
}
# Login server.
server {
listen [::]:443 ssl;
# Replace INSTANCENAME with the domain name of your instance; make
# sure the result is prefixed with the 'login' subdomain.
# E.g.: login.example.codecity.world
server_name login.INSTANCENAME;
location / {
# Proxy to loginServer.js port 7781.
proxy_pass http://127.0.0.1:7781/;
}
}
# Connect server.
server {
listen [::]:443 ssl;
# Replace INSTANCENAME with the domain name of your instance; make
# sure the result is prefixed with the 'connect' subdomain.
# E.g.: connect.example.codecity.world
server_name connect.INSTANCENAME;
location / {
# Proxy to connectServer.js port 7782.
proxy_pass http://127.0.0.1:7782/;
}
}
# MobWrite server.
server {
listen [::]:443 ssl;
# Replace INSTANCENAME with the domain name of your instance; make
# sure the result is prefixed with the 'mobwrite' subdomain.
# E.g.: mobwrite.example.codecity.world
server_name mobwrite.INSTANCENAME;
location / {
# Proxy to mobwrite_server.py port 7783.
proxy_pass http://127.0.0.1:7783/mobwrite;
}
}
# Static file server.
server {
listen [::]:443 ssl;
# Replace INSTANCENAME with the domain name of your instance; make
# sure the result is prefixed with the 'static' subdomain.
# E.g.: static.example.codecity.world
server_name static.INSTANCENAME;
location / {
autoindex on;
index index.html;
# If required, edit to be full path to CodeCity static directory.
# E.g. /home/codecity/CodeCity/static
root /home/codecity/CodeCity/static;
}
}
# Configuration for generating Forwarded: header, based on example from
# https://www.nginx.com/resources/wiki/start/topics/examples/forwarded/
#
# Conceal the IP address of incoming connections by default, as it is
# PII and we try to avoid giving users any chance to get their hands
# on each other's PII. To enable inclusion of actual IP addresses of
# incoming connections in the Forwarded header, uncomment the first
# two matchers below.
map $remote_addr $proxy_forwarded_for {
# IPv4 addresses can be sent as-is.
# ~^[0-9.]+$ "for=$remote_addr"
# IPv6 addresses need to be bracketed and quoted.
# ~^[0-9A-Fa-f:.]+$ "for=\"[$remote_addr]\"";
# Unix domain socket names cannot be represented in RFC 7239 syntax.
default "for=unknown";
}
# Append host and proto.
map $proxy_forwarded_for $proxy_forwarded_elem {
default "$proxy_forwarded_for;host=\"$http_host\";proto=$scheme";
}
map $http_forwarded $proxy_add_forwarded {
# If the incoming Forwarded header is syntactically valid, append to it.
"~^(,[ \\t]*)*([!#$%&'*+.^_`|~0-9A-Za-z-]+=([!#$%&'*+.^_`|~0-9A-Za-z-]+|\"([\\t \\x21\\x23-\\x5B\\x5D-\\x7E\\x80-\\xFF]|\\\\[\\t \\x21-\\x7E\\x80-\\xFF])*\"))?(;([!#$%&'*+.^_`|~0-9A-Za-z-]+=([!#$%&'*+.^_`|~0-9A-Za-z-]+|\"([\\t \\x21\\x23-\\x5B\\x5D-\\x7E\\x80-\\xFF]|\\\\[\\t \\x21-\\x7E\\x80-\\xFF])*\"))?)*([ \\t]*,([ \\t]*([!#$%&'*+.^_`|~0-9A-Za-z-]+=([!#$%&'*+.^_`|~0-9A-Za-z-]+|\"([\\t \\x21\\x23-\\x5B\\x5D-\\x7E\\x80-\\xFF]|\\\\[\\t \\x21-\\x7E\\x80-\\xFF])*\"))?(;([!#$%&'*+.^_`|~0-9A-Za-z-]+=([!#$%&'*+.^_`|~0-9A-Za-z-]+|\"([\\t \\x21\\x23-\\x5B\\x5D-\\x7E\\x80-\\xFF]|\\\\[\\t \\x21-\\x7E\\x80-\\xFF])*\"))?)*)?)*$" "$http_forwarded, $proxy_forwarded_elem";
# Otherwise, replace it.
default "$proxy_forwarded_elem";
}
================================================
FILE: etc/codecity-connect.service
================================================
[Unit]
Description=Code City Connect Server
Documentation=https://github.com/google/CodeCity
After=network.target
[Service]
SyslogIdentifier=cc-connect
WorkingDirectory=/home/codecity/CodeCity/connect
User=codecity
Group=codecity
ExecStart=@/home/codecity/CodeCity/connect/connectServer cc-connect
Restart=on-failure
================================================
FILE: etc/codecity-login.service
================================================
[Unit]
Description=Code City Login Server
Documentation=https://github.com/google/CodeCity
After=network.target
[Service]
SyslogIdentifier=cc-login
WorkingDirectory=/home/codecity/CodeCity/login
User=codecity
Group=codecity
ExecStart=@/home/codecity/CodeCity/login/loginServer cc-login
Restart=on-failure
================================================
FILE: etc/codecity-mobwrite.service
================================================
[Unit]
Description=Code City Login Server
Documentation=https://github.com/google/CodeCity
After=network.target
[Service]
SyslogIdentifier=cc-mobwrite
WorkingDirectory=/home/codecity/CodeCity/mobwrite
User=codecity
Group=codecity
ExecStart=@/usr/bin/python2 cc-mobwrite /home/codecity/CodeCity/mobwrite/mobwrite_server.py
Restart=on-failure
================================================
FILE: etc/codecity.service
================================================
[Unit]
Description=Code City
Documentation=https://github.com/google/CodeCity
After=network.target
Wants=codecity-login.service codecity-connect.service codecity-mobwrite.service
[Service]
SyslogIdentifier=codecity
WorkingDirectory=/home/codecity/CodeCity/database
User=codecity
Group=codecity
ExecStart=@/home/codecity/CodeCity/server/codecity codecity codecity.cfg
Restart=on-failure
[Install]
WantedBy=multi-user.target
================================================
FILE: etc/gcloud-snapshot
================================================
#!/bin/bash
# Put this file in /etc/cron.daily/ to effect automatic daily snapshots.
#
# Must also have installed gcloud-snapshot.sh from:
#
# https://github.com/jacksegal/google-compute-snapshot/
#
# and enabled the "compute engine" cloud API access scope for this
# instance.
/usr/local/sbin/gcloud-snapshot.sh -d 30
================================================
FILE: login/login.html
================================================
Code City Login
JavaScript required
================================================
FILE: login/loginServer
================================================
#!/usr/bin/env node
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Node.js server that provides Google auth services to Code City.
* @author fraser@google.com (Neil Fraser)
*/
'use strict';
const crypto = require('crypto');
const forwardedParse = require('forwarded-parse');
const fs = require('fs').promises;
const {google} = require('googleapis');
const http = require('http');
const net = require('net');
const {URL, format: urlFormat} = require('url');
const oauth2Api = google.oauth2('v2');
// Configuration constants.
const configFileName = 'loginServer.cfg';
// Global variables
let CFG = null;
const /** !Object */ clients = {};
const DEFAULT_CFG = {
// Internal port for this HTTP server. Nginx hides this from users.
httpPort: 7781,
// URL of connect page (absolute or relative).
connectUrl: 'https://connect.example.codecity.world/',
// URL of static folder (absolute or relative).
staticUrl: 'https://static.example.codecity.world/',
// Google's API client ID.
clientId: '00000000000-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx' +
'.apps.googleusercontent.com',
// Google's API client secret.
clientSecret: 'yyyyyyyyyyyyyyyyyyyyyyyy',
// Root domain.
cookieDomain: 'example.codecity.world',
// Regexp on email addresses that must pass to allow access.
emailRegexp: '.*',
// Port number for the login service backend.
backendPort: 7776,
/* List of fields, from data object returned by
* oauth2Api.userinfo.v2.me.get, to pass along in the request the
* login service backend.
*
* Available fieldnames, and the types and meanings of their values:
* - id: string - the user's OAuth (GAIA) ID as a numeric string.
* If salt is set (below), the .id will be salted and hashed with
* sha512 before being sent to the login backend service.
* - email: string - the user's email address.
* - verified_email: boolean - has the user's email address been verified?
* - name: string - the user's full name.
* - given_name: string - the user's given name.
* - family_name: string - the user's family name.
* - picture: string - URL pointing to the user's profile picture.
* - hd: string - the hosted domain, for GSuite accounts.
*/
backendFields: ['id'],
/* Random salt for OAuth IDs. If set to '' the .id field received
* from the Oauth server will be hashed but not salted. If set to
* undefined (or not set) the .id wil be sent plaintext.
*/
salt: 'zzzzzzzzzzzzzzzz'
};
/**
* Serve an error to the given ServerResult. Also log information
* about the failed IncomingMessage to the console.
* @param {!http.IncomingMessage} request The request which triggered the error.
* @param {!http.ServerResponse} response The ServerResult to send error to.
* @param {number} statusCode the HTTP response code to be served.
* @param {string} message An additional message to include in the result.
* @return {void}
*/
function sendError(request, response, statusCode, message) {
console.log('%s %s (Host: %s): %d %s', request.method,
request.url.replace(/=[^&]*(?=&|$)/g, '=…'),
request.headers.host, statusCode, message);
response.writeHead(statusCode).end(message);
}
/**
* Load a file from disk, add substitutions, and serve to the web.
* @param {!IncomingMessage} request The request being answered.
* @param {!http.ServerResponse} response The ServerResult to send the file to.
* @param {string} filename Name of template file on disk.
* @param {!Object} subs Object-map of replacement strings.
*/
async function serveFile(request, response, filename, subs) {
let /** string */ data;
try {
data = String(await fs.readFile(filename, 'utf8'));
} catch (err) {
sendError(request, response,
500, `Unable to load file ${filename}: ${err}`);
return;
}
// Inject substitutions.
for (const name in subs) {
data = data.replace(new RegExp(name, 'g'), subs[name]);
}
// Serve page to user.
response.statusCode = 200;
response.setHeader('Content-Type', 'text/html');
response.end(data);
}
/**
* Send a string to the login service backend and return any data
* received in response.
* @param {string} query Data string to send to backend.
* @return {!Promise} a promise yeilding the data received.
*/
async function pingBackend(query) {
let result = '';
return new Promise((resolve, reject) => {
const socket = net.createConnection({port: CFG.backendPort});
socket.on('connect', () => {
socket.end(query);
});
socket.on('error', (error) => {
socket.destroy();
reject(error);
});
socket.on('data', (data) => {
result += String(data);
});
socket.on('end', () => {
resolve(result);
});
});
}
/**
* Handles HTTP requests from web server.
* @param {!Object} request HTTP server request object
* @param {!Object} response HTTP server response object.
*/
async function handleRequest(request, response) {
if (request.connection.remoteAddress !== '127.0.0.1') {
sendError(request, response, 403,
`Connection from ${request.connection.remoteAddress} denied.`);
return;
}
// Determine what URL the client contacted us on.
let proto = 'http'; // What proto we are actually listening to.
let host = request.headers.host; // Host header we actually received.
// See if the first reverse proxy knows better.
const forwarded = request.headers.forwarded;
if (forwarded) {
try {
const forwards = forwardedParse(forwarded);
if (forwards[0]) {
if (forwards[0].proto) proto = forwards[0].proto;
if (forwards[0].host) host = forwards[0].host;
}
} catch (e) {
sendError(request, response, 400,
`Forwarded header: ${e.name}: ${e.message} of "${forwarded}"`);
return;
}
}
const url = new URL(request.url, `${proto}://${host}`);
const loginUrl = urlFormat(url, {fragment: false, search: false});
// Get an authentication client for our interactions with Google.
if (!clients[loginUrl]) {
// Create client for login URL not seen before.
clients[loginUrl] = new google.auth.OAuth2(
CFG.clientId, CFG.clientSecret, loginUrl);
}
const oauth2Client = clients[loginUrl];
// No auth code? Serve login.html.
const code = url.searchParams.get('code');
if (!code) {
// Compute Google's login URL, including deciding where to
// redirect to afterwards.
const options = {scope: 'email'};
if (url.searchParams.has('after')) {
options.state = url.searchParams.get('after');
} else if (url.searchParams.has('loginThenClose')) {
options.state = CFG.staticUrl + 'login-close.html';
} else {
options.state = CFG.connectUrl;
}
const subs = {
'<<>>': oauth2Client.generateAuthUrl(options),
'<<>>': CFG.staticUrl
};
serveFile(request, response, 'login.html', subs);
return;
}
// Handle the result of an OAuth login.
let tokens;
try {
({tokens} = await oauth2Client.getToken(code));
} catch (err) {
sendError(request, response, 500, `Google OAuth2 fail: ${err}`);
return;
}
// Now tokens contains an access_token and an optional
// refresh_token. Save them.
oauth2Client.setCredentials(tokens);
let data;
try {
({data} = await oauth2Api.userinfo.v2.me.get({auth: oauth2Client}));
} catch (err) {
sendError(request, response, 500, `Google Userinfo fail: ${err}`);
return;
}
// Check email address is allowed.
const emailRegexp = new RegExp(CFG.emailRegexp || '.*');
if (!emailRegexp.test(data.email)) {
sendError(request, response, 403, `Login denied for ${data.email}`);
return;
}
// FYI: If present, data.hd contains the GSfE domai,
// e.g. 'students.gissv.org', or 'sjsu.edu'. We aren't using it
// now, but this might be used to filter users.
// Convert the OAuth (GAIA) ID into one unique for Code City. Use
// CFG.salt to salt the sha512hash. If .salt === '', then .id will
// still be hashed but not salted.
// TODO(cpcallen): it would be more secure to append salt to id.
if (('id' in data) && CFG.salt !== undefined) {
data.id = crypto.createHash('sha512')
.update(CFG.salt + data.id).digest('hex');
}
// Contact login service backend if configured.
let cookie;
if (CFG.backendPort) {
// Construct object to be passed to login service backend.
const loginData = {};
for (const name of CFG.backendFields || ['id']) {
if (name in data) loginData[name] = data[name];
}
// Ping the login service backend.
try {
cookie = await pingBackend(JSON.stringify(loginData) + '\n');
} catch (err) {
sendError(request, response, 500, `Login service backend fail: ${err}`);
return;
}
} else {
// Just use the (probably salted and hashed) id value like we used to.
cookie = data.id;
}
if (!cookie) {
sendError('Login service backend did not return a valid cookie');
return;
}
// Login successful. Issue ID cookie.
if (!url.searchParams.has('state')) {
sendError(request, response, 500,
'Login successful but loginServer forgot where to redirect to.');
return;
}
const domain = CFG.cookieDomain ? `Domain=${CFG.cookieDomain}; ` : '';
const redirectUrl = url.searchParams.get('state');
response.writeHead(302, { // Temporary redirect.
'Set-Cookie': `ID=${cookie}; HttpOnly; ${domain}Path=/`,
'Location': redirectUrl,
});
response.end('Login OK. Redirecting.');
console.log('Accepted xxxx' + cookie.substring(cookie.length - 4));
}
/**
* Read the JSON configuration file and return it. If none is
* present, write a stub and throw an error.
*/
async function readConfigFile(filename) {
let data;
try {
data = await fs.readFile(filename, 'utf8');
} catch (err) {
console.log(`Configuration file ${filename} not found. ` +
'Creating new file.');
data = JSON.stringify(DEFAULT_CFG, null, 2) + '\n';
await fs.writeFile(filename, data, 'utf8');
}
CFG = JSON.parse(data);
if (CFG.salt === DEFAULT_CFG.salt) {
throw Error(
`Configuration file ${filename} not configured. ` +
'Please edit this file.');
}
if (!CFG.connectUrl.endsWith('/')) CFG.connectUrl += '/';
if (!CFG.staticUrl.endsWith('/')) CFG.staticUrl += '/';
}
/**
* Read configuration and start up the HTTP server.
*/
async function startup() {
await readConfigFile(configFileName);
// Start an HTTP server.
const server = http.createServer(handleRequest);
server.listen(CFG.httpPort, 'localhost', () => {
console.log(`Login server listening on port ${CFG.httpPort}`);
});
}
startup();
================================================
FILE: login/package.json
================================================
{
"name": "codecity-login",
"version": "0.0.0",
"description": "Login server for the Code City project",
"main": "loginServer.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"repository": {
"type": "git",
"url": "git+https://github.com/google/CodeCity.git"
},
"author": "Google",
"license": "Apache-2.0",
"bugs": {
"url": "https://github.com/google/CodeCity/issues"
},
"homepage": "https://github.com/google/CodeCity#readme",
"dependencies": {
"forwarded-parse": "^2.1.1",
"googleapis": "^59.0.0"
},
"devDependencies": {}
}
================================================
FILE: minimal/core_01_minimal.js
================================================
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Minimal database for Code City.
* @author fraser@google.com (Neil Fraser)
*/
var user = null;
var $ = {};
// System object: $.system
$.system = {};
$.system.log = new 'CC.log';
$.system.checkpoint = new 'CC.checkpoint';
$.system.shutdown = new 'CC.shutdown';
$.system.connectionListen = new 'CC.connectionListen';
$.system.connectionUnlisten = new 'CC.connectionUnlisten';
$.system.connectionWrite = new 'CC.connectionWrite';
$.system.connectionClose = new 'CC.connectionClose';
// Physical object prototype: $.physical
$.physical = {};
$.physical.name = 'Physical object prototype';
$.physical.description = '';
$.physical.location = null;
$.physical.contents_ = null;
$.physical.getContents = function() {
return this.contents_ || [];
};
$.physical.addContents = function(thing) {
var contents = this.getContents();
contents.indexOf(thing) === -1 && contents.push(thing);
this.contents_ = contents;
};
$.physical.removeContents = function(thing) {
var contents = this.getContents();
var index = contents.indexOf(thing);
if (index !== -1) {
contents.splice(index, 1);
}
this.contents_ = contents;
};
$.physical.moveTo = function(dest) {
var src = this.location;
src && src.removeContents && src.removeContents(this);
this.location = dest;
dest && dest.addContents && dest.addContents(this);
};
$.physical.look = function() {
user.tell(this.name);
user.tell(this.description);
var contents = this.getContents();
if (contents.length) {
var text = [];
for (var i = 0; i < contents.length; i++) {
text[i] = String(contents[i].name || contents[i]);
}
user.tell('Contents: ' + text.join(', '));
}
};
$.physical.look.dobj = 'this';
// Thing prototype: $.thing
$.thing = Object.create($.physical);
$.thing.name = 'Thing prototype';
$.thing.get = function() {
this.moveTo(user);
user.tell('You pick up ' + this.name + '.');
if (user.location) {
user.location.announce(user.name + ' picks up ' + this.name + '.');
}
};
$.thing.get.dobj = 'this';
$.thing.drop = function() {
this.moveTo(user.location);
user.tell('You drop ' + this.name + '.');
if (user.location) {
user.location.announce(user.name + ' drops ' + this.name + '.');
}
};
$.thing.drop.dobj = 'this';
// Room prototype: $.room
$.room = Object.create($.physical);
$.room.name = 'Room prototype';
$.room.announce = function(text) {
var contents = this.getContents();
for (var i = 0; i < contents.length; i++) {
var thing = contents[i];
if (thing !== user && thing.tell) {
thing.tell(text);
}
}
};
// User prototype: $.user
$.user = Object.create($.physical);
$.user.name = 'User prototype';
$.user.connection = null;
$.user.say = function(text) {
user.tell('You say: ' + text);
if (user.location) {
user.location.announce(user.name + ' says: ' + text);
}
};
$.user.say.dobj = 'any';
$.user.eval = function(code) {
user.tell(eval(code));
};
$.user.eval.dobj = 'any';
$.user.tell = function(text) {
if (this.connection) {
this.connection.write(text);
}
};
$.user.quit = function() {
if (this.connection) {
this.connection.close();
}
};
$.user.quit.dobj = 'none';
// Command parser.
$.execute = function(command) {
var argstr = command.trim();
var verbstr = argstr;
var dobjstr = '';
var dobj = null;
var space = command.indexOf(' ');
if (space !== -1) {
verbstr = argstr.substring(0, space).trim();
dobjstr = argstr.substring(space).trim();
}
if (!verbstr) {
return;
}
if (dobjstr) {
if (dobjstr === 'me') {
dobj = user;
} else if (dobjstr === 'here') {
dobj = user.location;
} else {
var objects = [user].concat(user.getContents());
if (user.location && user.location.getContents) {
objects.push(user.location);
objects = objects.concat(user.location.getContents());
}
for (var i = 0; i < objects.length; i++) {
var obj = objects[i];
if (obj.name &&
obj.name.toLowerCase().startsWith(dobjstr.toLowerCase())) {
dobj = obj;
break;
}
}
}
}
// Collect all objects which could host the verb.
var hosts = [user, user.location, dobj];
for (var i = 0; i < hosts.length; i++) {
var host = hosts[i];
if (!host) {
continue;
}
// Check every verb on each object for a match.
for (var prop in host) {
var func = host[prop];
if (prop === verbstr && typeof func === 'function' && func.dobj) {
if (func.dobj === 'any' || (func.dobj === 'this' && dobj === host) ||
(func.dobj === 'none' && !dobj)) {
return host[prop](dobjstr);
}
}
}
}
user.tell('Command not understood.');
};
// Database of users so that connections can bind to a user.
$.userDatabase = Object.create(null);
$.connection = {};
$.connection.onConnect = function() {
this.user = null;
this.buffer = '';
this.write('Welcome. Type name of user to connect as (Alpha or Beta).');
};
$.connection.onReceive = function(text) {
this.buffer += text.replace(/\r/g, '');
var lf;
while ((lf = this.buffer.indexOf('\n')) !== -1) {
this.onReceiveLine(this.buffer.substring(0, lf));
this.buffer = this.buffer.substring(lf + 1);
}
};
$.connection.onReceiveLine = function(text) {
if (this.user) {
user = this.user;
$.execute(text);
return;
}
// Remainder of function handles login.
text = text.trim().toLowerCase();
if ($.userDatabase[text]) {
this.user = $.userDatabase[text];
if (this.user.connection) {
this.user.connection.close();
$.system.log('Rebinding connection to ' + this.user.name);
} else {
$.system.log('Binding connection to ' + this.user.name);
}
this.user.connection = this;
this.write('Connected as ' + this.user.name);
user = this.user;
$.execute('look here');
if (user.location) {
user.location.announce(user.name + ' connects.');
}
} else {
this.write('Unknown user.');
}
};
$.connection.onEnd = function() {
if (this.user) {
if (user.location) {
user.location.announce(user.name + ' disconnects.');
}
if (this.user.connection === this) {
$.system.log('Unbinding connection from ' + this.user.name);
this.user.connection = null;
}
this.user = null;
}
};
$.connection.write = function(text) {
$.system.connectionWrite(this, text + '\n');
};
$.connection.close = function() {
$.system.connectionClose(this);
};
// Set up a room, two users, and a rock.
(function () {
var hangout = Object.create($.room);
hangout.name = 'Hangout';
hangout.description = 'A place to hang out, chat, and program.';
var alpha = Object.create($.user);
alpha.name = 'Alpha';
$.userDatabase[alpha.name.toLowerCase()] = alpha;
alpha.description = 'Looks a bit Canadian.';
alpha.moveTo(hangout);
var beta = Object.create($.user);
beta.name = 'Beta';
$.userDatabase[beta.name.toLowerCase()] = beta;
beta.description = 'Mostly harmless.';
beta.moveTo(hangout);
var rock = Object.create($.thing);
rock.name = 'Rock';
rock.description = 'Suspiciously cube shaped, made of granite.';
rock.moveTo(hangout);
$.system.connectionListen(7777, $.connection);
})();
================================================
FILE: minimal/minimal.cfg
================================================
{
"databaseDirectory": "./",
"checkpointInterval": 0,
"checkpointAtShutdown": false
}
================================================
FILE: minimal/readme.txt
================================================
Minimal Database.
This database demonstrates a very minimal Code City instance. It contains:
* Two users (Alpha and Beta)
* One room (Hangout)
* One object (Rock)
Run the database with:
node codecity.js minimal
Telnet to port 7777
Type either 'Alpha' or 'Beta' to connect as one of the two users.
Once connected, the valid commands are:
* say
* eval
* look [me|here|alpha|beta|hangout|rock]
* get rock
* drop rock
* quit
================================================
FILE: mobwrite/mobwrite.cfg
================================================
; ---------------------
; Settings for MobWrite
; ---------------------
; How long (in seconds) to compute a diff before giving up.
; Set to 0 to compute indefinitely.
DIFF_TIMEOUT = 0.1
; Demo usage should limit the maximum size of any text.
; Set to 0 to disable limit.
MAX_CHARS = 100000
; Delete any view which hasn't been accessed in a while.
; Format: {seconds|minutes|hours|days}
TIMEOUT_VIEW = 30 minutes
; Delete any text which hasn't been accessed in a while.
; TIMEOUT_TEXT should be longer than the length of TIMEOUT_VIEW
TIMEOUT_TEXT = 1 days
; How verbose the log should be.
; Choose from: CRITICAL, ERROR, WARNING, INFO, DEBUG
LOGGING = DEBUG
; Port to listen on.
LOCAL_PORT = 7783
; Restrict all Telnet connections to come from this location.
; Set to "" to allow connections from anywhere.
CONNECTION_ORIGIN = 127.0.0.1
; Name of cookie that must be present, otherwise code 410 is returned.
; This is in the form of a regexp. Set to blank to disable feature.
REQUIRED_COOKIE = ID
================================================
FILE: mobwrite/mobwrite_core.py
================================================
# Copyright 2009 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Core functions for a MobWrite client/server in Python.
"""
__author__ = "fraser@google.com (Neil Fraser)"
import datetime
import logging
import re
import diff_match_patch as dmp_module
class Configuration(dict):
def initConfig(self, filename):
"""Parse the config file and setup the preferences.
Args:
filename: Path to the config file.
Raises:
If the config is invalid, this function will thow an error.
"""
global MAX_CHARS, TIMEOUT_VIEW, TIMEOUT_TEXT
def readConfigFile(filename):
self.clear()
lineRegex = re.compile("^(\w+)\s*=\s*(.+)$")
# Attempt to open the file.
try:
f = open(filename)
except:
return
# Parse the file.
try:
for line in f:
line = line.strip()
# Comment lines start with a ;
if len(line) > 0 and not line.startswith(";"):
r = lineRegex.match(line)
if r:
self[r.group(1)] = r.group(2)
finally:
f.close()
def toTime(value):
(quantity, unit) = value.split(None, 1)
quantity = int(quantity)
if (unit == "seconds"):
delta = datetime.timedelta(seconds=quantity)
elif (unit == "minutes"):
delta = datetime.timedelta(minutes=quantity)
elif (unit == "hours"):
delta = datetime.timedelta(hours=quantity)
elif (unit == "days"):
delta = datetime.timedelta(days=quantity)
else:
raise "Config: Unknown time value."
return delta
readConfigFile(filename)
# Set each of the configuration parameters.
# If a parameter is not present, a reasonable default is specified here.
# If a configuration is invalid, throw an error.
DMP.Diff_Timeout = float(self.get("DIFF_TIMEOUT", 0.1))
MAX_CHARS = int(self.get("MAX_CHARS", 100000))
TIMEOUT_VIEW = toTime(self.get("TIMEOUT_VIEW", "30 minutes"))
TIMEOUT_TEXT = toTime(self.get("TIMEOUT_TEXT", "1 days"))
logLevel = self.get("LOGGING", "INFO")
if logLevel == "CRITICAL":
LOG.setLevel(logging.CRITICAL)
elif logLevel == "ERROR":
LOG.setLevel(logging.ERROR)
elif logLevel == "WARNING":
LOG.setLevel(logging.WARNING)
elif logLevel == "INFO":
LOG.setLevel(logging.INFO)
elif logLevel == "DEBUG":
LOG.setLevel(logging.DEBUG)
else:
raise "Config: Unknown logging level."
LOG.info("Read %d settings from %s" % (len(self), filename))
class TextObj:
# An object which stores a text.
# Object properties:
# .name - The unique name for this text, e.g 'proposal'
# .text - The text itself.
def __init__(self, *args, **kwargs):
# Setup this object
self.name = kwargs.get("name")
self.text = None
def setText(self, newtext):
# Scrub the text before setting it.
if newtext != None:
# Normalize linebreaks to LF.
newtext = re.sub(r"(\r\n|\r|\n)", "\n", newtext)
# Keep the text within the length limit.
if MAX_CHARS != 0 and len(newtext) > MAX_CHARS:
newtext = newtext[-MAX_CHARS:]
LOG.warning("Truncated text to %d characters." % MAX_CHARS)
if self.text != newtext:
self.text = newtext
class ViewObj:
# An object which contains one user's view of one text.
# Object properties:
# .username - The name for the user, e.g 'fraser'
# .filename - The name for the file, e.g 'proposal'
# .shadow - The last version of the text sent to client.
# .backup_shadow - The previous version of the text sent to client.
# .shadow_client_version - The client's version for the shadow (n).
# .shadow_server_version - The server's version for the shadow (m).
# .backup_shadow_server_version - the server's version for the backup
# shadow (m).
# .edit_stack - List of unacknowledged edits sent to the client.
# .delta_ok - Did the previous delta match the text length.
def __init__(self, *args, **kwargs):
# Setup this object
self.username = kwargs["username"]
self.filename = kwargs["filename"]
self.shadow_client_version = kwargs.get("shadow_client_version", 0)
self.shadow_server_version = kwargs.get("shadow_server_version", 0)
self.backup_shadow_server_version = kwargs.get("backup_shadow_server_version", 0)
self.shadow = kwargs.get("shadow", u"")
self.backup_shadow = kwargs.get("backup_shadow", u"")
self.edit_stack = []
self.delta_ok = True
class MobWrite:
def parseRequest(self, data):
"""Parse the raw MobWrite commands into a list of specific actions.
See: http://code.google.com/p/google-mobwrite/wiki/Protocol
Args:
data: A multi-line string of MobWrite commands.
Returns:
A list of actions, each action is a dictionary. Typical action:
{"username":"fred",
"filename":"report",
"mode":"delta",
"data":"=10+Hello-7=2",
"force":False,
"server_version":3,
"client_version":3,
"echo_username":False
}
"""
# Passing a Unicode string is an easy way to cause numerous subtle bugs.
if type(data) != str:
LOG.critical("parseRequest data type is %s" % type(data))
return []
if not (data.endswith("\n\n") or data.endswith("\r\r") or
data.endswith("\n\r\n\r") or data.endswith("\r\n\r\n")):
# There must be a linefeed followed by a blank line.
# Truncated data. Abort.
LOG.warning("Truncated data: '%s'" % data)
return []
# Parse the lines
actions = []
username = None
filename = None
server_version = None
echo_username = False
for line in data.splitlines():
if not line:
# Terminate on blank line.
break
if line.find(":") != 1:
# Invalid line.
continue
(name, value) = (line[:1], line[2:])
# Parse out a version number for file, delta or raw.
version = None
if ("FfDdRr".find(name) != -1):
div = value.find(":")
if div > 0:
try:
version = int(value[:div])
except ValueError:
LOG.warning("Invalid version number: %s" % line)
continue
value = value[div + 1:]
else:
LOG.warning("Missing version number: %s" % line)
continue
if name == "u" or name == "U":
# Remember the username.
username = value
# Client may request explicit usernames in response.
echo_username = (name == "U")
elif name == "f" or name == "F":
# Remember the filename and version.
filename = value
server_version = version
elif name == "n" or name == "N":
# Nullify this file.
filename = value
if username and filename:
action = {}
action["username"] = username
action["filename"] = filename
action["mode"] = "null"
actions.append(action)
else:
# A delta or raw action.
action = {}
if name == "d" or name == "D":
action["mode"] = "delta"
elif name == "r" or name == "R":
action["mode"] = "raw"
else:
action["mode"] = None
if name.isupper():
action["force"] = True
else:
action["force"] = False
action["server_version"] = server_version
action["client_version"] = version
action["data"] = value
action["echo_username"] = echo_username
if username and filename and action["mode"]:
action["username"] = username
action["filename"] = filename
actions.append(action)
return actions
def applyPatches(self, viewobj, diffs, action):
"""Apply a set of patches onto the view and text objects. This function must
be enclosed in a lock or transaction since the text object is shared.
Args:
viewobj: The user's view to be updated.
diffs: List of diffs to apply to both the view and the server.
action: Parameters for how forcefully to make the patch; may be modified.
"""
# Expand the fragile diffs into a full set of patches.
patches = DMP.patch_make(viewobj.shadow, diffs)
# First, update the client's shadow.
viewobj.shadow = DMP.diff_text2(diffs)
viewobj.backup_shadow = viewobj.shadow
viewobj.backup_shadow_server_version = viewobj.shadow_server_version
# Second, deal with the server's text.
textobj = viewobj.textobj
if textobj.text is None:
# A view is sending a valid delta on a file we've never heard of.
textobj.setText(viewobj.shadow)
action["force"] = False
LOG.debug("Set content: '%s'" % viewobj)
else:
if action["force"]:
# Clobber the server's text if a change was received.
if patches:
mastertext = viewobj.shadow
LOG.debug("Overwrote content: '%s'" % viewobj)
else:
mastertext = textobj.text
else:
(mastertext, results) = DMP.patch_apply(patches, textobj.text)
LOG.debug("Patched (%s): '%s'" %
(",".join(["%s" % (x) for x in results]), viewobj))
textobj.setText(mastertext)
# Global Diff/Match/Patch object.
DMP = dmp_module.diff_match_patch()
# Global logging object.
LOG = logging.getLogger("mobwrite")
# Configuration object.
CFG = Configuration()
================================================
FILE: mobwrite/mobwrite_core_test.py
================================================
#!/usr/bin/python2
# Copyright 2006 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import logging
import unittest
import mobwrite_core
# Force a module reload so to make debugging easier (at least in PythonWin).
reload(mobwrite_core)
class MobWriteCoreTest(unittest.TestCase):
def setUp(self):
mobwrite_core.LOG.setLevel(logging.ERROR)
mobwrite_core.logging.basicConfig()
def tearDown(self):
mobwrite_core.logging.shutdown()
def testParseRequest(self):
mobwrite = mobwrite_core.MobWrite()
actions = mobwrite.parseRequest("")
self.assertEquals([], actions)
actions = mobwrite.parseRequest("""u:fred
f:3:report
d:2:=10+Hello-7=2
""")
self.assertEquals([{"username":"fred",
"filename":"report",
"mode":"delta",
"data":"=10+Hello-7=2",
"force":False,
"server_version":3,
"client_version":2,
"echo_username":False
}], actions)
actions = mobwrite.parseRequest("""U:fred
f:3:report
R:2:Hello World
""")
self.assertEquals([{"username":"fred",
"filename":"report",
"mode":"raw",
"data":"Hello World",
"force":True,
"server_version":3,
"client_version":2,
"echo_username":True
}], actions)
actions = mobwrite.parseRequest("""U:fred
N:report
""")
self.assertEquals([{"username":"fred",
"filename":"report",
"mode":"null",
}], actions)
if __name__ == "__main__":
unittest.main()
================================================
FILE: mobwrite/mobwrite_server.py
================================================
#!/usr/bin/python2
# Copyright 2006 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""This file is MobWrite's server-side daemon.
Runs in the background listening to a port, accepting synchronization sessions
from clients.
"""
__author__ = "fraser@google.com (Neil Fraser)"
import datetime
import glob
import os
import re
import sys
import time
import thread
import urllib
from BaseHTTPServer import BaseHTTPRequestHandler
from BaseHTTPServer import HTTPServer
import mobwrite_core
# Demo usage should limit the maximum number of connected views.
# Set to 0 to disable limit.
MAX_VIEWS = 10000
# Dictionary of all text objects.
texts = {}
# Lock to prevent simultaneous changes to the texts dictionary.
lock_texts = thread.allocate_lock()
class TextObj(mobwrite_core.TextObj):
# A persistent object which stores a text.
# Object properties:
# .lock - Access control for writing to the text on this object.
# .views - Count of views currently connected to this text.
# .lasttime - The last time that this text was modified.
# Inherited properties:
# .name - The unique name for this text, e.g 'proposal'.
# .text - The text itself.
def __init__(self, *args, **kwargs):
# Setup this object
mobwrite_core.TextObj.__init__(self, *args, **kwargs)
self.views = 0
self.lasttime = datetime.datetime.now()
self.lock = thread.allocate_lock()
# lock_texts must be acquired by the caller to prevent simultaneous
# creations of the same text.
assert lock_texts.locked(), "Can't create TextObj unless locked."
global texts
texts[self.name] = self
def setText(self, newText):
mobwrite_core.TextObj.setText(self, newText)
self.lasttime = datetime.datetime.now()
def cleanup(self):
# General cleanup task.
if self.views > 0:
return
terminate = False
# Lock must be acquired to prevent simultaneous deletions.
self.lock.acquire()
try:
if self.lasttime < datetime.datetime.now() - mobwrite_core.TIMEOUT_TEXT:
mobwrite_core.LOG.info("Expired text: '%s'" % self)
terminate = True
if terminate:
# Terminate in-memory copy.
global texts
lock_texts.acquire()
try:
try:
del texts[self.name]
except KeyError:
mobwrite_core.LOG.error("Text object not in text list: '%s'" % self)
finally:
lock_texts.release()
finally:
self.lock.release()
def fetch_textobj(name, view):
# Retrieve the named text object. Create it if it doesn't exist.
# Add the given view into the text object's list of connected views.
# Don't let two simultaneous creations happen, or a deletion during a
# retrieval.
lock_texts.acquire()
try:
if texts.has_key(name):
textobj = texts[name]
mobwrite_core.LOG.debug("Accepted text: '%s'" % name)
else:
textobj = TextObj(name=name)
mobwrite_core.LOG.debug("Creating text: '%s'" % name)
textobj.views += 1
finally:
lock_texts.release()
return textobj
# Dictionary of all view objects.
views = {}
# Lock to prevent simultaneous changes to the views dictionary.
lock_views = thread.allocate_lock()
class ViewObj(mobwrite_core.ViewObj):
# A persistent object which contains one user's view of one text.
# Object properties:
# .lasttime - The last time that a web connection serviced this object.
# .textobj - The shared text object being worked on.
# Inherited properties:
# .username - The name for the user, e.g 'fraser'
# .filename - The name for the file, e.g 'proposal'
# .shadow - The last version of the text sent to client.
# .backup_shadow - The previous version of the text sent to client.
# .shadow_client_version - The client's version for the shadow (n).
# .shadow_server_version - The server's version for the shadow (m).
# .backup_shadow_server_version - the server's version for the backup
# shadow (m).
# .edit_stack - List of unacknowledged edits sent to the client.
# .delta_ok - Did the previous delta match the text length.
def __init__(self, *args, **kwargs):
# Setup this object
mobwrite_core.ViewObj.__init__(self, *args, **kwargs)
self.lasttime = datetime.datetime.now()
self.textobj = fetch_textobj(self.filename, self)
# lock_views must be acquired by the caller to prevent simultaneous
# creations of the same view.
assert lock_views.locked(), "Can't create ViewObj unless locked."
global views
views[(self.username, self.filename)] = self
def cleanup(self):
# General cleanup task.
# Delete myself if I've been idle too long.
# Don't delete during a retrieval.
lock_views.acquire()
try:
if self.lasttime < datetime.datetime.now() - mobwrite_core.TIMEOUT_VIEW:
mobwrite_core.LOG.info("Idle out: '%s'" % self)
global views
try:
del views[(self.username, self.filename)]
except KeyError:
mobwrite_core.LOG.error("View object not in view list: '%s'" % self)
self.textobj.views -= 1
finally:
lock_views.release()
def nullify(self):
self.lasttime = datetime.datetime.min
self.cleanup()
def fetch_viewobj(username, filename):
# Retrieve the named view object. Create it if it doesn't exist.
# Don't let two simultaneous creations happen, or a deletion during a
# retrieval.
lock_views.acquire()
try:
key = (username, filename)
if views.has_key(key):
viewobj = views[key]
viewobj.lasttime = datetime.datetime.now()
mobwrite_core.LOG.debug("Accepting view: '%s'" % viewobj)
else:
if MAX_VIEWS != 0 and len(views) > MAX_VIEWS:
viewobj = None
mobwrite_core.LOG.critical("Overflow: Can't create new view.")
else:
viewobj = ViewObj(username=username, filename=filename)
mobwrite_core.LOG.debug("Creating view: '%s'" % viewobj)
finally:
lock_views.release()
return viewobj
class DaemonMobWrite(BaseHTTPRequestHandler, mobwrite_core.MobWrite):
def do_POST(self):
connection_origin = mobwrite_core.CFG.get("CONNECTION_ORIGIN", "")
if connection_origin and self.client_address[0] != connection_origin:
raise IOError("Connection refused from %s (only %s allowed)." %
(self.client_address[0], connection_origin))
mobwrite_core.LOG.info("Connection accepted from " + self.client_address[0])
required_cookie = mobwrite_core.CFG.get("REQUIRED_COOKIE", "")
if required_cookie and (('Cookie' not in self.headers) or
(not re.search(r'(^|;)\s*%s=\w' % required_cookie, self.headers['Cookie']))):
self.send_headers(410)
self.wfile.write("Required cookie not found.\n")
return
# Read the POST data.
content_length = int(self.headers['Content-Length'])
data = self.rfile.read(content_length)
div = data.find("q=")
if div == -1:
self.send_headers(400)
self.wfile.write("'q=' parameter not found in data:\n")
self.wfile.write(data)
return
data = data[div + 2:]
data = urllib.unquote(data)
self.send_headers(200)
self.wfile.write(self.handleRequest(data))
self.wfile.write("\n") # Terminating blank line.
# Goodbye
mobwrite_core.LOG.debug("Disconnecting.")
def send_headers(self, code):
origin = self.headers['Origin']
self.send_response(code)
self.send_header('Content-type', 'text/plain')
self.send_header('Access-Control-Allow-Origin', origin)
self.send_header('Access-Control-Allow-Credentials', 'true')
self.end_headers()
def handleRequest(self, text):
actions = self.parseRequest(text)
return self.doActions(actions)
def doActions(self, actions):
output = []
viewobj = None
last_username = None
last_filename = None
for action_index in xrange(len(actions)):
# Use an indexed loop in order to peek ahead one step to detect
# username/filename boundaries.
action = actions[action_index]
username = action["username"]
filename = action["filename"]
# Fetch the requested view object.
if not viewobj:
viewobj = fetch_viewobj(username, filename)
if viewobj is None:
# Too many views connected at once.
# Send back nothing. Pretend the return packet was lost.
return ""
viewobj.delta_ok = True
textobj = viewobj.textobj
if action["mode"] == "null":
# Nullify the text.
mobwrite_core.LOG.debug("Nullifying: '%s'" % viewobj)
textobj.lock.acquire()
try:
textobj.setText(None)
finally:
textobj.lock.release()
viewobj.nullify();
viewobj = None
continue
if (action["server_version"] != viewobj.shadow_server_version and
action["server_version"] == viewobj.backup_shadow_server_version):
# Client did not receive the last response. Roll back the shadow.
mobwrite_core.LOG.warning("Rollback from shadow %d to backup shadow %d" %
(viewobj.shadow_server_version, viewobj.backup_shadow_server_version))
viewobj.shadow = viewobj.backup_shadow
viewobj.shadow_server_version = viewobj.backup_shadow_server_version
viewobj.edit_stack = []
# Remove any elements from the edit stack with low version numbers which
# have been acked by the client.
x = 0
while x < len(viewobj.edit_stack):
if viewobj.edit_stack[x][0] <= action["server_version"]:
del viewobj.edit_stack[x]
else:
x += 1
if action["mode"] == "raw":
# It's a raw text dump.
data = urllib.unquote(action["data"]).decode("utf-8")
mobwrite_core.LOG.info("Got %db raw text: '%s'" % (len(data), viewobj))
viewobj.delta_ok = True
# First, update the client's shadow.
viewobj.shadow = data
viewobj.shadow_client_version = action["client_version"]
viewobj.shadow_server_version = action["server_version"]
viewobj.backup_shadow = viewobj.shadow
viewobj.backup_shadow_server_version = viewobj.shadow_server_version
viewobj.edit_stack = []
if action["force"] or textobj.text is None:
# Clobber the server's text.
textobj.lock.acquire()
try:
if textobj.text != data:
textobj.setText(data)
mobwrite_core.LOG.debug("Overwrote content: '%s'" % viewobj)
finally:
textobj.lock.release()
elif action["mode"] == "delta":
# It's a delta.
mobwrite_core.LOG.info("Got '%s' delta: '%s'" % (action["data"], viewobj))
if action["server_version"] != viewobj.shadow_server_version:
# Can't apply a delta on a mismatched shadow version.
viewobj.delta_ok = False
mobwrite_core.LOG.warning("Shadow version mismatch: %d != %d" %
(action["server_version"], viewobj.shadow_server_version))
elif action["client_version"] > viewobj.shadow_client_version:
# Client has a version in the future?
viewobj.delta_ok = False
mobwrite_core.LOG.warning("Future delta: %d > %d" %
(action["client_version"], viewobj.shadow_client_version))
elif action["client_version"] < viewobj.shadow_client_version:
# We've already seen this diff.
pass
mobwrite_core.LOG.warning("Repeated delta: %d < %d" %
(action["client_version"], viewobj.shadow_client_version))
else:
# Expand the delta into a diff using the client shadow.
try:
diffs = mobwrite_core.DMP.diff_fromDelta(viewobj.shadow, action["data"])
except ValueError:
diffs = None
viewobj.delta_ok = False
mobwrite_core.LOG.warning("Delta failure, expected %d length: '%s'" %
(len(viewobj.shadow), viewobj))
viewobj.shadow_client_version += 1
if diffs != None:
# Textobj lock required for read/patch/write cycle.
textobj.lock.acquire()
try:
self.applyPatches(viewobj, diffs, action)
finally:
textobj.lock.release()
# Generate output if this is the last action or the username/filename
# will change in the next iteration.
if ((action_index + 1 == len(actions)) or
actions[action_index + 1]["username"] != username or
actions[action_index + 1]["filename"] != filename):
print_username = None
print_filename = None
if action["echo_username"] and last_username != username:
# Print the username if the previous action was for a different user.
print_username = username
if last_filename != filename or last_username != username:
# Print the filename if the previous action was for a different user
# or file.
print_filename = filename
output.append(self.generateDiffs(viewobj, print_username,
print_filename, action["force"]))
last_username = username
last_filename = filename
# Dereference the view object so that a new one can be created.
viewobj = None
return "".join(output)
def generateDiffs(self, viewobj, print_username, print_filename, force):
output = []
if print_username:
output.append("u:%s\n" % print_username)
if print_filename:
output.append("F:%d:%s\n" % (viewobj.shadow_client_version, print_filename))
textobj = viewobj.textobj
mastertext = textobj.text
if viewobj.delta_ok:
if mastertext is None:
mastertext = ""
# Create the diff between the view's text and the master text.
diffs = mobwrite_core.DMP.diff_main(viewobj.shadow, mastertext)
mobwrite_core.DMP.diff_cleanupEfficiency(diffs)
text = mobwrite_core.DMP.diff_toDelta(diffs)
if force:
# Client sending 'D' means number, no error.
# Client sending 'R' means number, client error.
# Both cases involve numbers, so send back an overwrite delta.
viewobj.edit_stack.append((viewobj.shadow_server_version,
"D:%d:%s\n" % (viewobj.shadow_server_version, text)))
else:
# Client sending 'd' means text, no error.
# Client sending 'r' means text, client error.
# Both cases involve text, so send back a merge delta.
viewobj.edit_stack.append((viewobj.shadow_server_version,
"d:%d:%s\n" % (viewobj.shadow_server_version, text)))
viewobj.shadow_server_version += 1
mobwrite_core.LOG.info("Sent '%s' delta: '%s'" % (text, viewobj))
else:
# Error; server could not parse client's delta.
# Send a raw dump of the text.
viewobj.shadow_client_version += 1
if mastertext is None:
mastertext = ""
viewobj.edit_stack.append((viewobj.shadow_server_version,
"r:%d:\n" % viewobj.shadow_server_version))
mobwrite_core.LOG.info("Sent empty raw text: '%s'" % viewobj)
else:
# Force overwrite of client.
text = mastertext
text = text.encode("utf-8")
text = urllib.quote(text, "!~*'();/?:@&=+$,# ")
viewobj.edit_stack.append((viewobj.shadow_server_version,
"R:%d:%s\n" % (viewobj.shadow_server_version, text)))
mobwrite_core.LOG.info("Sent %db raw text: '%s'" %
(len(text), viewobj))
viewobj.shadow = mastertext
for edit in viewobj.edit_stack:
output.append(edit[1])
return "".join(output)
def cleanup_thread():
# Every minute cleanup.
while True:
mobwrite_core.LOG.info("Running cleanup task.")
for v in views.values():
v.cleanup()
for v in texts.values():
v.cleanup()
timeout = datetime.datetime.now() - mobwrite_core.TIMEOUT_TEXT
time.sleep(60)
def main():
mobwrite_core.CFG.initConfig("./mobwrite.cfg")
# Start up a thread that does timeouts and cleanup.
thread.start_new_thread(cleanup_thread, ())
port = int(mobwrite_core.CFG.get("LOCAL_PORT", 3017))
mobwrite_core.LOG.info("Listening on port %d..." % port)
s = HTTPServer(("", port), DaemonMobWrite)
try:
s.serve_forever()
except KeyboardInterrupt:
mobwrite_core.LOG.info("Shutting down.")
s.socket.close()
if __name__ == "__main__":
mobwrite_core.logging.basicConfig()
main()
mobwrite_core.logging.shutdown()
================================================
FILE: server/code.js
================================================
/**
* @license
* Copyright 2018 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Utilities for manipulating JavaScript code.
* @author cpcallen@google.com (Christopher Allen)
*/
'use strict';
/**
* A collection of useful regular expressions.
* @const
*/
var regexps = {};
/**
* Matches (globally) escape sequences found in string and regexp
* literals, like '\n' or '\x20' or '\u1234'.
* @const
*/
regexps.escapes = /\\(?:["'\\\/0bfnrtv]|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{2})/g;
/**
* Matches a single-quoted string literal, like "'this one'" and
* "'it\\'s'".
* @const
*/
regexps.singleQuotedString =
new RegExp("'(?:[^'\\\\\\r\\n\\u2028\\u2029]|" +
regexps.escapes.source + ")*'", 'g');
/**
* Matches a double-quoted string literal, like '"this one"' and
* '"it\'s"'.
* @const
*/
regexps.doubleQuotedString =
new RegExp('"(?:[^"\\\\\\r\\n\\u2028\\u2029]|' +
regexps.escapes.source + ')*"', 'g');
/**
* Matches a string literal, like "'this one' and '"that one"' as well
* as "the 'string literal' substring of this longer string" too.
* @const
*/
regexps.string = new RegExp('(?:' + regexps.singleQuotedString.source + '|' +
regexps.doubleQuotedString.source + ')', 'g');
/**
* Matches exaclty a string literal, like "'this one'" but notably not
* " 'this one' " (because it contains other characters not part of
* the literal).
* @const
*/
regexps.stringExact = new RegExp('^' + regexps.string.source + '$');
/**
* RegExp matching a valid JavaScript identifier (strictly an
* IdentifierName, which does not exclude ReservedWord). Note that
* this is fairly conservative, because ANY Unicode letter can appear
* in an identifier - but the full regexp is absurdly complicated.
* @const
*/
regexps.identifier = /[A-Za-z_$][A-Za-z0-9_$]*/g;
/**
* RegExp matching exactly a valid JavaScript identifier. See note
* for .identifier, above.
* @const
*/
regexps.identifierExact = new RegExp('^' + regexps.identifier.source + '$');
/**
* Convert a string representation of a string literal to a string.
* Basically does eval(s), but safely and only if s is a string literal.
* @param {string} s A string consisting of exactly a string literal.
* @return {string} The string value of the literal s.
*/
var parseString = function(s) {
if (!regexps.stringExact.test(s)) {
throw new TypeError(quote(s) + ' is not a string literal');
};
return s.slice(1, -1).replace(regexps.escapes, function(esc) {
switch (esc[1]) {
case "'":
case '"':
case '/':
case '\\':
return esc[1];
case '0':
return '\0';
case 'b':
return '\b';
case 'f':
return '\f';
case 'n':
return '\n';
case 'r':
return '\r';
case 't':
return '\t';
case 'v':
return '\v';
case 'u':
case 'x':
return String.fromCharCode(parseInt(esc.slice(2), 16));
default:
// RegExp in call to replace has accepted something we
// don't know how to decode.
throw new Error('unknown escape sequence "' + esc + '"??');
}
});
};
/**
* Convert a string into a string literal. We use single or double
* quotes depending on which occurs less frequently in the string to
* be escaped (prefering single quotes if it's a tie). Strictly
* speaking we only need to escape backslash, \r, \n, \u2028 (line
* separator), \u2029 (paragraph separator) and whichever quote
* character we're using, but for output readability we escape all the
* control characters.
*
* TODO(cpcallen): Consider using optimised algorithm from Node.js's
* util.format (see strEscape function in
* https://github.com/nodejs/node/blob/master/lib/util.js).
* @param {string} str The string to convert.
* @return {string} The value s as a eval-able string literal.
*/
var quote = function(str) {
if (count(str, "'") > count(str, '"')) { // More 's. Use "s.
return '"' + str.replace(quote.doubleRE, quote.replace) + '"';
} else { // Equal or more "s. Use 's.
return "'" + str.replace(quote.singleRE, quote.replace) + "'";
}
};
/**
* Regexp for characters to be escaped in a single-quoted string.
*/
quote.singleRE = /[\x00-\x1f\\\u2028\u2029']/g;
/**
* Regexp for characters to be escaped in a single-quoted string.
*/
quote.doubleRE = /[\x00-\x1f\\\u2028\u2029"]/g;
/**
* Replacer function (for either case)
* @param {string} c Single UTF-16 code unit ("character") string to
* be replaced.
* @return {string} Multi-character string containing escaped
* representation of c.
*/
quote.replace = function(c) {
return quote.replacements[c];
};
/**
* Map of replacements for quote function.
*/
quote.replacements = {
'\x00': '\\0', '\x01': '\\x01', '\x02': '\\x02', '\x03': '\\x03',
'\x04': '\\x04', '\x05': '\\x05', '\x06': '\\x06', '\x07': '\\x07',
'\x08': '\\b', '\x09': '\\t', '\x0a': '\\n', '\x0b': '\\v',
'\x0c': '\\f', '\x0d': '\\r', '\x0e': '\\x0e', '\x0f': '\\x0f',
'"': '\\"', "'": "\\'", '\\': '\\\\',
'\u2028': '\\u2028', '\u2029': '\\u2029',
};
/**
* Count non-overlapping occurrences of searchString in str.
*
* There are many possible implementations; using .split works pretty
* well but this is slightly faster at time of writing. See
* https://jsperf.com/count-the-number-of-characters-in-a-string for
* latest performance measurements.
* @param {string} str The string to be searched.
* @param {string} searchString The string to count occurrences of.
* @return {number} The number of occurrences of searchString in str.
*/
var count = function(str, searchString) {
var index = 0;
for(var count = 0; ; count++) {
index = str.indexOf(searchString, index);
if (index === -1) return count;
index += searchString.length;
}
};
exports.quote = quote;
exports.regexps = regexps;
exports.parseString = parseString;
// For unit testing only!
exports.testOnly = {
count: count,
}
================================================
FILE: server/codecity
================================================
#!/usr/bin/env node
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview A virtual world of collaborative coding.
* @author fraser@google.com (Neil Fraser)
*/
'use strict';
const crypto = require('crypto');
const fs = require('fs');
const path = require('path');
const Interpreter = require('./interpreter');
const Parser = require('./parser').Parser;
const Serializer = require('./serialize');
var CodeCity = {};
CodeCity.databaseDirectory = '';
CodeCity.interpreter = null;
CodeCity.config = null;
/**
* Start a running instance of Code City. May be called on a command line.
* @param {string=} configFile Path and filename of configuration file.
* If not present, look for the configuration file as a command line parameter.
*/
CodeCity.startup = function(configFile) {
// process.argv is a list containing: ['node', 'codecity', 'db/google.cfg']
configFile = configFile || process.argv[2];
if (!configFile) {
console.error('Configuration file not found.\n' +
'Usage: node %s ', process.argv[1]);
process.exit(1);
}
var contents = CodeCity.loadFile(configFile);
CodeCity.config = CodeCity.parseJson(contents);
// Find the most recent database file.
var dir = CodeCity.config.databaseDirectory || './';
if (dir[0] === '/') {
CodeCity.databaseDirectory = dir;
} else {
CodeCity.databaseDirectory = path.join(path.dirname(configFile), dir);
}
if (!fs.existsSync(CodeCity.databaseDirectory)) {
console.error('Database directory not found: ' +
CodeCity.databaseDirectory);
process.exit(1);
}
// Find the most recent database file.
var checkpoint = CodeCity.allCheckpoints()[0];
// Load the interpreter.
if (checkpoint) {
var filename = path.join(CodeCity.databaseDirectory, checkpoint);
CodeCity.interpreter = CodeCity.loadCheckpoint(filename);
} else {
// Database not found, load one or more startup files instead.
console.log('Unable to find database file in %s, looking for startup ' +
'file(s) instead.', CodeCity.databaseDirectory);
CodeCity.interpreter = CodeCity.loadStartup(CodeCity.databaseDirectory);
}
// Checkpoint at regular intervals.
// TODO: Let the interval be configurable from the database.
var interval = CodeCity.config.checkpointInterval || 600;
CodeCity.config.checkpointInterval = interval;
if (interval > 0) {
setInterval(CodeCity.checkpoint, interval * 1000);
}
console.log('Load complete. Starting Code City.');
CodeCity.interpreter.start();
};
/**
* Create an Interpreter instance with desired options and initialise
* it with custom builtins.
* @return {!Interpreter}
*/
CodeCity.makeInterpreter = function() {
var intrp = new Interpreter({
trimEval: true,
trimProgram: true,
methodNames: true,
stackLimit: 10000,
});
CodeCity.initSystemFunctions(intrp);
CodeCity.initLibraryFunctions(intrp);
return intrp;
};
/**
* Create an Interpreter instance and deserialise a .city checkpoint
* into it.
* @param {string} filename The filename of the .city file to read.
* @return {!Interpreter}
*/
CodeCity.loadCheckpoint = function(filename) {
var intrp = CodeCity.makeInterpreter();
var flatpack = CodeCity.parseJson(CodeCity.loadFile(filename));
Serializer.deserialize(flatpack, intrp);
console.log('Checkpoint %s loaded.', filename);
return intrp;
};
/**
* Create an Interpreter instance and load startup .js files into it.
* @param {string} dir The directory containing startup files to be read.
* @return {!Interpreter}
*/
CodeCity.loadStartup = function(dir) {
var intrp = CodeCity.makeInterpreter();
var fileCount = 0;
var files = fs.readdirSync(dir);
for (var i = 0; i < files.length; i++) {
if (files[i].match(/^(core|db|test).*\.js$/)) {
var filename = path.join(dir, files[i]);
var contents = CodeCity.loadFile(filename);
console.log('Loading startup file %s', filename);
intrp.createThreadForSrc(contents);
fileCount++;
}
}
if (fileCount === 0) {
console.error('Unable to find startup file(s) in %s', dir);
process.exit(1);
}
console.log('Loaded %d startup file(s) from %s', fileCount, dir);
return intrp;
};
/**
* Open a file and read its contents. Die if there's an error.
* @param {string} filename
* @return {string} File contents.
*/
CodeCity.loadFile = function(filename) {
// Load the specified file from disk.
try {
return fs.readFileSync(filename, 'utf8').toString();
} catch (e) {
console.error('Unable to open file: %s', filename);
console.info(e);
process.exit(1);
}
};
/**
* Parse text as JSON value. Die if there's an error.
* @param {string} text
* @return {*} JSON value.
*/
CodeCity.parseJson = function(text) {
// Convert from text to JSON.
try {
return JSON.parse(text);
} catch (e) {
console.error('Syntax error in parsing JSON');
console.info(e);
process.exit(1);
}
};
/**
* Return a list of all currently saved checkpoints, ordered from most
* to least recent.
* @return {!Array} Array of filenames for checkpoints.
*/
CodeCity.allCheckpoints = function() {
var files = fs.readdirSync(CodeCity.databaseDirectory);
files = files.filter((file) => CodeCity.allCheckpoints.regexp_.test(file));
files.sort().reverse();
return files;
};
CodeCity.allCheckpoints.regexp_ =
/^\d{4}-\d\d-\d\dT\d\d\.\d\d\.\d\d(\.\d{1,3})?Z?\.city$/;
/**
* Delete as many checkpoints as needed until there's room to fit a new one.
*/
CodeCity.deleteCheckpointsIfNeeded = function() {
var checkpoints = CodeCity.allCheckpoints();
var minFiles = Math.max(0, CodeCity.config.checkpointMinFiles || 0);
if (!checkpoints.length || checkpoints.length < minFiles) {
return; // Not enough checkpoints saved.
}
// Look up size of last checkpoint.
var lastCheckpointSize =
CodeCity.fileSize(checkpoints[checkpoints.length - 1]);
var directorySize = checkpoints.reduce((sum, fileName) =>
sum + CodeCity.fileSize(fileName), 0);
// Budget for a possible 10% growth.
var estimateNext = directorySize + lastCheckpointSize * 1.1;
var maxSize = CodeCity.config.checkpointMaxDirectorySize * 1024 * 1024;
if (typeof maxSize !== 'number') {
maxSize = Infinity;
}
if (estimateNext < maxSize) {
return; // There's room.
}
// Choose and delete one file.
var deleteFile = CodeCity.chooseCheckpointToDelete(checkpoints);
var fullPath = path.join(CodeCity.databaseDirectory, deleteFile);
console.log('Deleting checkpoint ' + fullPath);
fs.unlinkSync(fullPath);
// Do it again, until no delete is needed.
CodeCity.deleteCheckpointsIfNeeded();
};
/**
* Given a list of checkpoint filenames, choose one to delete.
* See https://neil.fraser.name/software/backup/
* @param {!Array} checkpoints Array of checkpoint filenames.
* @return {string} Filename of checkpoint to delete.
*/
CodeCity.chooseCheckpointToDelete = function(checkpoints) {
// Convert all filenames (e.g. '2018-11-09T18.49.50.548Z.city')
// into ISO-8601 format (e.g. '2018-11-09T18:49:50.548Z'),
// then parse as milliseconds.
var checkpointTimes = checkpoints.map((name) =>
Date.parse(name.slice(0, -5).replace('.', ':').replace('.', ':')));
var currentTime = Date.now();
var totalTime = currentTime - checkpointTimes[checkpointTimes.length - 1];
var interval = CodeCity.config.checkpointInterval * 1000;
// Planning to delete one checkpoint.
var checkpointCount = checkpoints.length - 1;
// Compute ideal times.
var missing = Math.max(totalTime / interval - checkpointCount, 0);
var decayRate = (missing + 1) ** (1 / checkpointCount);
var idealTimes = new Array(checkpointTimes.length);
for (var n = 0; n < checkpointTimes.length; n++) {
idealTimes[n] = currentTime - (interval * (n + decayRate ** n - 1));
}
// Choose one backup for deletion.
// Compute the cumulative error from the right side. Store in array.
var rightDiff = new Array(checkpointTimes.length);
var accumulator = 0;
for (var n = checkpointTimes.length - 1; n >= 1; n--) {
accumulator += Math.abs(checkpointTimes[n] - idealTimes[n]);
rightDiff[n] = accumulator;
}
// Compute the cumulative error from the left side (with backups shifted by
// one position, as would happen after a deletion).
// Use rightDiff array to compute total error for each possible deletion.
accumulator = 0;
var minDiff = Infinity;
var minIndex = 0;
for (var n = 1; n < checkpointTimes.length - 1; n++) {
accumulator += Math.abs(checkpointTimes[n - 1] - idealTimes[n]);
var diff = accumulator + rightDiff[n + 1];
if (diff < minDiff) {
// Smallest total error yet. Save this candidate.
minDiff = diff;
minIndex = n;
}
}
return checkpoints[minIndex];
};
/**
* Find the size of a file in the current database directory.
* @param {string} fileName Name of file.
* @return {number} Number of bytes in file.
*/
CodeCity.fileSize = function(fileName) {
var fullPath = path.join(CodeCity.databaseDirectory, fileName);
return fs.statSync(fullPath).size;
};
/**
* Save the database to disk.
* @param {boolean} sync True if Code City intends to shutdown afterwards.
* False if Code City is running this in the background.
*/
CodeCity.checkpoint = function(sync) {
console.log('Checkpointing...');
CodeCity.deleteCheckpointsIfNeeded();
try {
CodeCity.interpreter.pause();
var json = Serializer.serialize(CodeCity.interpreter);
} finally {
sync || CodeCity.interpreter.start();
}
// JSON.stringify(json) would work, but adding linebreaks so that every
// object is on its own line makes the output more readable.
var text = [];
for (var i = 0; i < json.length; i++) {
text.push(JSON.stringify(json[i]));
}
text = '[' + text.join(',\n') + ']';
var filename = (new Date()).toISOString().replace(/:/g, '.') + '.city';
filename = path.join(CodeCity.databaseDirectory, filename);
var tmpFilename = filename + '.partial';
try {
fs.writeFileSync(tmpFilename, text);
fs.renameSync(tmpFilename, filename);
console.log('Checkpoint ' + filename + ' complete.');
} catch (e) {
console.error('Checkpoint failed! ' + e);
} finally {
// Attempt to remove partially-written checkpoint if it still exists.
try {
fs.unlinkSync(tmpFilename);
} catch (e) {
}
}
};
/**
* Shutdown Code City. Checkpoint the database before terminating.
* Optional parameter is exit code (if numeric) or signal to (re-)kill
* process with (if string). Re-killing after checkpointing allows
* systemd to accurately determine cause of death. Defaults to 0.
* @param {string|number=} code Exit code or signal.
*/
CodeCity.shutdown = function(code) {
if (CodeCity.config.checkpointAtShutdown !== false) {
CodeCity.checkpoint(true);
}
if (typeof code === 'string') {
process.kill(process.pid, code);
} else {
process.exit(code || 0);
}
};
/**
* Print one line to the log. Allows for interpolated strings.
* @param {...*} var_args Arbitrary arguments for console.log.
*/
CodeCity.log = function(var_args) {
console.log.apply(console, arguments);
};
/**
* Initialize user-callable system functions.
* These are not part of any JavaScript standard.
* BUG(#280): provide (new) NativeFunction wrappers.
* @param {!Interpreter} intrp The Interpreter instance to initialize.
*/
CodeCity.initSystemFunctions = function(intrp) {
intrp.createNativeFunction('CC.log', CodeCity.log, false);
intrp.createNativeFunction('CC.checkpoint', CodeCity.checkpoint, false);
intrp.createNativeFunction('CC.shutdown', function(code) {
CodeCity.shutdown(Number(code));
}, false);
};
/**
* Initialize user-callable library functions.
* These are not part of any JavaScript standard.
* @param {!Interpreter} intrp The Interpreter instance to initialize.
*/
CodeCity.initLibraryFunctions = function(intrp) {
new intrp.NativeFunction({
id: 'CC.acorn.parse', length: 1,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var code = args[0];
var perms = state.scope.perms;
if (typeof code !== 'string') {
throw new intrp.Error(perms, intrp.TYPE_ERROR,
'argument to parse must be a string');
}
try {
var ast = Parser.parse(code);
} catch (e) {
throw intrp.errorNativeToPseudo(e, perms);
}
return intrp.nativeToPseudo(ast, perms);
}
});
new intrp.NativeFunction({
id: 'CC.acorn.parseExpressionAt', length: 2,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var code = args[0];
var offset = args[1];
var perms = state.scope.perms;
if (typeof code !== 'string') {
throw new intrp.Error(perms, intrp.TYPE_ERROR,
'first argument to parseExpressionAt must be a string');
}
if (typeof offset !== 'number') {
throw new intrp.Error(perms, intrp.TYPE_ERROR,
'second argument to parseExpressionAt must be a number');
}
try {
var ast = Parser.parseExpressionAt(code, offset);
} catch (e) {
throw intrp.errorNativeToPseudo(e, perms);
}
return intrp.nativeToPseudo(ast, perms);
}
});
new intrp.NativeFunction({
id: 'CC.hash', length: 2,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var hash = String(args[0]);
var data = args[1];
var perms = state.scope.perms;
var hashes = crypto.getHashes();
if (!hashes.includes(hash)) {
throw new intrp.Error(perms, intrp.RANGE_ERROR,
'first argument to hash must be one of:\n' +
hashes.map(function(h) {return " '" + h + "'\n";}).join(''));
}
if (typeof data !== 'string') {
throw new intrp.Error(perms, intrp.TYPE_ERROR,
'second argument to hash must be a string');
}
try {
return String(crypto.createHash(hash).update(data).digest('hex'));
} catch (e) {
throw intrp.errorNativeToPseudo(e, perms);
}
}
});
};
///////////////////////////////////////////////////////////////////////////////
// Main program.
// If this file is executed form a command line, startup Code City.
// Otherwise, if it is required as a library, do nothing.
if (require.main === module) {
CodeCity.startup();
// SIGTERM and SIGINT shut down server.
process.once('SIGTERM', CodeCity.shutdown.bind(null, 'SIGTERM'));
process.once('SIGINT', CodeCity.shutdown.bind(null, 'SIGINT'));
// SIGHUP forces checkpoint.
process.on('SIGHUP', CodeCity.checkpoint.bind(null, false));
}
///////////////////////////////////////////////////////////////////////////////
// Exports
module.exports = CodeCity;
================================================
FILE: server/compile
================================================
#!/bin/bash
# Copyright 2019 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# Run the Closure Compiler, in --checks-only mode, on the Code City
# server (and optionally server unit tests as well).
# Compile tests, which also compile server:
readonly ENTRY_POINT=tests/run.js
# Aternatively, compile server alone:
# readonly ENTRY_POINT=codecity.js
# List of arguments to feed to compiler - flags and filenames.
args=(-O=ADVANCED_OPTIMIZATIONS
--checks-only
--module_resolution=NODE
--process_common_js_modules
--assume_function_wrapper
--dependency_mode=PRUNE
--externs=externs/node.js
--externs=externs/WeakRef.js
--hide_warnings_for=node_modules/acorn
node_modules/acorn/package.json
node_modules/acorn/**.mjs
iterable_weakmap.js
iterable_weakset.js
registry.js
parser.js
interpreter.js
serialize.js
code.js
selector.js
dumper.js
codecity
priorityqueue.js
dump
tests/*.js
)
# Set current directory to the one containing this script.
cd "$(dirname "${BASH_SOURCE[0]}")"
# Temporarily symlink extern declarations for node builtins into
# node_modules/, and add their .js and package.json files to args.
declare -a builtins
for path in externs/*; do
if [[ -d "${path}" && -f "${path}/package.json" ]]; then
builtins+=("$(basename "${path}")")
fi
done
for builtin in "${builtins[@]}"; do
link="node_modules/${builtin}"
if [[ -e "${link}" ]]; then
if [[ -L "${link}" ]]; then
rm "${link}" # Remove old symlink.
else
echo "$0: aborting because ${link} already exists and is not a symlink" \
1>&2
exit 1
fi
fi
ln -s "../externs/${builtin}" "${link}"
args+=("${link}"/{*.js,package.json})
done
google-closure-compiler "${args[@]}" --entry_point="${ENTRY_POINT}"
return="$?"
# Remove extern symlinks.
for builtin in "${builtins[@]}"; do
link="node_modules/${builtin}"
if [[ ! -L "${link}" ]]; then
echo "$0: aborting because ${link} is no longer a symlink" 1>&2
exit 1
fi
rm "${link}"
done
exit ${return}
================================================
FILE: server/config.txt
================================================
Documentation for config file options:
"databaseDirectory": string
Relative path from this config file to the database directory.
Defaults to "./" (current directory).
"checkpointInterval": number
Number of seconds between regular checkpoints.
If 0, then no regular checkpoints.
Defaults to 600 (10 minutes).
TODO: Move this configuration option into the database.
"checkpointAtShutdown": boolean
If true, save a checkpoint when the server shuts down.
If false, don't save a checkpoint, which results in lost data.
Defaults to true.
"checkpointMinFiles": number
Minimum number of checkpoint files in a directory. While there are
fewer than this number, then no checkpoints will be deleted.
Defaults to 0.
"checkpointMaxDirectorySize": number
Maximum number of megabytes allowed for checkpoints in checkpoint
directory. If this value is exceeded and checkpointMinFiles is also
satisfied, then one or more old checkpoints will be deleted to make
room for the next checkpoint.
Defaults to Infinity.
================================================
FILE: server/dump
================================================
#!/usr/bin/env node
/**
* @license
* Copyright 2018 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Infrastructure to save the state of an Interpreter as
* eval-able JS. Mainly a wrapper around Dumper, handling
* the application of a dupmp configuration.
* @author cpcallen@google.com (Christopher Allen)
*/
'use strict';
var code = require('./code');
var CodeCity = require('./codecity');
var Do = require('./dumper').Do;
var Dumper = require('./dumper').Dumper;
var DumperOptions = require('./dumper').DumperOptions;
var Writable = require('./dumper').Writable;
var fs = require('fs');
var Interpreter = require('./interpreter');
var path = require('path');
var Selector = require('./selector');
/**
* Dump an Interpreter using a given dump specification.
* @param {!Interpreter} intrp1 An interpreter initialised exactly as
* the one the ouptut JS will be executed by.
* @param {!Interpreter} intrp2 An interpreter containing state
* modifications (relative to intrp1) to be dumped.
* @param {!Array} config The dump specification.
* @param {string=} directory A directory relative to which
* non-absolute filenames in config should be written. If none is
* supplied then they will be treated as relative to the current
* directory.
* @param {boolean=} verbose Print message describing what is being done.
*/
var dump = function(intrp1, intrp2, config, directory, verbose) {
var dumper = new Dumper(intrp1, intrp2, {verbose: verbose});
if (verbose) console.log('Dumper initialised.');
// Skip everything that's explicitly mentioned in the config, so
// that paths won't get dumped until it's their turn.
for (var item, i = 0; (item = config[i]); i++) {
if (!item.contents) continue;
for (var entry, j = 0; (entry = item.contents[j]); j++) {
dumper.skip(entry.selector);
}
}
var /** string */ header = '';
// Dump the specified paths, in order.
for (var item, i = 0; (item = config[i]); i++) {
if ('options' in item) { // An OptionsItem.
dumper.setOptions(item.options);
continue;
}
// A FileItem.
var filename = item.filename;
if (verbose) console.log('Dumping to %s...', filename);
if (directory !== undefined && !path.isAbsolute(filename)) {
filename = path.normalize(path.join(directory, filename));
}
var outputStream = new SyncWriter(filename);
dumper.setOptions({output: outputStream});
for (var selector, j = 0; (selector = item.prune[j]); j++) {
dumper.prune(selector);
}
for (var selector, j = 0; (selector = item.pruneRest[j]); j++) {
dumper.pruneRest(selector);
}
if (item.header !== undefined) header = item.header;
var fileHeader = header;
for (var key in item.headerSubs) {
fileHeader = fileHeader.replace(key, item.headerSubs[key]);
}
if (fileHeader) dumper.write(fileHeader);
if (item.contents) {
for (var entry, j = 0; (entry = item.contents[j]); j++) {
if (verbose) console.log('Dumping: %s', entry.selector);
dumper.unskip(entry.selector);
dumper.dumpBinding(entry.selector, entry.do);
dumper.write('\n');
}
}
if (item.rest) {
if (verbose) console.log('Dumping rest.');
dumper.dump();
}
outputStream.end();
}
};
/**
* Convert a dump plan from an !Array to
* !Array, with validataion and a few conversions:
*
* - Whereas as in the input, paths will will be represented by
* selector strings, in the corresponding output the properties will
* be Selectors. The SpecConfigEntry path: will become .selector in
* the corresponding COnfigEntry.
*
* - Whereas the input will specify do: values as strings
* (e.g. "RECURSE"), the output will have Do enum values
* (e.g. Do.RECURSE) instead.
*
* - A plain selector string ss, appearing in the contents: array of a
* SpecFileItem, will be replaced by the ContentEntry
* {selector: new Selector(ss), do: Do.RECURSE, reorder: false}.
*
* - All optional boolean-valued properties will be normalised to
* exist, defaulting to false.
*
* @param {*} spec The dump plan to be validated. If this is not an
* !Array, TypeError will be thrown.
* @return {!Array}
*/
var configFromSpec = function(spec) {
var /** !Array */ config = [];
/** @type {function(string, number=)} */
function reject(message, j) {
var prefix = 'spec[' + i + ']';
if (j !== undefined) prefix = prefix + '.contents[' + j + ']';
if (message[0] !== '.') prefix = prefix + ' ';
throw new TypeError(prefix + message);
}
if (!Array.isArray(spec)) {
throw new TypeError('spec must be an array of SpecConfigItems');
}
for (var i = 0; i < spec.length; i++) {
var item = spec[i];
if (typeof item !== 'object' || item === null) {
reject('not a SpecConfigItem object');
}
if ('filename' in item) { // It's a SpecFileItem.
var /** (string|undefined) */ header;
var /** !Object */ headerSubs = {};
var /** !Array */ prune = [];
var /** !Array */ pruneRest = [];
var /** !Array */ contents = [];
if (typeof item.filename !== 'string') {
// TODO(cpcallen): add better filename validity check?
reject('.filename is not a string');
} else if (!Array.isArray(item.contents) && item.contents !== undefined) {
reject('.contents is not an array');
} else if (typeof item.rest !== 'boolean' && item.rest !== undefined) {
reject('.rest is not a boolean');
}
if (item.header instanceof Array) {
header = item.header.join('\n');
} else if (typeof item.header === 'string' || item.header === undefined) {
header = item.header;
} else {
reject('.header is not string or array of strings');
}
if (item.headerSubs instanceof Object) {
for (var key in item.headerSubs) {
var value = item.headerSubs[key];
if (value instanceof Array) {
headerSubs[key] = value.join('\n');
} else if (typeof value === 'string') {
headerSubs[key] = value;
} else {
reject('.headerSubs.' + key + ' is not a string');
}
}
} else if (item.headerSubs !== undefined) {
reject('.headerSubs is not an object');
}
if ('prune' in item) {
if (!Array.isArray(item.prune)) {
reject('.prune is not an array');
}
for (var j = 0; j < item.prune.length; j++) {
prune.push(new Selector(item.prune[j]));
}
}
if ('pruneRest' in item) {
if (!Array.isArray(item.pruneRest)) {
reject('.pruneRest is not an array');
}
for (j = 0; j < item.pruneRest.length; j++) {
pruneRest.push(new Selector(item.pruneRest[j]));
}
}
if ('contents' in item) {
for (j = 0; j < item.contents.length; j++) {
var entry = item.contents[j];
if (typeof entry === 'string') {
var selector = new Selector(entry);
contents.push({selector: selector, do: Do.RECURSE, reorder: false});
continue;
} else if (typeof entry !== 'object' || entry === null) {
reject('not a SpecContentEntry object', j);
} else if (typeof entry.path !== 'string') {
reject('.path not a vaid selector string', j);
} else if (!Do.hasOwnProperty(entry.do)) {
reject('.do: ' + entry.do + ' is not a valid Do value', j);
} else if (typeof entry.reorder !== 'boolean' &&
entry.reorder !== undefined) {
reject('.reorder must be boolean or omitted', j);
}
contents.push({
selector: new Selector(entry.path),
do: Do[entry.do],
reorder: Boolean(entry.reorder),
});
}
} else if (!item.rest) {
reject('must specify one of .contents or .rest');
}
config.push({
filename: item.filename,
header: header,
headerSubs: headerSubs,
prune: prune,
pruneRest: pruneRest,
contents: contents, // Possibly empty.
rest: Boolean(item.rest),
});
} else if ('options' in item) { // It's a SpecOptionsItem.
if (typeof item.options !== 'object') {
reject('.options is not a DumperOptions object');
// TODO(cpcallen): additional type checks?
}
config.push({options: item.options});
} else {
reject('is neither a SpecFileItem nor a SpecOptionsItem');
}
}
return config;
};
/**
* A synchronous writable stream, with an API that is a simplified
* subset of stream.Writable.
* @constructor
* @struct
* @implements Writable
* @param {string} filename The file to write to.
*/
var SyncWriter = function(filename) {
/** @type {number|null} */
this.fd = fs.openSync(filename, 'w', 0o600);
};
/**
* Write string to file.
* @override
* @param {string} s String to write.
* @returns {void}
*/
SyncWriter.prototype.write = function(s) {
if (this.fd === null) throw Error('stream already ended');
fs.writeSync(this.fd, s);
};
/**
* Close file.
* @returns {void}
*/
SyncWriter.prototype.end = function() {
if (this.fd === null) throw Error('stream already ended');
fs.closeSync(this.fd);
this.fd = null;
};
///////////////////////////////////////////////////////////////////////////////
// Data types used to specify a dump configuration.
///////////////////////////////////////////////////////////////////////////////
// For internal use; strict types:
/**
* A processed-and-ready-to-use configuration entry.
* @typedef {!OptionsItem|!FileItem}
*/
var ConfigItem;
/**
* A processed-and-ready-to-use configuration entry setting general
* options.
* @typedef {{copyright: (string|!Array|undefined),
* options: !DumperOptions}}
*/
var OptionsItem;
/**
* A processed-and-ready-to-use configuration entry for a single
* output file.
* @typedef {{filename: string,
* header: (string|undefined),
* headerSubs: !Object,
* prune: !Array,
* pruneRest: !Array,
* contents: !Array,
* rest: boolean}}
*/
var FileItem;
/**
* The type of the values of .contents entries of a ConfigEntry.
*
* - selector: is a Selector identifying the variable or property
* binding this entry applies to.
*
* - do: is a Do value speciifying how much of selector to dump.
*
* - reorder: is a boolean specifying whether it is acceptable to
* allow property or set/map entry entries to be created (by the
* output JS) in a different order than they apear in the
* interpreter instance being serialised. If false, output may
* contain placeholder entries like:
*
* var obj = {};
* obj.foo = undefined; // placeholder
* obj.bar = function() { ... };
*
* to allow obj.foo to be defined later while still preserving
* property order.
*
* @typedef {{selector: !Selector,
* do: Do,
* reorder: boolean}}
*/
var ContentEntry = function() {};
//////////////////////////////////////////////////////////////////////
// For dump_spec.json use; loose, JSON-compatible types:
/** @typedef {!SpecOptionsItem|!SpecFileItem} */
var SpecConfigItem;
/**
* An OptionsItem, but with Selectors represented by selector strings.
*
* @typedef {{options: !DumperOptions}}
*/
var SpecOptionsItem;
/**
* A FileItem represented as plain old JavaScript object (i.e., as
* ouptut by JSON.parse):
*
* - Do values are reprsesented by the coresponding strings (e.g.,
* "RECURSE" instead of Do.RECURSE).
* - For convenience, header: and the values of headerSubs: may be an
* arrays of strings, which will be joined with newlines.
* - Contents entries can be just a selector string, which will be
* treated as Do.RECURSE.
*
* @typedef {{filename: string,
* header: (string|!Array|undefined),
* headerSubs: (!Object|string)>|undefined),
* prune: (!Array|undefined),
* pruneRest: (!Array|undefined),
* contents: (!Array|undefined),
* rest: (boolean|undefined)}}
*/
var SpecFileItem;
/**
* Like a ContentEntry, but with a string instead of a Do value.
* @typedef {{path: string,
* do: string,
* reorder: (boolean|undefined)}}
*/
var SpecContentEntry;
///////////////////////////////////////////////////////////////////////////////
// Main program.
///////////////////////////////////////////////////////////////////////////////
if (require.main === module) {
if (process.argv.length < 4) {
console.log(
'usage: dump <.city file> ');
process.exit(1);
}
var cityFile = process.argv[2];
var planFile = process.argv[3];
var dir = process.argv[4];
var intrp = CodeCity.loadCheckpoint(cityFile);
var specText = fs.readFileSync(planFile);
const spec = JSON.parse(String(specText));
var config = configFromSpec(spec);
dump(CodeCity.makeInterpreter(), intrp, config, dir, /*verbose:*/ true);
};
///////////////////////////////////////////////////////////////////////////////
// Exports.
///////////////////////////////////////////////////////////////////////////////
exports.configFromSpec = configFromSpec;
exports.Do = Do;
exports.dump = dump;
================================================
FILE: server/dumper.js
================================================
/**
* @license
* Copyright 2018 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview The Dumper class (and related helpers) to diff the
* state of (parts or all of) two Interpreter objects, outputing
* eval-able JS code to convert the one into the other.
* @author cpcallen@google.com (Christopher Allen)
*/
'use strict';
var code = require('./code');
var Interpreter = require('./interpreter');
var PriorityQueue = require('./priorityqueue').PriorityQueue;
var Selector = require('./selector');
var util = require('util');
///////////////////////////////////////////////////////////////////////////////
// Dumper.
/**
* Dumper compares the state of two Interpreter instances, for the
* purpose of generating eval-able JS that would update part or all(*)
* of the first to the same state as the second. This can be used to
* dump the state of an Interpreter by comparing it against a pristine
* Interpreter instance, or to produce a software patch by comparing a
* long-running Interpreter against a previous version of itself or
* against the target to which the patch will be applied.
*
* (*) Limitations: since there is no way to construct arbitrary stack
* frames by evaling JS source code, it is not at present possible to
* dump the state of threads. This could be rectified in future by
* providing host functions for creating/modifying the stack frames
* associated with Thread objects.
*
* @constructor
* @struct
* @param {!Interpreter} intrp1 An interpreter initialised exactly as
* the one the ouptut JS will be executed by.
* @param {!Interpreter} intrp2 An interpreter containing state
* modifications (relative to intrp1) to be dumped.
* @param {!DumperOptions=} options Additional options.
*/
var Dumper = function(intrp1, intrp2, options) {
this.intrp1 = intrp1;
this.intrp2 = intrp2;
// Copy DEFAULT_OPTIONS then apply supplied options.
/** @type {!DumperOptions} */
this.options = {};
this.setOptions(DEFAULT_OPTIONS);
if (options) this.setOptions(options);
/** @const {!Map} */
this.scopeDumpers = new Map();
/** @const {!Map} */
this.objDumpers2 = new Map();
/**
* Map of Arguments objects to the ScopeDumpers for the scopes to
* which they belong.
* @const {!Map}
*/
this.argumentsScopeDumpers = new Map();
/**
* Which scope are we presently outputting code in the context of?
* @type {!Interpreter.Scope}
*/
this.scope = intrp2.global;
/** @type {!Interpreter.Owner} Perms at present point in output. */
this.perms = intrp2.ROOT;
/**
* Map from objects from intrp1 to corresponding objects in intrp2.
* @type {!Map}
*/
this.objs1to2 = new Map();
/**
* Current indentation.
* @type {string}
*/
this.indent = '';
this.diffBuiltins_();
// Create and initialise ScopeDumper for global scope.
/** @const !ScopeDumper */
this.global = this.getScopeDumper_(intrp2.global);
for (var v in intrp1.global.vars) {
var val1 = intrp1.global.get(v);
var val2 = intrp2.global.get(v);
var val1in2;
if (val1 instanceof intrp1.Object) {
if (!(val2 instanceof intrp2.Object)) {
throw new TypeError('Primitive / object mistmatch');
}
val1in2 = this.objs1to2.get(val1);
} else {
val1in2 = val1;
}
if (Object.is(val1in2, val2)) {
this.global.setDone(v, (typeof val2 === 'object') ? Do.DONE : Do.RECURSE);
if (val2 instanceof intrp2.Object) {
this.getObjectDumper_(val2)
.updateRef(this, new Components(this.global, v));
// Other initialialisation will be taken care of below.
}
}
}
// Survey objects accessible via global scope to find their outer scopes.
this.survey_();
};
/**
* Diff the values of buit-ins.
* @private
* @return {void}
*/
Dumper.prototype.diffBuiltins_ = function() {
// Initialise intrpObjs.
var builtins = this.intrp1.builtins.keys();
for (var i = 0; i < builtins.length; i++) {
var builtin = builtins[i];
var obj1 = this.intrp1.builtins.get(builtin);
var obj2 = this.intrp2.builtins.get(builtin);
if (!(obj2 instanceof this.intrp2.Object)) {
continue; // Skip primitive-valued builtins.
} else if (obj1 === undefined) {
throw new Error('Builtin not found in intrp1 Interpreter');
} else if (!(obj1 instanceof this.intrp1.Object)) {
throw new Error("Builtin wasn't an object originally");
}
// TODO(cpcallen): add check for inconsistent duplicate
// registrations - e.g., if parseInt and Number.parseInt were
// the same in intrp2 but different in intrp1.
this.objs1to2.set(obj1, obj2);
}
// Create and initialise ObjectDumpers for builtin objects.
for (var i = 0; i < builtins.length; i++) {
builtin = builtins[i];
obj2 = this.intrp2.builtins.get(builtin);
if (!(obj2 instanceof this.intrp2.Object)) continue; // Skip primitives.
var objDumper = this.getObjectDumper_(obj2);
obj1 = this.intrp1.builtins.get(builtin);
// Record pre-set prototype.
objDumper.proto =
(obj1.proto === null) ? null : this.objs1to2.get(obj1.proto);
if (obj2.proto === objDumper.proto) {
objDumper.setDone(Selector.PROTOTYPE,
(obj2.proto === null) ? Do.RECURSE : Do.DONE);
}
// Record pre-set owner.
var owner = /** @type{?Interpreter.Owner} */(
(obj1.owner === null) ? null : this.objs1to2.get(
/** @type{?Interpreter.prototype.Object} */(obj1.owner)));
if (obj2.owner === owner) {
objDumper.setDone(Selector.OWNER,
(obj2.owner === null) ? Do.RECURSE : Do.DONE);
}
// Record pre-set property values/attributes.
var keys = obj1.ownKeys(this.intrp1.ROOT);
for (var j = 0; j < keys.length; j++) {
var key = keys[j];
var pd1 = obj1.getOwnPropertyDescriptor(key, this.intrp1.ROOT);
var pd2 = obj2.getOwnPropertyDescriptor(key, this.intrp2.ROOT);
var attrs = {
writable: pd1.writable,
enumerable: pd1.enumerable,
configurable: pd1.configurable
};
objDumper.attributes[key] = attrs;
var value = pd1.value instanceof this.intrp2.Object ?
this.objs1to2.get(pd1.value) : pd1.value;
objDumper.checkProperty(key, value, attrs, pd2);
}
}
};
/**
* Dump everything that has not already been dumped so far. The
* generated source text is written to the current output buffer.
* Notably, this will also dump any listening sockets.
* @return {void}
*/
Dumper.prototype.dump = function() {
// Dump all remaining bindings.
this.global.dump(this);
// Dump listening Servers.
for (var key in this.intrp2.listeners_) {
var port = Number(key);
var server = this.intrp2.listeners_[port];
var args = [port, server.proto];
if (server.timeLimit) args.push(server.timeLimit);
this.write(this.exprForCall_('CC.connectionListen', args), ';');
}
};
/**
* Generate JS source text to declare and optionally initialise a
* particular binding (as specified by a Selector). The generated
* source text is written to the current output buffer.
*
* E.g., if foo = [42, 69, 105], then:
*
* myDumper.dumpBinding(new Selector('foo'), Do.DECL)
* // Writes: 'var foo;\n'
* myDumper.dumpBinding(new Selector('foo'), Do.SET)
* // Writes: 'foo = [];\n'
* myDumper.dumpBinding(new Selector('foo[0]'), Do.SET)
* // Writes: 'foo[0] = 42;\n'
* myDumper.dumpBinding(new Selector('foo'), Do.RECURSE)
* // Writs: 'foo[1] = 69;\nfoo[2] = 105;\n'
*
* This is mainly a wrapper around Object/ScopeDumper.p.dumpBinding
* and ObjectDumper.p.dump.
*
* @param {!Selector} selector The selector for the binding to be dumped.
* @param {!Do} todo How much to dump. Must be >= Do.DECL.
* @return {void}
*/
Dumper.prototype.dumpBinding = function(selector, todo) {
var c = this.getComponentsForSelector_(selector);
var done = c.dumper.dumpBinding(this, c.part, todo);
if (todo >= Do.RECURSE && done < Do.RECURSE) {
var value = c.dumper.getValue(this, c.part);
if (value instanceof this.intrp2.Object) {
var objDone = this.getObjectDumper_(value).dump(this, selector);
if (objDone === ObjectDumper.Done.DONE_RECURSIVELY) {
if (c.dumper.getDone(c.part) < Do.RECURSE) {
c.dumper.setDone(c.part, Do.RECURSE);
}
}
}
}
};
/**
* Get a source text representation of a given value. The source text
* will vary depending on the state of the dump; for instance, if the
* value is an object that has not yet apepared in the dump it will be
* represented by an expression creating the object - but if it has
* appeared before, then it will instead be represented by an
* expression referenceing the previously-constructed object.
*
* This method is mostly a wrapper around the other .exprFor_
* methods (but notably not .exprForBuiltin_ and .exprForCall_, which
* are wrappers around this method); see them for examples of expected
* output.
*
* @private
* @param {Interpreter.Value} value Arbitrary JS value from this.intrp2.
* @param {!Components=} ref Location in which value will be stored.
* @param {boolean=} callable Return the expression suitably
* parenthesised to be used as the callee of a CallExpression.
* @param {string=} funcName If supplied, and if value is an anonymous
* UserFuncion, then the returned expression is presumed to appear
* on the right hand side of an assignment statement such that the
* resulting Function object has its .name property automatically
* set to this value.
* @return {string} An eval-able representation of the value.
*/
Dumper.prototype.exprFor_ = function(value, ref, callable, funcName) {
var intrp2 = this.intrp2;
if (!(value instanceof intrp2.Object)) {
return this.exprForPrimitive_(value);
}
// Return existing reference to object (if already created).
var objDumper = this.getObjectDumper_(value);
var selector; // Existing selector for value, if any.
if (objDumper.proto !== undefined && objDumper.ref) {
selector = objDumper.getSelector();
}
if (ref) objDumper.updateRef(this, ref); // Safe new ref if specified.
if (selector) return this.exprForSelector_(selector);
// Object not yet referenced. Is it a builtin?
var key = intrp2.builtins.getKey(value);
if (key) {
var quoted = code.quote(key);
return callable ? '(new ' + quoted + ')' : 'new ' + quoted;
}
// Seems to be a new object. Check it really doesn't exist already
// and that it will be referenceable.
if (objDumper.proto !== undefined) {
throw new Error('object already exists but is not referenced');
} else if (!objDumper.ref) {
throw new Error('refusing to create non-referable object');
}
var expr;
if (value instanceof intrp2.Function) {
expr = this.exprForFunction_(value, objDumper, funcName);
} else if (value instanceof intrp2.Array) {
expr = this.exprForArray_(value, objDumper);
} else if (value instanceof intrp2.Date) {
expr = this.exprForDate_(value, objDumper);
} else if (value instanceof intrp2.RegExp) {
expr = this.exprForRegExp_(value, objDumper);
} else if (value instanceof intrp2.Error) {
expr = this.exprForError_(value, objDumper);
} else if (value instanceof intrp2.WeakMap) {
expr = this.exprForWeakMap_(value, objDumper);
} else {
expr = this.exprForObject_(value, objDumper);
}
// Do we need to set [[Prototype]]? Not if it's already correct.
if (value.proto === objDumper.proto) {
objDumper.setDone(Selector.PROTOTYPE,
(value.proto === null) ? Do.RECURSE : Do.DONE);
}
// Do we need to set [[Owner]]? Not if it's already correct.
if (value.owner === this.perms) {
objDumper.setDone(Selector.OWNER,
(value.owner === null) ? Do.RECURSE : Do.DONE);
}
return expr;
};
/**
* Get a source text representation of a given Array object. For the
* moment the return value is always '[]', but the specified arrDumper
* is modified to reflect what further work will need to be done to
* finsh dumping the array object.
* TODO(cpcallen): Return a more interesting array literal when possible.
* @private
* @param {!Interpreter.prototype.Array} arr Array object to be recreated.
* @param {!ObjectDumper} arrDumper ObjectDumper for arr.
* @return {string} An eval-able representation of arr.
*/
Dumper.prototype.exprForArray_ = function(arr, arrDumper) {
arrDumper.proto = this.intrp2.ARRAY;
var root = this.intrp2.ROOT;
var lastIndex = arr.get('length', root) - 1;
arrDumper.attributes['length'] =
{writable: true, enumerable: false, configurable: false};
if (lastIndex < 0 || arr.getOwnPropertyDescriptor(String(lastIndex), root)) {
// No need to set .length if it will be set via setting final index.
arrDumper.setDone('length', Do.RECURSE);
} else {
// Length exists; don't worry about it when preserving propery order.
arrDumper.setDone('length', Do.DECL);
}
return '[]';
};
/**
* Get a source text representation of a given builtin, for the
* purposes of calling it. Usually the return value will be a string
* like 'Object.defineProperty', but if the builtin in question hasn't
* yet been assigned to an object it will instead return a string like
* "(new 'Object.defineProperty')" to invoke the new hack to obtain
* it. This is a trivial wrapper around exprFor_ for a common use
* case.
* @private
* @param {string} builtin The name of the builtin.
* @return {string} An eval-able representation of obj.
*/
Dumper.prototype.exprForBuiltin_ = function(builtin) {
return this.exprFor_(this.intrp2.builtins.get(builtin), undefined, true);
};
/**
* Get a source text representation of a call to a given builtin
* function. The array of arguments can contain either
* Interpreter.Values or Selectors, which will be passed to .exprFor_
* and .exprForSelector_, respectively.
* @private
* @param {string} builtin The name of the builtin function to call.
* @param {!Array=} args Arguments to the call.
* @return {string} An eval-able representation of a builtin function call.
*/
Dumper.prototype.exprForCall_ = function(builtin, args) {
var dumper = this;
return this.exprForBuiltin_(builtin) + '(' +
Array.from(args || []).map(function (argument) {
if (argument instanceof Selector) {
return dumper.exprForSelector_(argument);
} else {
return dumper.exprFor_(argument);
}
}).join(', ') + ')';
};
/**
* Get a source text representation of a given Date object. The
* return value will usually be a string of the form "new
* Date('1975-07-27T23:59:59.000Z')" (but the new hack will be invoked
* if the Data constructor has not yet been initialised).
* @private
* @param {!Interpreter.prototype.Date} date Date object to be recreated.
* @param {!ObjectDumper} dateDumper ObjectDumper for date.
* @return {string} An eval-able representation of date.
*/
Dumper.prototype.exprForDate_ = function(date, dateDumper) {
dateDumper.proto = this.intrp2.DATE;
return 'new ' + this.exprForCall_('Date', [date.date.toISOString()]);
};
/**
* Get a source text representation of a given Error object. The
* return value will usually be a string of the form "new
* RangeError()" or "new TypeError('message')" (but the new hack will
* be invoked if the Data constructor has not yet been initialised).
* Only the built-in Error constructors will be used; for custom error
* stub-types errDumper will be left in a state that will ensure that
* {proto} is subsequently set appropriately.
* @private
* @param {!Interpreter.prototype.Error} err Error object to be recreated.
* @param {!ObjectDumper} errDumper ObjectDumper for err.
* @return {string} An eval-able representation of err.
*/
Dumper.prototype.exprForError_ = function(err, errDumper) {
errDumper.proto = err.proto;
var constructor;
if (err.proto === this.intrp2.EVAL_ERROR) {
constructor = 'EvalError';
} else if (err.proto === this.intrp2.RANGE_ERROR) {
constructor = 'RangeError';
} else if (err.proto === this.intrp2.REFERENCE_ERROR) {
constructor = 'ReferenceError';
} else if (err.proto === this.intrp2.SYNTAX_ERROR) {
constructor = 'SyntaxError';
} else if (err.proto === this.intrp2.TYPE_ERROR) {
constructor = 'TypeError';
} else if (err.proto === this.intrp2.URI_ERROR) {
constructor = 'URIError';
} else if (err.proto === this.intrp2.PERM_ERROR) {
constructor = 'PermissionError';
} else {
constructor = 'Error';
errDumper.proto = this.intrp2.ERROR;
}
// Try to set .message in the constructor call.
var message = err.getOwnPropertyDescriptor('message', this.intrp2.ROOT);
var args = [];
if (message && typeof message.value === 'string') {
args.push(message.value);
var attr = errDumper.attributes['message'] =
{writable: true, enumerable: false, configurable: true};
errDumper.checkProperty('message', message.value, attr , message);
}
// The .stack property is always created, and we always want to
// overwrite (or delete) it.
errDumper.attributes['stack'] =
{writable: true, enumerable: false, configurable: true};
var stack = err.getOwnPropertyDescriptor('stack', this.intrp2.ROOT);
if (stack) {
errDumper.setDone('stack', Do.DECL);
} else {
errDumper.scheduleDeletion('stack');
}
return 'new ' + this.exprForCall_(constructor, args);
};
/**
* Get a source text representation of a given Function object. The
* returned string is just this.obj.toString(), which will be a string
* of the form "function name(arg0, arg1, ...) { body; }", formatted
* with whitespace and line breaks as it was in the original source.
* Most of this method is therefore devoted to ensuring that
* funcDumper is modified to reflect what further work will need to be
* done to finsh dumping the function object.
* TODO(cpcallen): Dump FunctionDeclarations as such, rather than
* converting them into FunctionExpressions.
* @private
* @param {!Interpreter.prototype.Function} func Function object to be
* recreated.
* @param {!ObjectDumper} funcDumper ObjectDumper for func.
* @param {string=} funcName If supplied, and if value is an anonymous
* UserFunction, then the returned expression is presumed to appear
* on the right hand side of an assignment statement such that the
* resulting Function object has its .name property automatically
* set to this value if a name does not appear in the function body.
* @return {string} An eval-able representation of func.
*/
Dumper.prototype.exprForFunction_ = function(func, funcDumper, funcName) {
if (!(func instanceof this.intrp2.UserFunction)) {
throw Error('Unable to dump non-UserFunction');
}
// TODO(cpcallen): Should throw, rather than merely warn.
for (var scope = func.scope; scope !== this.scope; scope = scope.outerScope) {
var vars = Object.getOwnPropertyNames(scope.vars);
if (scope.type === Interpreter.Scope.Type.FUNEXP && scope === func.scope ||
vars.length === 0) {
continue;
}
this.warn(util.format('CLOSURE: type: %s, vars: %s',
scope.type, vars.join(', ')));
}
// Record stuff that gets done automatically by evaluating a
// function expression, like setting its __proto__ and .prototype.
funcDumper.proto = this.intrp2.FUNCTION; // TODO(ES6): generators, etc.?
// The .length property will be set implicitly (and is immutable).
funcDumper.attributes['length'] =
{writable: false, enumerable: false, configurable: false};
funcDumper.setDone('length', Do.RECURSE);
// The .name property is often set automatically.
// TODO(ES6): Handle prefix?
if (func.node['id']) {
funcName = func.node['id']['name'];
}
if (funcName) {
var attr = funcDumper.attributes['name'] =
{writable: false, enumerable: false, configurable: true};
var pd = func.getOwnPropertyDescriptor('name', this.intrp2.ROOT);
if (pd) {
funcDumper.checkProperty('name', funcName, attr, pd);
} else {
funcDumper.scheduleDeletion('name');
}
}
// The .prototype property will automatically be created, so we
// don't need to "declare" it. (Fortunately it's non-configurable,
// so we don't need to worry that it might need to be deleted.)
funcDumper.setDone('prototype', Do.DECL);
// Better still, we might be able to use the automatically-created
// .prototype object - if the current value is an ordinary Object
// and it isn't a built-in or already instantiated. (N.B.: we don't
// care about its {proto}; that can be modified later.)
attr = funcDumper.attributes['prototype'] =
{writable: true, enumerable: false, configurable: false};
pd = func.getOwnPropertyDescriptor('prototype', this.intrp2.ROOT);
var prototype = pd.value;
if (!this.intrp2.builtins.getKey(prototype) &&
prototype instanceof this.intrp2.Object &&
Object.getPrototypeOf(prototype) === this.intrp2.Object.prototype) {
var prototypeFuncDumper = this.getObjectDumper_(prototype);
if (prototypeFuncDumper.proto === undefined) {
// We can use automatic .prototype object.
// Mark .prototype as Do.SET or Do.ATTR as appropriate.
funcDumper.checkProperty('prototype', prototype, attr, pd);
// Mark prototype object as existing and referenceable.
prototypeFuncDumper.proto = this.intrp2.OBJECT;
prototypeFuncDumper
.updateRef(this, new Components(funcDumper, 'prototype'));
// Do we need to set .prototype's [[Prototype]]?
if (prototype.proto === prototypeFuncDumper.proto) {
prototypeFuncDumper.setDone(Selector.PROTOTYPE,
(prototype.proto === null) ? Do.RECURSE : Do.DONE);
}
// Do we need to set .prototype's [[Owner]]?
if (prototype.owner === this.perms) {
prototypeFuncDumper.setDone(Selector.OWNER,
(prototype.owner === null) ? Do.RECURSE : Do.DONE);
}
// It gets a .constructor property. Check to see if it will
// need to be overwritten.
attr = prototypeFuncDumper.attributes['constructor'] =
{writable: true, enumerable: false, configurable: true};
pd = prototype.getOwnPropertyDescriptor('constructor', this.intrp2.ROOT);
prototypeFuncDumper.checkProperty('constructor', func, attr, pd);
}
}
return func.toString();
};
/**
* Get a source text representation of a given Object. For now the
* return value will always be either the string '{}' or one of the
* form 'Object.create(prototype)' (and/or invoking the new hack if
* required).
* TODO(cpcallen): return a more interesting object literal when possible.
* @private
* @param {!Interpreter.prototype.Object} obj Object to be recreated.
* @param {!ObjectDumper} objDumper ObjectDumper for obj.
* @return {string} An eval-able representation of obj.
*/
Dumper.prototype.exprForObject_ = function(obj, objDumper) {
switch (obj.proto) {
case null:
objDumper.proto = null;
return this.exprForCall_('Object.create', [null]);
case this.intrp2.OBJECT:
objDumper.proto = this.intrp2.OBJECT;
return '{}';
default:
if (this.getObjectDumper_(obj.proto).proto !== undefined) {
// Record prototype connection.
objDumper.proto = obj.proto;
this.getObjectDumper_(obj.proto)
.updateRef(this, new Components(objDumper, Selector.PROTOTYPE));
return this.exprForCall_('Object.create', [obj.proto]);
} else {
// Can't set [[Prototype]] yet. Do it later.
objDumper.proto = this.intrp2.OBJECT;
return '{}';
}
}
};
/**
* Get a source text representation of a given primitive value (not
* including symbols). Correctly handles having Infinity, NaN and/or
* undefiend shadowed by binding in the current scope. In general
* this is just the obvious literal, but note:
*
* - Strings will be single- or double-quoted depending on which is
* more concise.
* - If Infinity, NaN or undefined is shadowed an alternative
* expression evaluating to the desired value will be returned
* instead. (N.B.: true, false and null are literals so cannot be
* shadowed.)
* @private
* @param {undefined|null|boolean|number|string} value Primitive JS value.
* @return {string} An eval-able representation of the value.
*/
Dumper.prototype.exprForPrimitive_ = function(value) {
switch (typeof value) {
case 'undefined':
if (this.isShadowed_('undefined')) return '(void 0)';
// FALL THROUGH
case 'boolean':
return String(value);
case 'number':
// All finite values (except -0) will convert back to exactly
// equal number, but Infinity and NaN could be shadowed. See
// https://stackoverflow.com/a/51218373/4969945
if (Object.is(value, -0)) {
return '-0';
} else if (Number.isFinite(value)) {
return String(value);
} else if (Number.isNaN(value)) {
if (this.isShadowed_('NaN')) {
return '(0/0)';
}
return 'NaN';
} else { // value is Infinity or -Infinity.
if (this.isShadowed_('Infinity')) {
return (value > 0) ? '(1/0)' : '(-1/0)';
}
return String(value);
}
case 'string':
return code.quote(value);
default:
if (value === null) {
return 'null';
} else {
throw TypeError('exprForPrimitive_ called on non-primitive value');
}
}
};
/**
* Get a source text representation of a given RegExp object. The
* returned value will be a string containing a regexp literal, like
* '/foobar/gi'.
* @private
* @param {!Interpreter.prototype.RegExp} re RegExp to be recreated.
* @param {!ObjectDumper} reDumper ObjectDumper for re.
* @return {string} An eval-able representation of re.
*/
Dumper.prototype.exprForRegExp_ = function(re, reDumper) {
reDumper.proto = this.intrp2.REGEXP;
// Some properties are implicitly pre-set.
var props = ['source', 'global', 'ignoreCase', 'multiline'];
for (var prop, i = 0; (prop = props[i]); i++) {
reDumper.attributes[prop] =
{writable: false, enumerable: false, configurable: false};
reDumper.setDone(prop, Do.RECURSE);
}
reDumper.attributes['lastIndex'] =
{writable: true, enumerable: false, configurable: false};
if (Object.is(re.get('lastIndex', this.intrp2.ROOT), 0)) {
// Can skip setting .lastIndex iff it is 0.
reDumper.setDone('lastIndex', Do.RECURSE);
} else {
reDumper.setDone('lastIndex', Do.DECL);
}
return re.regexp.toString();
};
/**
* Get a source text representation of a given selector. In general,
* given Selector s and Dumper d, d.exprForSelector_(s) will be the
* same as s.toExpr() except when the output needs to call a builtin
* function like Object.getPrototypeOf that is not available via its
* usual name - e.g. if Object.getPrototypeOf has not yet been dumped
* then the selector foo.bar{proto} might be represented as "(new
* 'Object.getPrototypeOf')(foo.bar)" instead of
* "Object.getPrototypeOf(foo.bar)".
* @private
* @param {Selector=} selector Selector to obtain value of.
* @return {string} An eval-able representation of the value.
*/
Dumper.prototype.exprForSelector_ = function(selector) {
var dumper = this;
return selector.toString(function(part, out) {
if (part === Selector.PROTOTYPE) {
out.unshift(dumper.exprForBuiltin_('Object.getPrototypeOf'), '(');
out.push(')');
} else if (part === Selector.OWNER) {
out.unshift(dumper.exprForBuiltin_('Object.getOwnerOf'), '(');
out.push(')');
} else {
throw new TypeError('Invalid part in parts array');
}
});
};
/**
* Get a source text representation of a given WeakMap object. The
* return value will usually be the string "new WeakMap()" (but the
* new hack will be invoked if the WeakMap constructor has not yet
* been initialised).
* @private
* @param {!Interpreter.prototype.WeakMap} weakMap WeakMap object to
* be recreated.
* @param {!ObjectDumper} weakMapDumper ObjectDumper for weakmap.
* @return {string} An eval-able representation of weakmap.
*/
Dumper.prototype.exprForWeakMap_ = function(weakMap, weakMapDumper) {
weakMapDumper.proto = this.intrp2.WEAKMAP;
return 'new ' + this.exprForCall_('WeakMap');
};
/**
* Given a Selector and optionally a Scope, get the corresponding
* Components.
* @private
* @param {!Selector} selector A selector for the binding in question.
* @param {!Interpreter.Scope=} scope Scope which selector is relative to.
* Defaults to current scope.
* @return {!Components} The dumper and part corresponding to selector.
*/
Dumper.prototype.getComponentsForSelector_ = function(selector, scope) {
if (!scope) scope = this.scope;
if (selector.length < 1) throw new RangeError('Zero-length selector??');
var /** !SubDumper */ dumper = this.getScopeDumper_(scope);
var /** Interpreter.Value */ v;
for (var i = 0; i < selector.length - 1; i++) {
v = dumper.getValue(this, selector[i]);
if (!(v instanceof this.intrp2.Object)) {
var s = new Selector(selector.slice(0, i + 1));
throw TypeError("Can't select part of primitive " + s + ' === ' + v);
}
dumper = this.getObjectDumper_(v);
}
return new Components(dumper, selector[selector.length - 1]);
};
/**
* Given a Selector or selector string and optionally a Scope, get the
* SubDumper for the value object identified. This is intended to be
* used only for testing.
* @param {!Selector|string} selector A Selector or selector string
* referring to an object.
* @param {!Interpreter.Scope=} scope Scope which ss is relative to.
* Defaults to current scope.
* @return {!ObjectDumper} The ObjectDumper for the referred-to object.
*/
Dumper.prototype.getDumperFor = function(selector, scope) {
if (typeof selector === 'string') selector = new Selector(selector);
if (!scope) scope = this.scope;
var /** !SubDumper */ dumper = this.getScopeDumper_(scope);
var /** Interpreter.Value */ v;
for (var i = 0; i < selector.length; i++) {
v = dumper.getValue(this, selector[i]);
if (!(v instanceof this.intrp2.Object)) {
var s = new Selector(selector.slice(0, i + 1));
throw TypeError("Can't select part of primitive " + s + ' === ' + v);
}
dumper = this.getObjectDumper_(v);
}
if (!(dumper instanceof ObjectDumper)) throw new TypeError('corrupt state');
return dumper;
};
/**
* Get interned ObjectDumper for sope.
* @private
* @param {!Interpreter.prototype.Object} obj The object to get the dumper for.
* @return {!ObjectDumper} The ObjectDumper for obj.
*/
Dumper.prototype.getObjectDumper_ = function(obj) {
if (this.objDumpers2.has(obj)) return this.objDumpers2.get(obj);
var objDumper = new ObjectDumper(obj);
this.objDumpers2.set(obj, objDumper);
return objDumper;
};
/**
* Get interned ScopeDumper for sope.
* @private
* @param {!Interpreter.Scope} scope The scope to get info for.
* @return {!ScopeDumper} The ScopeDumper for scope.
*/
Dumper.prototype.getScopeDumper_ = function(scope) {
if (this.scopeDumpers.has(scope)) return this.scopeDumpers.get(scope);
var scopeDumper = new ScopeDumper(scope);
this.scopeDumpers.set(scope, scopeDumper);
return scopeDumper;
};
/**
* Returns true if a given name is shadowed in the current scope.
* TODO(cpcallen): Use .reachable on the global Scope's ScopeDumper.
* @private
* @param {string} name Variable name that might be shadowed.
* @param {!Interpreter.Scope=} scope Scope in which name is defined.
* Defaults to the global scope.
* @return {boolean} True iff name is bound in a scope between the
* current scope (this.scope) (inclusive) and scope (exclusive).
*/
Dumper.prototype.isShadowed_ = function(name, scope) {
if (!scope) scope = this.intrp2.global;
for (var s = this.scope; s !== scope; s = s.outerScope) {
if (s === null) {
throw Error("Looking for name '" + name + "' from non-enclosing scope??");
}
if (s.hasBinding(name)) return true;
}
return false;
};
/**
* Mark a particular binding (as specified by a Selector) with a
* certain done value.
* @private
* @param {!Selector} selector The selector for the binding to be deferred.
* @param {!Do} done Do status to mark binding with.
*/
Dumper.prototype.markBinding_ = function(selector, done) {
var c = this.getComponentsForSelector_(selector);
var was = c.dumper.getDone(c.part);
if (was !== done) c.dumper.setDone(c.part, done);
};
/**
* Mark a particular binding (as specified by a Selector) to pruned,
* which will have the effect of trying to ensure it does not exist in
* the state reconstructed by the dump output.
* TODO(cpcallen): actually delete pruned properties if necessary.
* @param {!Selector} selector The selector for the binding to be pruned.
*/
Dumper.prototype.prune = function(selector) {
var c = this.getComponentsForSelector_(selector);
c.dumper.prune(c.part);
};
/**
* Set the .prune flag on the ObjectDumper for the object identified
* by the given Selector to true.
* TODO(cpcallen): actually delete pruned properties if necessary.
* @param {!Selector} selector The selector for the binding to be pruned.
*/
Dumper.prototype.pruneRest = function(selector) {
selector = new Selector(selector.concat([''])); // N.B. ugly hack!
var c = this.getComponentsForSelector_(selector);
if (!(c.dumper instanceof ObjectDumper)) throw new TypeError();
c.dumper.pruneRest = true;
};
/**
* Set options for this dumper. Can be called to change options
* between calls to .dumpbBinding. Will update existing settings with
* new values, so only changed options need to be supplied.
* @param {!DumperOptions} options The new options to apply.
* @return {void}
*/
Dumper.prototype.setOptions = function(options) {
for (var key in DEFAULT_OPTIONS) {
if (key in options) this.options[key] = options[key];
}
};
/**
* Mark a particular binding (as specified by a Selector) to be
* skipped, which will have the effect of preventing any further
* dumping of it until it is unskipped.
* @param {!Selector} selector The selector for the binding to be skipped.
*/
Dumper.prototype.skip = function(selector) {
var c = this.getComponentsForSelector_(selector);
c.dumper.skip(c.part);
};
/**
* Survey the global Scope and recursively everything accessible via
* its bindings, to prepare for dumping.
*
* This is done useing Dijkstra's Algorithm to create a least-cost
* spanning tree starting from the global scope, with distance
* measured by Selector badness.
*
* @private
* @return {void}
*/
Dumper.prototype.survey_ = function() {
var /** !Set */ visited = new Set();
var /** !PriorityQueue */ queue = new PriorityQueue();
// TODO(cpcallen): Remove badness; this info is already stored in queue.
var /** !Map */ badness = new Map();
// Start building spanning tree from the global scope.
var globalScopeDumper = this.getScopeDumper_(this.intrp2.global);
var /* @const */ globalBadness = 0;
badness.set(globalScopeDumper, globalBadness);
queue.insert(globalScopeDumper, globalBadness);
while (queue.length) {
var /** !SubDumper */ dumper = queue.deleteMin();
if (visited.has(dumper)) throw new Error('surveying same dumper twice??');
visited.add(dumper);
var baseBadness = badness.get(dumper);
badness.delete(dumper);
var /** !Array */ adjacent = dumper.survey(this);
for (var j = 0; j < adjacent.length; j++) {
var edge = adjacent[j];
if (edge instanceof ScopeDumper) {
if (visited.has(edge)) continue;
badness.set(edge, Infinity);
queue.set(edge, Infinity);
}
if (!(edge.value instanceof this.intrp2.Object)) continue;
var objectDumper = this.getObjectDumper_(edge.value);
if (visited.has(objectDumper)) continue;
var newBadness = baseBadness + Selector.partBadness(edge.part);
// If we've not seen objectDumper before, .get will return
// undefined and the following test will return false.
// (Undefined is effectivly a 'bigger infinity' here!)
if (newBadness >= badness.get(objectDumper)) continue;
objectDumper.preferredRef = new Components(dumper, edge.part);
badness.set(objectDumper, newBadness);
queue.set(objectDumper, newBadness);
}
}
};
/**
* Mark a particular binding (as specified by a Selector) as no longer
* to be skipped.
* @param {!Selector} selector The selector for the binding to be skipped.
*/
Dumper.prototype.unskip = function(selector) {
var c = this.getComponentsForSelector_(selector);
c.dumper.unskip(c.part);
};
/**
* Log a warning about something suspicious that happened while
* dumping. By default this prints to the console and .write()s a
* comment to the file being output, but it can be overridden on
* individual instances.
* @param {string} warning Warning to output or log.
*/
Dumper.prototype.warn = function(warning) {
if (this.options.verbose) console.log(warning);
warning = warning.replace(/^(?!$)/gm, this.indent + '// ')
.slice(this.indent.length); // Remove indent from first line.
this.write(warning);
};
/**
* Write strings to current output file. (May be buffered.) The
* arguments will be concatenated into a single string, which will be
* pefixed with the current indentation and have a trailing newline
* added if necessary. No indentation will be added to the second and
* subsequent lines of a multi-line write, however, to preserve
* indentation in function bodies / multi-line string literals / etc.
* @param {...string} var_args Strings to output.
*/
Dumper.prototype.write = function(var_args) {
if (this.options.output) {
var line = this.indent + Array.prototype.join.call(arguments, '');
if (!line.endsWith('\n')) line += '\n';
this.options.output.write(line);
}
};
///////////////////////////////////////////////////////////////////////////////
// SubDumper
/**
* Common interface and functionality for ScopeDumper and ObjectDumper.
* @abstract @constructor
* @struct
*/
var SubDumper = function() {
/** @type {?Set} */
this.skip_ = null;
/** @type {?Set} */
this.prune_ = null;
};
/**
* Generate JS source text to create and/or initialize a single
* binding (varialbe in a scope, or property / internal slot of an
* object).
* @abstract
* @param {!Dumper} dumper Dumper to which this ScopeDumper belongs.
* @param {Selector.Part} part The part to dump. Must be simple string.
* @param {!Do} todo How much to do. Must be >= Do.DECL; > Do.SET ignored.
* @return {!Do} How much has been done on the specified binding.
*/
SubDumper.prototype.dumpBinding = function(dumper, part, todo) {};
/**
* Return the current 'done' status of a binding.
* @abstract
* @param {Selector.Part} part The part to get status for.
* @return {!Do} The done status of the binding.
*/
SubDumper.prototype.getDone = function(part) {};
/**
* Return the value of the given part in intrp2 (i.e., the intended
* final value, provided that it isn't going to be pruned.)
* @abstract
* @param {!Dumper} dumper Dumper to which this SubDumper belongs.
* @param {Selector.Part} part The binding part to get the value of.
* @return {Interpreter.Value} The value of that part.
*/
SubDumper.prototype.getValue = function(dumper, part) {};
/**
* Update the current 'done' status of a binding. Will throw a
* RangeError if caller attempts to un-do or re-do a previously-done
* action.
* @param {Selector.Part} part The part to set status for.
* @param {!Do} done The new done status of the binding.
*/
SubDumper.prototype.setDone = function(part, done) {};
/**
* Mark a particular binding (as specified by a Part) to be pruned,
* which will have the effect of trying to ensure it does not exist in
* the state reconstructed by the dump output.
* TODO(cpcallen): actually delete pruned properties if necessary.
* @param {Selector.Part} part The binding to be pruned.
*/
SubDumper.prototype.prune = function(part) {
if (!this.prune_) this.prune_ = new Set();
this.prune_.add(part);
};
/**
* Return true the specified part is presently reachable - i.e., could
* be set or read by an expression in the currently-dumped scope.
* @abstract
* @param {!Dumper} dumper Dumper to which this SubDumper belongs.
* @param {Selector.Part=} part The binding whose reachability is of
* interest. Ignored, since all object bindings are always
* reachable if the object is.
* @return {boolean}
*/
SubDumper.prototype.reachable = function(dumper, part) {};
/**
* Mark a particular binding (as specified by a Part) to be skipped,
* which will have the effect of preventing any further dumping of it
* until it is unskipped.
* @param {Selector.Part} part The binding to be skipped.
*/
SubDumper.prototype.skip = function(part) {
if (!this.skip_) this.skip_ = new Set();
this.skip_.add(part);
};
/**
* Survey the scope or object associated with this SubDumper in
* preparation for dumping.
*
* Returns a list of OutwardEdges representing outward edges
* from this node of the object graph.: the properties (and internal
* slots) of this object. Exceptionally, because Scopes are not
* Interpreter Objects (and there is no Selector.Part corresponding to
* the enclosing scope slot of a UserFunction object), the
* ObjectDumper for a UserFunction will also include a bare
* ScopeDumper in its returned array.
*
* @abstract
* @param {!Dumper} dumper Dumper to which this ScopeDumper belongs.
* @return {!Array}
*/
SubDumper.prototype.survey = function(dumper) {};
/**
* Mark a particular binding (as specified by a Selector) as no longer
* to be skipped.
* @param {Selector.Part} part The binding to be unskipped.
*/
SubDumper.prototype.unskip = function(part) {
if (!this.skip_) return;
this.skip_.delete(part);
if (this.skip_.size === 0) this.skip_ = null;
};
///////////////////////////////////////////////////////////////////////////////
// ScopeDumper
/**
* ScopeDumper encapsulates all machinery to dump an Interpreter.Scope
* to eval-able JS, including maintaining all the dump-state info
* required to keep track of what variable bindings have and haven't
* yet been dumped.
* @constructor @extends {SubDumper}
* @struct
* @param {!Interpreter.Scope} scope The scope to keep state for.
*/
var ScopeDumper = function(scope) {
SubDumper.call(this);
this.scope = scope;
/** @private @const {!Object} Done status of each variable. */
this.doneVar_ = Object.create(null);
/** @const {!Set} Set of inner scopes. */
this.innerScopes = new Set();
/** @const {!Set} Set of inner functions. */
this.innerFunctions = new Set();
};
Object.setPrototypeOf(ScopeDumper, SubDumper);
Object.setPrototypeOf(ScopeDumper.prototype, SubDumper.prototype);
/**
* Generate JS source text to create and/or initialize a single
* variable binding.
* @param {!Dumper} dumper Dumper to which this ScopeDumper belongs.
* @return {void}
*/
ScopeDumper.prototype.dump = function(dumper) {
if (dumper.scope !== this.scope) {
throw new Error("Can't dump scope other than current scope");
}
// Dump variable bindings.
for (var name in this.scope.vars) {
if (this.getDone(name) >= Do.RECURSE) continue; // Skip already-done.
// Dump binding itself.
var done = this.dumpBinding(dumper, name, Do.RECURSE);
// Attempt to recursively dump the value object, if there is one.
if (done >= Do.RECURSE) continue;
var value = this.getValue(dumper, name);
if (!(value instanceof dumper.intrp2.Object)) continue;
var valueDumper = dumper.getObjectDumper_(value);
var objDone = valueDumper.dump(dumper, new Selector(name));
if (objDone === ObjectDumper.Done.DONE_RECURSIVELY) {
this.setDone(name, Do.RECURSE);
}
}
};
/**
* Generate JS source text to create and/or initialize a single
* variable binding.
* @param {!Dumper} dumper Dumper to which this ScopeDumper belongs.
* @param {Selector.Part} part The part to dump. Must be simple string.
* @param {!Do} todo How much to do. Must be >= Do.DECL; > Do.SET ignored.
* @return {!Do} How much has been done on the specified binding.
*/
ScopeDumper.prototype.dumpBinding = function(dumper, part, todo) {
if (dumper.scope !== this.scope) {
throw new Error("Can't create binding other than in current scope");
} else if (typeof part !== 'string') {
throw new TypeError('Invalid part (not a variable name)');
} else if (!this.scope.hasBinding(part)) {
throw new ReferenceError("Can't dump non-existent variable " + part);
} else if (this.prune_ && this.prune_.has(part)) {
return Do.RECURSE; // Don't dump this binding at all.
} else if (this.skip_ && this.skip_.has(part)) {
return this.getDone(part); // Do nothing but don't lie about it.
}
var done = this.getDone(part);
var output = [];
if (todo < Do.DECL || done >= todo || done > Do.SET) return done;
if (done < Do.DECL) {
output.push('var ');
done = Do.DECL;
}
if (done < Do.SET) {
output.push(part);
if (todo >= Do.SET) {
var ref = new Components(this, part);
var value = this.scope.get(part);
output.push(' = ', dumper.exprFor_(value, ref, false, part));
done = (value instanceof dumper.intrp2.Object) ? Do.DONE : Do.RECURSE;
}
output.push(';');
}
this.setDone(part, done);
dumper.write.apply(dumper, output);
return done;
};
/**
* Return the current 'done' status of a variable binding.
* @param {Selector.Part} part The part get status for. Must be simple string.
* @return {!Do} The done status of the binding.
*/
ScopeDumper.prototype.getDone = function(part) {
if (typeof part !== 'string') {
throw new TypeError('Invalid part (not a variable name)');
}
var done = this.doneVar_[part];
return done === undefined ? Do.UNSTARTED : done;
};
/**
* Update the current 'done' status of a variable binding. Will throw
* a RangeError if caller attempts to un-do a previously-done action.
* @param {Selector.Part} part The part set status for. Must be simple string.
* @param {!Do} done The new done status of the binding.
*/
ScopeDumper.prototype.setDone = function(part, done) {
if (typeof part !== 'string') {
throw new TypeError('Invalid part (not a variable name)');
}
var old = this.getDone(part);
// Invariant checks.
if (done <= old) {
var fault = (done === old) ? 'Refusing redundant' : "Can't undo previous";
throw new RangeError(fault + ' work on variable ' + part);
}
this.doneVar_[part] = done;
};
/**
* Return the value of the given variable in this.scope (i.e., the
* value in intrp2, and the intended final value - provided that it
* isn't going to be pruned.)
* @param {!Dumper} dumper Dumper to which this ScopeDumper belongs.
* @param {Selector.Part} part The binding part to get the value of.
* @return {Interpreter.Value} The value of that part.
*/
ScopeDumper.prototype.getValue = function(dumper, part) {
if (typeof part !== 'string') throw new TypeError('Invalid first part??');
if (!this.scope.hasBinding(part)) {
throw new ReferenceError(part + ' is not defined');
}
return this.scope.get(part);
};
/**
* Return true iff the given binding (which must be a variable name)
* is currently reachable. Specifically, this will return true if:
*
* 1. this.scope is the current value dumper.scope, since we can
* always access existing bindings and create new ones in the
* current scope.
* 2. this.scope is an outer scope of dumper.scope and par
* is not shadowed in dumper.scope or any intervening one.
*
* BUG(cpcallen): Only #1 is implemented at the moment.
*
* @param {!Dumper} dumper Dumper to which this ScopeDumper belongs.
* @param {Selector.Part=} part Variable name whose reachability is of
* interest.
* @return {boolean}
*/
ScopeDumper.prototype.reachable = function(dumper, part) {
return this.scope === dumper.scope;
};
/**
* Visit a Scope to prepare for dumping. In particular:
*
* - If this.scope.outerScope is set, record this as one of it's inner
* scopes, so that when we go to dump that scope later we know we
* need to dump this one inside it.
*
* - Find any Arguments object attached to this scope and record the
* relationship in the dumper.argumentsScopeDumpers map.
*
* - Collect and return an array of {part, value} tuples, where each
* represents a variable in this scope.
*
* @param {!Dumper} dumper Dumper to which this ScopeDumper belongs.
* @return {!Array}
*/
ScopeDumper.prototype.survey = function(dumper) {
var /** !Array */ adjacent = [];
// Record parent scope.
if (this.scope !== dumper.intrp2.global) {
if (this.scope.outerScope === null) {
throw new TypeError('Non-global scope has null outer scope');
}
var outerScopeDumper = dumper.getScopeDumper_(this.scope.outerScope);
// Record this as inner scope of this.outerScope.
outerScopeDumper.innerScopes.add(this);
// Don't forget to survey the outerScope, too:
adjacent.push(outerScopeDumper);
}
// Record arguments object attached to this scope if it's a function scope.
if (this.scope.type === Interpreter.Scope.Type.FUNCTION &&
this.scope.hasImmutableBinding('arguments')) {
var argsObject = this.scope.get('arguments');
if (!(argsObject instanceof dumper.intrp2.Arguments)) {
// BUG(cpcallen): what about function(arguments) {...}?
throw new TypeError('arguments not an Arguments object');
} else if (dumper.argumentsScopeDumpers.has(argsObject)) {
// BUG(cpcallen): what about (function(arguments) {...})(
// (function() {return arguments;})()); ?
throw new Error('Arguments object belongs to more than one scope');
}
dumper.argumentsScopeDumpers.set(argsObject, this);
}
// Collect Components for other objects reachable from this one.
for (var name in this.scope.vars) {
adjacent.push({part: name, value: this.scope.get(name)});
}
return adjacent;
};
///////////////////////////////////////////////////////////////////////////////
// ObjectDumper
/**
* ObjectDumper encapsulates all machinery to dump an
* Interpreter.prototype.Object to eval-able JS, including maintaining
* all the dump-state info required to keep track of what properties
* (etc.) have and haven't yet been dumped.
* @constructor @extends {SubDumper}
* @struct
* @param {!Interpreter.prototype.Object} obj The object to keep state for.
*/
var ObjectDumper = function(obj) {
SubDumper.call(this);
/** @type {!Interpreter.prototype.Object} */
this.obj = obj;
/**
* Preferred reference to this object. E.g., for Object.prototype
* this would be {dumper: , part: 'prototype'}.
* @type {?Components}
*/
this.preferredRef = null;
/**
* A valid-at-this-point-in-the-dump referrence to this object.
* @type {?Components} Reference to this object, once created.
*/
this.ref = null;
/**
* If true, then .dump() will not dump any ordinary (property /
* member / entry) bindings. This means that only bindings dumped
* by calls to .dumpBinding() will be dumped. (Prototype and owner
* bindings will still be dumped unless they are individually
* .prune()ed.)
* @type {boolean}
*/
this.pruneRest = false;
/** @type {!ObjectDumper.Done} How much has object been dumped? */
this.done = ObjectDumper.Done.NO;
/** @private @type {!Do} Has prototype been set? */
this.doneProto_ = Do.DECL; // Never need to 'declare' the [[Prototype]] slot!
/**
* Current value of [[Prototype]] slot of obj at this point in dump.
* Typically initially Object.prototype (or similar); will be ===
* obj.proto when complete. Used to check for unwritable inherited
* properties when attempting to set properties by assignment.
* Should only be undefined if object has not yet been created.
* @type {?Interpreter.prototype.Object|undefined}
*/
this.proto = undefined;
/** @private @type {!Do} Has owner been set? */
this.doneOwner_ = Do.DECL; // Never need to 'declare' that object has owner!
/** @private @const {!Object} Done status of each property. */
this.doneProp_ = Object.create(null);
/**
* Map of property name -> property descriptor, where property
* descriptor is a map of attribute names (writable, enumerable,
* configurable, more tbd) to boolean values describing the present
* attributes of the property at the current point in the dump; this
* is updated as code that modifies them is generated. (We do not
* store values here.)
* @type {!Object>}
*/
this.attributes = Object.create(null);
/** @type {?Array} Properties to delete. */
this.toDelete = null;
};
Object.setPrototypeOf(ObjectDumper, SubDumper);
Object.setPrototypeOf(ObjectDumper.prototype, SubDumper.prototype);
/**
* Updates done state of property binding after defining/assigning a
* property. This computes the new done value, calls .setDone(key,
* done) and returns the new value.
* @param {string} key The property key just updated.
* @param {Interpreter.Value} value The value just assigned to the property.
* @param {!Object} attr The property's current attributes.
* @param {!Interpreter.Descriptor|undefined} pd Property descriptor
* returned by calling this.obj.getOwnPropertyDescriptor(key, ...).
* @return {!Do} New done state.
*/
ObjectDumper.prototype.checkProperty = function(key, value, attr, pd) {
var done;
if (!Object.is(value, pd.value)) {
done = Do.DECL;
} else if (attr.writable === pd.writable &&
attr.enumerable === pd.enumerable &&
attr.configurable === pd.configurable) {
done = (typeof value === 'object') ? Do.ATTR : Do.RECURSE;
} else {
done = Do.SET;
}
this.setDone(key, done);
return done;
};
/**
* Recursively dumps all bindings of the object (and objects reachable
* via it).
* @param {!Dumper} dumper Dumper to which this ObjectDumper belongs.
* @param {!Selector=} objSelector Selector refering to this object.
* Optional; defaults to whatever selector was used to create the
* object.
* @param {!Array<(!SubDumper)>=} visiting List of Scope/Object dumpers
* currently being recursively dumped. Used only when
* recursing.
* @param {!Set<(!SubDumper)>=} visited Set of Scope/Object dumpers
* currently that have already been visited. Used only when
* recursing.
* @return {!ObjectDumper.Done|?ObjectDumper.Pending} Done status for
* object, or or null if there is an outstanding dump or
* dumpBinding invocaion for this object, or a (bindings,
* dependencies) pair if a recursive call encountered such an
* outstanding invocation.
*/
ObjectDumper.prototype.dump = function(
dumper, objSelector, visiting, visited) {
if (!visiting) visiting = [];
if (!visited) visited = new Set();
if (!objSelector) objSelector = this.getSelector();
if (!objSelector) throw new Error("can't dump unreferencable object");
if (this.proto === undefined) {
throw new Error("can't dump uncreated object " + this.getSelector(true));
}
if (visited.has(this)) return null;
if (this.done === ObjectDumper.Done.DONE_RECURSIVELY) return this.done;
visiting.push(this);
visited.add(this);
// Delete properties that shouldn't exist.
if (this.toDelete) {
var sel = new Selector(objSelector);
for (var key, i = 0; (key = this.toDelete[i]); i++) {
sel.push(key);
dumper.write('delete ', dumper.exprForSelector_(sel), ';');
sel.pop();
}
this.toDelete = null;
}
// Dump bindings: prototype, owner, and properties.
// TODO(cpcallen): Also dump set/map entries, etc.
// Optimistically assume success until we find otherwise.
var /** !ObjectDumper.Done */ done = ObjectDumper.Done.DONE_RECURSIVELY;
var /** ?ObjectDumper.Pending */ pending = null;
var keys = this.obj.ownKeys(dumper.intrp2.ROOT);
var parts = [Selector.PROTOTYPE, Selector.OWNER];
if (!this.pruneRest) parts = parts.concat(keys);
for (i = 0; i < parts.length; i++) {
var part = parts[i];
if (this.prune_ && this.prune_.has(part)) {
// TODO(cpcallen): delete binding if necessary.
continue;
} else if (this.skip_ && this.skip_.has(part) ||
dumper.options.skipBindings.includes(part)) {
// Can't finish an object with skipped parts.
done = /** @type {!ObjectDumper.Done} */(
Math.min(done, ObjectDumper.Done.NO));
continue;
}
// Attempt to dump the binding itself.
var bindingSelector = new Selector(objSelector.concat(part));
var bindingDone =
this.dumpBinding(dumper, part, Do.DONE, objSelector, bindingSelector);
if (bindingDone === Do.RECURSE) { // Nothing more to do for part.
continue;
} else if (bindingDone < Do.DONE) { // Object can't be done.
done = /** @type {!ObjectDumper.Done} */(
Math.min(done, ObjectDumper.Done.NO));
}
if (bindingDone < Do.SET) continue; // Can't recurse if no object yet!
// Attempt to recursively dump the value object, if there is one.
var value = this.getValue(dumper, part);
if (!(value instanceof dumper.intrp2.Object)) continue;
var valueDumper = dumper.getObjectDumper_(value);
if (dumper.options.treeOnly &&
(this !== valueDumper.preferredRef.dumper ||
part !== valueDumper.preferredRef.part)) {
// Refuse to recurse into objects outside of the spanning tree.
done = /** @type {!ObjectDumper.Done} */(
Math.min(done, ObjectDumper.Done.DONE));
continue;
}
valueDumper.updateRef(dumper, new Components(this, part));
var objDone =
valueDumper.dump(dumper, bindingSelector, visiting, visited);
if (objDone === null || objDone instanceof ObjectDumper.Pending) {
// Circular structure detected.
if (!pending) {
pending = new ObjectDumper.Pending(bindingSelector, valueDumper);
} else {
pending.add(bindingSelector, valueDumper);
}
if (objDone instanceof ObjectDumper.Pending) {
// Circular dependency detected amongst objects being recursively
// dumped. Record details of circularity. Add this binding.
pending.merge(objDone);
}
} else if (objDone === ObjectDumper.Done.DONE_RECURSIVELY) {
// Successful recursive dump. Upgrade binding accordingly.
this.setDone(part, Do.RECURSE);
}
}
if (this.done < ObjectDumper.Done.DONE && done >= ObjectDumper.Done.DONE) {
// Dump extensibility.
if (!this.obj.isExtensible(dumper.intrp2.ROOT)) {
dumper.write(
dumper.exprForCall_('Object.preventExtensions', [objSelector]),
';');
}
this.done = ObjectDumper.Done.DONE; // Set now to allow cycles to complete.
}
visiting.pop();
// If all parts of circular dependency are DONE, mark all as
// RECURSE / DONE_RECURSIVELY.
// TODO(cpcallen): Clean up this code.
if (done) {
if (pending) {
if (pending.dependencies.some(
function(dep) {return !dep.done || visiting.includes(dep);})) {
done = /** @type {!ObjectDumper.Done} */(
Math.min(done, ObjectDumper.Done.DONE));
} else {
var /** !Selector */ binding;
for (i = 0; (binding = pending.bindings[i]); i++) {
dumper.markBinding_(binding, Do.RECURSE);
}
for (var dep, i = 0; (dep = pending.dependencies[i]); i++) {
dep.done = ObjectDumper.Done.DONE_RECURSIVELY;
}
pending = null;
}
}
}
this.done = done;
return pending || done;
};
/**
* Generate JS source text to create and/or initialize a single
* binding (property or internal slot) of the object.
* @param {!Dumper} dumper Dumper to which this ObjectDumper belongs.
* @param {Selector.Part} part The binding part to dump.
* @param {!Do} todo How much to do. Must be >= Do.DECL; > Do.ATTR ignored.
* @param {!Selector=} objSelector Selector refering to this object.
* Optional; will be created using getSelector if not supplied.
* @param {!Selector=} bindingSelector Selector refering to part.
* Optional; will be created by appending part to objSelector.
* @return {!Do} The done status of the specified binding.
*/
ObjectDumper.prototype.dumpBinding = function(
dumper, part, todo, objSelector, bindingSelector) {
if (!objSelector) objSelector = this.getSelector();
if (!objSelector) {
throw new Error("can't dump unreferencable object");
} else if (this.proto === undefined) {
throw new Error("can't dump uncreated object " + this.getSelector(true));
} else if (this.prune_ && this.prune_.has(part)) {
return Do.RECURSE; // Don't dump requested binding at all.
} else if (this.skip_ && this.skip_.has(part)) {
return this.getDone(part); // Do nothing but don't lie about it.
}
if (!bindingSelector) {
bindingSelector = new Selector(objSelector.concat(part));
}
var partRef = new Components(this, part);
if (part === Selector.PROTOTYPE) {
return this.dumpPrototype_(dumper, todo, partRef,
objSelector, bindingSelector);
} else if (part === Selector.OWNER) {
return this.dumpOwner_(dumper, todo, partRef,
objSelector, bindingSelector);
} else if (typeof part === 'string') {
return this.dumpProperty_(dumper, part, todo, partRef,
objSelector, bindingSelector);
} else {
throw new Error('Invalid part');
}
};
/**
* Generate JS source text to set the object's [[Owner]].
* @private
* @param {!Dumper} dumper Dumper to which this ObjectDumper belongs.
* @param {!Do} todo How much to do. Must be >= Do.DECL; > Do.SET ignored.
* @param {!Components} partRef A reference to this object's [[Owner]] slot.
* @param {!Selector} objSelector Selector refering to this object.
* @param {!Selector} bindingSelector Selector refering to this
* object's [[Owner]] slot.
* @return {!Do} The done status of the object's [[Owner]] slot.
*/
ObjectDumper.prototype.dumpOwner_ = function(
dumper, todo, partRef, objSelector,bindingSelector) {
var value = /** @type {?Interpreter.prototype.Object} */(this.obj.owner);
if (todo >= Do.SET && this.doneOwner_ < Do.SET) {
// Record owner connection.
if (value !== null) {
dumper.getObjectDumper_(value)
.updateRef(dumper, new Components(this, Selector.OWNER));
}
dumper.write(
dumper.exprForCall_('Object.setOwnerOf', [objSelector, value]),
';');
this.doneOwner_ = (value === null) ? Do.RECURSE: Do.DONE;
}
return this.doneOwner_;
};
/**
* Generate JS source text to create and/or initialize a single
* property of the object. The output will consist of:
*
* - An assignment statement to create the property and/or set its
* value, if necessary and possible.
* - A call to Object.defineProperty, to set the property's attributes
* (and value, if the value couldn't be set by assignement), if
* necessary.
* @private
* @param {!Dumper} dumper Dumper to which this ObjectDumper belongs.
* @param {string} key The property to dump.
* @param {!Do} todo How much to do.
* @param {!Components} partRef A reference to this object's property [key].
* @param {!Selector} objSelector Selector refering to this object.
* @param {!Selector} bindingSelector Selector refering to key.
* @return {!Do} The done status of the specified property.
*/
ObjectDumper.prototype.dumpProperty_ = function(
dumper, key, todo, partRef, objSelector, bindingSelector) {
var pd = this.obj.getOwnPropertyDescriptor(key, dumper.intrp2.ROOT);
if (!pd) {
throw new RangeError("can't dump nonexistent property " + bindingSelector);
}
// Do this binding, if requested.
var done = this.getDone(key);
if (todo >= Do.DECL && todo > done && done < Do.ATTR) {
var attr = this.attributes[key];
// If only "declaring" property, set it to undefined.
var value = (todo === Do.DECL) ? undefined : pd.value;
// Output assignment statement if useful.
if (done < Do.SET && this.isWritable(dumper, key)) {
if (!attr) {
attr = this.attributes[key] =
{writable: true, enumerable: true, configurable: true};
}
// Will this assignemnt set the .name of an anonymous function?
// TODO(ES6): Handle prefix?
var funcName = dumper.intrp1.options.methodNames ? key : undefined;
dumper.write(dumper.exprForSelector_(bindingSelector), ' = ',
dumper.exprFor_(value, partRef, false, funcName), ';');
done = this.checkProperty(key, value, attr, pd);
}
// Output defineProperty call if useful.
if (todo > done && done < Do.ATTR) {
if (!attr) {
attr = this.attributes[key] =
{writable: false, enumerable: false, configurable: false};
} else if (!attr.configurable) {
dumper.warn(
"Can't redefine non-configurable property " + bindingSelector);
return done;
}
var items = [];
if (attr.writable !== (pd.writable || todo < Do.SET)) {
attr.writable = pd.writable || todo < Do.SET;
items.push('writable: ' + attr.writable);
}
if (attr.enumerable !== (pd.enumerable || todo < Do.SET)) {
attr.enumerable = pd.enumerable || todo < Do.SET;
items.push('enumerable: ' + attr.enumerable);
}
if (attr.configurable !== (pd.configurable || todo < Do.SET)) {
attr.configurable = pd.configurable || todo < Do.SET;
items.push('configurable: ' + attr.configurable);
}
if (todo >= Do.SET && done < Do.SET) {
// TODO(cpcallen): supply selector here?
items.push('value: ' + dumper.exprFor_(value));
}
dumper.write(dumper.exprForBuiltin_('Object.defineProperty'), '(',
dumper.exprForSelector_(objSelector), ', ',
dumper.exprFor_(key), ', {', items.join(', '), '});');
done = this.checkProperty(key, value, attr, pd);
}
}
return done;
};
/**
* Generate JS source text to set the object's [[Prototype]].
* @private
* @param {!Dumper} dumper Dumper to which this ObjectDumper belongs.
* @param {!Do} todo How much to do. Must be >= Do.DECL; > Do.SET ignored.
* @param {!Components} partRef A reference to this object's [[Owner]] slot.
* @param {!Selector} objSelector Selector refering to this object.
* @param {!Selector} bindingSelector Selector refering to this
* object's [[Prototype]] slot.
* @return {!Do} The done status of the object's [[Prototype]] slot.
*/
ObjectDumper.prototype.dumpPrototype_ = function(
dumper, todo, partRef, objSelector, bindingSelector) {
var value = this.obj.proto;
if (todo >= Do.SET && this.doneProto_ < Do.SET) {
// Record prototype connection.
this.proto = value;
if (value !== null) {
dumper.getObjectDumper_(value)
.updateRef(dumper, new Components(this, Selector.PROTOTYPE));
}
dumper.write(
dumper.exprForCall_('Object.setPrototypeOf', [objSelector, value]),
';');
this.doneProto_ = (value === null) ? Do.RECURSE: Do.DONE;
}
return this.doneProto_;
};
/**
* Return the current 'done' status of an object binding.
* @param {Selector.Part} part The part to get status for.
* @return {!Do} The done status of the binding.
*/
ObjectDumper.prototype.getDone = function(part) {
if (part === Selector.PROTOTYPE) {
return this.doneProto_;
} else if (part === Selector.OWNER) {
return this.doneOwner_;
} else if (typeof part === 'string') {
var done = this.doneProp_[part];
return done === undefined ? Do.UNSTARTED : done;
} else {
throw new TypeError('Invalid part');
}
};
/**
* Return a Selector for this object. If preferred is true, the
* preferred selector will be returned; this is the least-badness
* Selecgtor in intrp2 for this.obj, but may not yet be a valid
* selector at the current point in the dump. Otherwise, the selector
* returned will be the best known valid selector. An Error will be
* thrown if no valid selector exists.
* @param {boolean=} preferred Return preferred selector?
* @return {!Selector} A selector for this.obj.
*/
ObjectDumper.prototype.getSelector = function(preferred) {
var /** !SubDumper */ sd = this;
var /** !Array */ parts = [];
while (sd instanceof ObjectDumper) {
var /** ?Components */ next = preferred ? sd.preferredRef : sd.ref;
if (!next) throw new Error('unreferenced object while building Selector');
sd = next.dumper;
parts.unshift(next.part);
}
if (!(sd instanceof ScopeDumper)) {
throw new TypeError('unknown SubDumper subclass');
} else if (sd.scope.type !== Interpreter.Scope.Type.GLOBAL) {
throw new Error('refusing to create Selector for non-global scope');
}
return new Selector(parts);
};
/**
* Return the value of the given part of this.obj (i.e., the value
* in intrp2, and the intended final value provided that it isn't
* going to be pruned.)
* @param {!Dumper} dumper Dumper to which this ObjectDumper belongs.
* @param {Selector.Part} part The binding part to get the value of.
* @return {Interpreter.Value} The value of that part.
*/
ObjectDumper.prototype.getValue = function(dumper, part) {
if (typeof part === 'string') {
return this.obj.get(part, dumper.intrp2.ROOT);
} else if (part === Selector.PROTOTYPE) {
return this.obj.proto;
} else if (part === Selector.OWNER) {
return /** @type{?Interpreter.prototype.Object} */(this.obj.owner);
} else {
throw new Error('unknown part type');
}
};
/**
* Return true iff the specifed property can be created or set by
* assignment - i.e., that it exists and is writable, or doesn't exist
* and does not inherit from a non-writable property on the prototype
* chain.
*
* N.B. this not checking writability on intrp1 or intrp2, but on the
* notional state of the interpreter at this point in the dump (i.e.,
* somewhere in between the two), as recorded on the relevant
* ObjectDumper .attibutes and .proto properties.
*
* @param {!Dumper} dumper Dumper to which this ObjectDumper belongs.
* @param {string} key The property key to check for writability of.
* @return {boolean} True iff the property can be set by assignment.
*/
ObjectDumper.prototype.isWritable = function(dumper, key) {
// Invariant checks.
if (this.proto === undefined) {
throw new Error('Checking writability of property on non-created object');
} else if ((key in this.attributes) !== (this.getDone(key) >= Do.DECL)) {
throw new Error('Attribute / done mismatch');
}
if (key in this.attributes) {
return this.attributes[key].writable;
} else {
if (this.proto === null) {
return true;
} else {
return dumper.getObjectDumper_(this.proto).isWritable(dumper, key);
}
}
};
/**
* Return true iff this.object is currently reachable.
* @param {!Dumper} dumper Dumper to which this ObjectDumper belongs.
* @param {Selector.Part=} part The binding whose reachability is of
* interest. Ignored, since all object bindings are always
* reachable if the object is.
* @return {boolean}
*/
ObjectDumper.prototype.reachable = function(dumper, part) {
return Boolean(this.ref) && this.ref.dumper.reachable(dumper, this.ref.part);
};
/**
* Record that the (ressurected) object will have a property, not on
* the original, that needs to be deleted.
* @param {string} key The property key to delete.
*/
ObjectDumper.prototype.scheduleDeletion = function(key) {
if (this.toDelete) {
this.toDelete.push(key);
} else {
this.toDelete = [key];
}
};
/**
* Update the current 'done' status of a property. Will throw a
* RangeError if caller attempts to un-do or re-do a previously-done
* action.
* @param {Selector.Part} part The part to set status for.
* @param {!Do} done The new done status of the binding.
*/
ObjectDumper.prototype.setDone = function(part, done) {
var old = this.getDone(part);
// Invariant checks.
if (done <= old) {
var fault = (done === old) ? 'Refusing redundant' : "Can't undo previous";
var description = this.getSelector(/*preferred=*/true);
throw new RangeError(fault + ' work on ' + part + ' of ' + description);
}
// Do set.
if (part === Selector.PROTOTYPE) {
this.doneProto_ = done;
} else if (part === Selector.OWNER) {
this.doneOwner_ = done;
} else if (typeof part === 'string') {
this.doneProp_[part] = done;
}
};
/**
* Visit an Object to prepare for dumping. In particular:
*
* - If this.object is a UserFunction, record it on it's .scope's
* ScopeDumper's list of inner functions, so that when we go to dump
* that scope later we know all the functions that need to be
* declared within it.
*
* - Collect and return an array of {part, value}, where each
* represents a property or internal slot of this.object. If
* this.object is a UserFunction, the returned array will also
* contain a bare ScopeDumper object representing the
* function's enclosing scope.
*
* @param {!Dumper} dumper Dumper to which this ObjectDumper belongs.
* @return {!Array}
*/
ObjectDumper.prototype.survey = function(dumper) {
var /** !Array */ adjacent = [];
if (this.obj instanceof dumper.intrp2.UserFunction) {
// Record this this function as inner to scope, and survey scope.
var scopeDumper = dumper.getScopeDumper_(this.obj.scope);
scopeDumper.innerFunctions.add(this);
adjacent.push(scopeDumper);
}
adjacent.push({part: Selector.PROTOTYPE, value: this.obj.proto});
var ownerObj = /** @type {!Interpreter.prototype.Object} */(this.obj.owner);
adjacent.push({part: Selector.OWNER, value: ownerObj});
var keys = this.obj.ownKeys(dumper.intrp2.ROOT);
for (var i = 0; i < keys.length; i++) {
var key = keys[i];
var value = this.obj.get(key, dumper.intrp2.ROOT);
adjacent.push({part: key, value: value});
}
return adjacent;
};
/**
* Record a new reference to the object, if it is 'better' than the
* existing one. 'Better' means, in order of priority:
*
* - Ignore references from self entirely.
* - Prefer any reference over no reference.
* - Prefer references from reachable objects over ones from
* unreachable objects.
* - If both existing (this.ref) and proposed (ref) .dumpers are reachable:
* - Prefer .preferredRef over others, otherwise
* - Prefer reference with lowest overall badness.
* - If neither .dumper is reachable, prefer reference with lowest overall
* badness when using .dumpers's .preferredRef instead.
*
* @param {!Dumper} dumper The Dumper to which this ObjectDumber belongs.
* @param {!Components} ref The new reference.
* @return {void}
*/
ObjectDumper.prototype.updateRef = function(dumper, ref) {
if (ref.dumper === this) return; // Ignore references from self entirely.
if (!this.ref) { // Prefer any reference over no reference.
this.ref = ref;
return;
}
if (this.ref.isReachable(dumper)) {
if (ref.isReachable(dumper)) { // Both existing and new refs reachable.
if (this.preferredRef) { // Prefer .preferredRef over others.
if (this.preferredRef.equals(this.ref)) {
return;
} else if(this.preferredRef.equals(ref)) {
this.ref = ref;
return;
}
}
// Otherwise, prefer ref with lowest overall badness.
var oldBadness = this.getSelector().badness();
var newBadness = Selector.partBadness(ref.part);
if (ref.dumper instanceof ObjectDumper) {
newBadness += ref.dumper.getSelector().badness();
}
if (newBadness < oldBadness) this.ref = ref;
}
} else {
if (ref.isReachable(dumper)) { // Existing ref unreachable but new ref is!
this.ref = ref;
} else { // Neither existing nor new refs reachable.
var oldBadness =
Selector.partBadness(this.ref.part) +
(this.ref.dumper instanceof ObjectDumper ?
this.ref.dumper.getSelector(/*preferred=*/true).badness() :
0);
var newBadness =
Selector.partBadness(ref.part) +
(ref.dumper instanceof ObjectDumper ?
ref.dumper.getSelector(/*preferred=*/true).badness() :
0);
if (newBadness < oldBadness) this.ref = ref;
}
}
};
/**
* Tri-state "done" flag for ObjectDumper. A bit like Do, but for the
* whole object rather than a single binding.
* @enum {number}
*/
ObjectDumper.Done = {
/** Object not fully dumped. */
NO: 0,
/**
* Object is done (has all own properties fully defined including
* attributes, has correct [[Owner]] and [[Prototype]], is
* non-extensible if applicable, etc.).
*/
DONE: 1,
/** This object and all objects accessible from it are done. */
DONE_RECURSIVELY: 2,
};
/**
* A record of pending bindings returned by the .dump and .dumpBinding
* methods when they encounter a circular dependency while trying to
* recursively dump some objects.
*
* E.g., given objects a and b, if a.b === b, and b.a === a, then
* either both a and b can be both be fully recursivley dumped or
* neither is. When attempting to dump a, the dumpProperty()
* will try to dump b, which will ensure that b.a is done and return a
* Pending object indicating that being recursively done is
* awaiting completion of a.
*
* @constructor
* @struct
* @param {!Selector} binding A binding awaiting recursive completion
* of its value object.
* @param {!ObjectDumper} valueDumper The ObjectDumper for the object
* which is the value of binding.
*/
ObjectDumper.Pending = function(binding, valueDumper) {
if (!binding) throw new Error('no binding');
if (!valueDumper) throw new Error('no valueDumper');
/** !Array */
this.bindings = [binding];
/** !Array */
this.dependencies = [valueDumper];
};
/**
* Add a new (binding, dependency) pair to this Pending object.
* @param {!Selector} binding A binding awaiting recursive completion
* of its value object.
* @param {!ObjectDumper} valueDumper The ObjectDumper for the object
* which is the value of binding.
*/
ObjectDumper.Pending.prototype.add = function(binding, valueDumper) {
if (!binding) throw new Error('no binding');
if (!valueDumper) throw new Error('no valueDumper');
this.bindings.push(binding);
this.dependencies.push(valueDumper);
};
/**
* Merge another pending list into this one.
* @param {!ObjectDumper.Pending} that Another Pending list.
*/
ObjectDumper.Pending.prototype.merge = function(that) {
this.bindings = this.bindings.concat(that.bindings);
this.dependencies = this.dependencies.concat(that.dependencies);
};
/** @override */
ObjectDumper.Pending.prototype.toString = function() {
return '{bindings: [' + this.bindings.join(', ') + '], ' +
'dependencies: [' + this.dependencies.map(function(od) {
return String(od.getSelector(/*preferred=*/true));
}).join(', ') + ']}';
};
///////////////////////////////////////////////////////////////////////////////
// Helper Classes.
/**
* A {SubDumper, Selector.Part} tuple.
*
* N.B.: the usage of 'components' here is analagous to that term's
* usage in interpreter.js but not identical: there is is a [scope,
* variable] tuple; here it is a {ScopeDumper/ObjectDumper,
* Selector.Part} tuple.
*
* @constructor
* @struct
* @param {!SubDumper} dumper
* @param {Selector.Part} part
*/
var Components = function(dumper, part) {
/** @const {!SubDumper} */ this.dumper = dumper;
/** @const {Selector.Part} */ this.part = part;
};
/**
* Return true iff this and that represent the same binding.
* @param {!Components} that Another Components to compare this with.
* @return {boolean}
*/
Components.prototype.equals = function(that) {
return this.dumper === that.dumper && this.part === that.part;
};
/**
* Return true iff this reference is currently reachable.
* @param {!Dumper} dumper Dumper to which this Components belongs.
* @return {boolean}
*/
Components.prototype.isReachable = function(dumper) {
return this.dumper.reachable(dumper, this.part);
};
/**
* Custom util.inspect implementation, to make debug/test output more
* readable.
* @param {number} depth
* @param {util.inspect.Options} opts
* @return {string}
*/
Components.prototype[util.inspect.custom] = function(depth, opts) {
var /** string */ dumper;
if (this.dumper instanceof ScopeDumper) {
dumper = util.format('<%s scope>', this.dumper.scope.type);
} else if (this.dumper instanceof ObjectDumper) {
try {
dumper = this.dumper.getSelector(/*preferred=*/true).toString();
} catch (e) {
dumper = '';
}
}
return util.format('[%s.%s]', dumper, this.part);
};
///////////////////////////////////////////////////////////////////////////////
// Type declarations: Do, etc.
/**
* Possible things to do (or have done) with a variable / property /
* etc. binding. N.B.: values meaning "don't do this one (yet)"
* are negative, "nothing done" is zero (and therefore falsey), and
* "some work has been done" are positive.
*
* Code should not depend on the numeric values of the enum options,
* but it is permissiible to depend on the options being in numeric
* order of ascending completion - i.e., Do.x implies Do.y if Do.x >=
* Do.y.
*
* @enum {number}
*/
var Do = {
/**
* Nothing has been done about this binding yet. Only valid as a
* 'done' value, not as a 'do' value.
*/
UNSTARTED: 0,
/**
* Ensure that the specified binding exists, but do not yet set it
* to its final value. If the binding is a variable, it has been /
* will be declared; if it is a property, it has been / will be
* created but not (yet) set to a value other than undefined (nor
* made non-configurable).
*/
DECL: 1,
/**
* Ensure that the specified binding exists and has been set to its
* final value (if primitive) or an object of the correct class (if
* non-primitive).
*
* For property bindings, the property attributes will generally not
* (yet) be set, and if a new object was created to be the value of
* the specified binding it will generally not (yet) have its
* properties or internal set/map data set (but immutable internal
* data, such as function code, will have been set at creation).
*/
SET: 2,
/**
* Ensure theat the specified binding has been set to its final
* value, and additionally that the final property attributes
* (enumerable, writable and/or configurable) are set. DONE is
* provided as an alias for bindings (like variables,
* [[Prototype]] and [[Owner]] that don't have attributes; for
* those, SET should automatically be promoted to DONE.
*/
ATTR: 3,
DONE: 3,
/**
* Ensure the specified path is has been set to its final value (and
* marked immuable, if applicable) and that the same has been done
* recursively to all bindings reachable via path.
*/
RECURSE: 4,
};
/**
* Options object for Dumper.
* @record
*/
var DumperOptions = function() {};
/**
* The stream that this.write() will write to. Setting it to null
* (the default) will cause cause .write() to do nothing, causing
* dumped code to be lost.
* @type {?Writable|undefined}
*/
DumperOptions.prototype.output;
/**
* Skip the named bindings.
* @type {!Array|undefined}
*/
DumperOptions.prototype.skipBindings;
/**
* If true, limit recursive dumping to the spaning tree defined by the
* preferred selectors.
*
* E.g.: Noting that Object{proto}, Fucntion{proto} and
* Function.prototype are the same object. If treeOnly is true (the
* default), then:
*
* * Dumping Object recursively would set Object{proto} but not visit
* Function.prototype at all, while
* * Dumping Function recursively would set Function{proto} but
* recurse into Function.prototype.
*
* On the other hand, if treeOnly is false, then dumping Object
* recursively would recurse into Object{proto} (i.e.,
* Function.prototype by a different name), and dumping Function might
* choose ot recurse via Function{proto} rather than
* Function.prototype.
*
* @type {boolean|undefined}
*/
DumperOptions.prototype.treeOnly;
/**
* Print status information and warnings to the console?
* @type {boolean|undefined}
*/
DumperOptions.prototype.verbose;
/**
* Default options for Dumper.
* @const @type {!DumperOptions}
*/
var DEFAULT_OPTIONS = {
output: null,
skipBindings: [],
treeOnly: true,
verbose: false,
};
/**
* A value representing an outward edge (from an unspecified object)
* on the object graph.
*
* - Outward edges that are properties or internal slots are
* represented as a {Selector.Part, Interpreter.Value} tuple.
* - Outward edges that are the enclosing scope of a UserFunction are
* represented by a bare ScopeDumper.
* @typedef {{part: Selector.Part, value: Interpreter.Value}|!ScopeDumper}
*/
var OutwardEdge;
/**
* A writable stream. Could be a stream.Writable, but we don't check
* the return value of .write to see if it's safe to keep writing, so
* caller might prefer to supply a synchronous implementation instead!
* @interface
*/
var Writable = function() {};
/**
* Write a string to the writable stream.
* @param {string} s
*/
Writable.prototype.write = function(s) {};
///////////////////////////////////////////////////////////////////////////////
// Exports.
exports.Do = Do;
exports.Dumper = Dumper;
exports.DumperOptions = DumperOptions;
exports.Writable = Writable;
// For unit testing only!
exports.testOnly = {
Components: Components,
ObjectDumper: ObjectDumper,
ScopeDumper: ScopeDumper,
};
================================================
FILE: server/externs/WeakRef.js
================================================
/**
* @license
* Copyright 2018 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Closure Compiler externs for the new ES2020 WeakRef and
* FinalizationRegistry API https://tc39.es/ecma262/#sec-managing-memory
* @author cpcallen@google.com (Christopher Allen)
* @externs
*/
// Closure Compiler (as of google-closue-compiler@20210406.0.0) now
// knows about WeakRef, but it doesn't yet know about FinalizationRegistry.
/**
* @constructor
* @struct
* @param {function(HELDVALUE)} cleanupCallback
* @template TARGET, HELDVALUE, TOKEN
* @nosideeffects
*/
// TODO(cpcallen): Make TARGET and TOKEN bounded to {!Object} once
// closure-compiler supports bounded generic types.
var FinalizationRegistry = function(cleanupCallback) {};
/**
* @param {TARGET} target
* @param {HELDVALUE} heldValue
* @param {TOKEN=} unregisterToken
* @return {void}
*/
FinalizationRegistry.prototype.register =
function(target, heldValue, unregisterToken) {};
/**
* @param {TOKEN} unregisterToken
* @return {void}
*/
FinalizationRegistry.prototype.unregister = function(unregisterToken) {};
================================================
FILE: server/externs/buffer/buffer.js
================================================
/**
* @license
* Copyright 2018 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Fake implementation of node.js's buffer module to
* satisfy Closure Compiler dependencies. This is mostly an
* excerpt from contrib/nodejs/buffer.js from
* https://github.com/google/closure-compiler.git
* @author cpcallen@google.com (Christopher Allen)
*/
// TODO(cpcallen): Use official externs directly.
/** @constructor @struct */
var Buffer = function() {};
exports.Buffer = Buffer;
================================================
FILE: server/externs/buffer/package.json
================================================
{
"description": "Fake package.json for require('buffer')",
"main": "buffer.js",
"name": "buffer",
}
================================================
FILE: server/externs/crypto/crypto.js
================================================
/**
* @license
* Copyright 2018 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Fake implementation of node.js's crypto module to satisfy
* Closure Compiler dependencies. This is mostly an excerpt from
* contrib/nodejs/fs.js from
* https://github.com/google/closure-compiler.git
* @author cpcallen@google.com (Christopher Allen)
*/
// TODO(cpcallen): Use official externs directly.
var Buffer = require('buffer').Buffer;
var stream = require('stream');
/** @const */
var crypto = {};
/**
* @param {string} algorithm
* @return {crypto.Hash}
*/
crypto.createHash = function(algorithm) {};
/**
* @constructor
* @struct
* @extends stream.Transform
* @param {string} algorithm
* @param {Object=} options
*/
crypto.Hash = function(algorithm, options) {};
/**
* @param {string|Buffer} data
* @param {string=} input_encoding
* @return {crypto.Hash}
*/
crypto.Hash.prototype.update = function(data, input_encoding) {};
/**
* @param {string=} encoding
* @return {string}
*/
crypto.Hash.prototype.digest = function(encoding) {};
/**
* @return {!Array}
*/
crypto.getHashes = function() {};
module.exports = crypto;
================================================
FILE: server/externs/crypto/package.json
================================================
{
"description": "Fake package.json for require('crypto')",
"main": "crypto.js",
"name": "crypto",
}
================================================
FILE: server/externs/events/events.js
================================================
/**
* @license
* Copyright 2018 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Fake implementation of node.js's events module to
* satisfy Closure Compiler dependencies.
* @author cpcallen@google.com (Christopher Allen)
*/
/** @const */
var events = {};
/** @type {symbol} */
events.errorMonitor;
/** @constructor @struct */
events.EventEmitter = function() {};
/**
* @param {string|symbol} event
* @param {function(...)} listener
* @return {events.EventEmitter}
*/
events.EventEmitter.prototype.on = function(event, listener) {};
/**
* @param {string|symbol} event
* @param {function(...)} listener
* @return {events.EventEmitter}
*/
events.EventEmitter.prototype.once = function(event, listener) {};
/**
* @param {string|symbol} event
* @param {function(...)} listener
* @return {events.EventEmitter}
*/
events.EventEmitter.prototype.removeListener = function(event, listener) {};
module.exports = events;
================================================
FILE: server/externs/events/package.json
================================================
{
"description": "Fake package.json for require('events')",
"main": "events.js",
"name": "events",
}
================================================
FILE: server/externs/fs/fs.js
================================================
/**
* @license
* Copyright 2018 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Fake implementation of node.js's fs module to satisfy
* Closure Compiler dependencies. This is mostly an excerpt from
* contrib/nodejs/fs.js from
* https://github.com/google/closure-compiler.git
* @author cpcallen@google.com (Christopher Allen)
*/
// TODO(cpcallen): Use official externs directly.
var Buffer = require('buffer').Buffer;
var stream = require('stream');
/** @const */
var fs = {};
/**
* @param {string} path
* @param {number=} mode
*/
fs.accessSync = function(path, mode) {};
/**
* @param {number} fd
* @return {void}
*/
fs.closeSync = function(fd) {};
/**
* @param {string} path
* @param {{flags: (string|undefined),
* encoding: (string|undefined),
* fd: (number|undefined),
* mode: (number|undefined),
* bufferSize: (number|undefined)}=} options
* @return {fs.ReadStream}
*/
fs.createReadStream = function(path, options) {};
/**
* @constructor
* @struct
* @extends stream.ReadableStream
*/
fs.ReadStream = function () {};
/**
* @param {string} path
* @param {{flags: (string|undefined),
* encoding: (string|undefined),
* mode: (number|undefined)}=} options
* @return {fs.WriteStream}
*/
fs.createWriteStream = function(path, options) {};
/**
* @constructor
* @struct
* @extends stream.WritableStream
*/
fs.WriteStream = function () {};
/**
* @param {string} path
* @return {boolean}
*/
fs.existsSync = function(path) {};
/**
* @param {string} path
* @param {string} flags
* @param {number=} mode
* @return {number}
*/
fs.openSync = function(path, flags, mode) {};
/**
* @param {string} path
* @return {Array}
*/
fs.readdirSync = function(path) {};
/**
* @param {string} filename
* @param {string=} encoding
* @return {string|Buffer}
*/
fs.readFileSync = function(filename, encoding) {};
/**
* @param {string} oldPath
* @param {string} newPath
* @return {void}
*/
fs.renameSync = function(oldPath, newPath) {};
/**
* @param {string} path
* @return {fs.Stats}
*/
fs.statSync = function(path) {};
/**
* @param {string} path
* @return {void}
*/
fs.unlinkSync = function(path) {};
/**
* @param {string} filename
* @param {*} data
* @param {string=} encoding
* @return {void}
*/
fs.writeFileSync = function(filename, data, encoding) {};
/**
* @param {number} fd
* @param {string} string
* @param {number=} position
* @param {string=} encoding
* @return {number}
*/
fs.writeSync = function(fd, string, position, encoding) {};
/** @constructor @struct */
fs.Stats = function () {};
/** @return {boolean} */
fs.Stats.prototype.isFile;
/** @return {boolean} */
fs.Stats.prototype.isDirectory;
/** @return {boolean} */
fs.Stats.prototype.isBlockDevice;
/** @return {boolean} */
fs.Stats.prototype.isCharacterDevice;
/** @return {boolean} */
fs.Stats.prototype.isSymbolicLink;
/** @return {boolean} */
fs.Stats.prototype.isFIFO;
/** @return {boolean} */
fs.Stats.prototype.isSocket;
/** @type {number} */
fs.Stats.prototype.dev = 0;
/** @type {number} */
fs.Stats.prototype.ino = 0;
/** @type {number} */
fs.Stats.prototype.mode = 0;
/** @type {number} */
fs.Stats.prototype.nlink = 0;
/** @type {number} */
fs.Stats.prototype.uid = 0;
/** @type {number} */
fs.Stats.prototype.gid = 0;
/** @type {number} */
fs.Stats.prototype.rdev = 0;
/** @type {number} */
fs.Stats.prototype.size = 0;
/** @type {number} */
fs.Stats.prototype.blkSize = 0;
/** @type {number} */
fs.Stats.prototype.blocks = 0;
/** @type {Date} */
fs.Stats.prototype.atime;
/** @type {Date} */
fs.Stats.prototype.mtime;
/** @type {Date} */
fs.Stats.prototype.ctime;
module.exports = fs;
================================================
FILE: server/externs/fs/package.json
================================================
{
"description": "Fake package.json for require('fs')",
"main": "fs.js",
"name": "fs",
}
================================================
FILE: server/externs/http/http.js
================================================
/**
* @license
* Copyright 2018 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Fake implementation of node.js's http module to
* satisfy Closure Compiler dependencies. This is mostly an
* adaptation of contrib/nodejs/http.js from
* https://github.com/google/closure-compiler.git
* @author cpcallen@google.com (Christopher Allen)
*/
// TODO(cpcallen): Use official externs directly.
var Buffer = require('buffer').Buffer;
var events = require('events');
var net = require('net');
var stream = require('stream');
/** @const */
var http = {};
/**
* @typedef {function(http.IncomingMessage, http.ServerResponse)}
*/
http.requestListener;
/**
* @param {http.requestListener=} listener
* @return {http.Server}
*/
http.createServer;
/**
* @constructor
* @struct
* @extends events.EventEmitter
* @param {http.requestListener=} listener
*/
http.Server = function(listener) {};
/**
* @param {(number|string)} portOrPath
* @param {(string|Function)=} hostnameOrCallback
* @param {Function=} callback
*/
http.Server.prototype.listen;
/**
* @return {void}
*/
http.Server.prototype.close;
/**
* @constructor
* @struct
* @extends stream.Readable
*/
http.IncomingMessage = function() {};
/**
* @type {?string}
* */
http.IncomingMessage.prototype.method;
/**
* @type {?string}
*/
http.IncomingMessage.prototype.url;
/**
* @type {Object}
* */
http.IncomingMessage.prototype.headers;
/**
* @type {Object}
* */
http.IncomingMessage.prototype.trailers;
/**
* @type {string}
*/
http.IncomingMessage.prototype.httpVersion;
/**
* @type {string}
*/
http.IncomingMessage.prototype.httpVersionMajor;
/**
* @type {string}
*/
http.IncomingMessage.prototype.httpVersionMinor;
/**
* @type {*}
*/
http.IncomingMessage.prototype.connection;
/**
* @type {?number}
*/
http.IncomingMessage.prototype.statusCode;
/**
* @type {net.Socket}
*/
http.IncomingMessage.prototype.socket;
/**
* @param {number} msecs
* @param {function()} callback
* @return {void}
*/
http.IncomingMessage.prototype.setTimeout;
/**
* @constructor
* @struct
* @extends events.EventEmitter
* @private
*/
http.ServerResponse = function() {};
/**
* @return {void}
*/
http.ServerResponse.prototype.writeContinue;
/**
* @param {number} statusCode
* @param {*=} reasonPhrase
* @param {*=} headers
*/
http.ServerResponse.prototype.writeHead;
/**
* @type {number}
*/
http.ServerResponse.prototype.statusCode;
/**
* @param {string} name
* @param {string} value
* @return {void}
*/
http.ServerResponse.prototype.setHeader;
/**
* @param {string} name
* @return {string|undefined} value
*/
http.ServerResponse.prototype.getHeader;
/**
* @param {string} name
* @return {void}
*/
http.ServerResponse.prototype.removeHeader;
/**
* @param {string|Array|Buffer} chunk
* @param {string=} encoding
* @return {void}
*/
http.ServerResponse.prototype.write;
/**
* @param {Object} headers
* @return {void}
*/
http.ServerResponse.prototype.addTrailers;
/**
* @param {(string|Array|Buffer)=} data
* @param {string=} encoding
* @return {void}
*/
http.ServerResponse.prototype.end;
/**
* @constructor
* @struct
* @extends events.EventEmitter
* @private
*/
http.ClientRequest = function() {};
/**
* @param {string|Array|Buffer} chunk
* @param {string=} encoding
* @return {void}
*/
http.ClientRequest.prototype.write;
/**
* @param {(string|Array|Buffer)=} data
* @param {string=} encoding
* @return {void}
*/
http.ClientRequest.prototype.end;
/**
* @return {void}
*/
http.ClientRequest.prototype.abort;
/**
* @param {string|!Object} urlOrOptions
* @param {!Object|function(!http.IncomingMessage)=} optionsOrCallback
* @param {function(!http.IncomingMessage)=} callback
* @return {http.ClientRequest}
*/
http.request = function(urlOrOptions, optionsOrCallback, callback) {};
/**
* @param {string|!Object} urlOrOptions
* @param {!Object|function(!http.IncomingMessage)=} optionsOrCallback
* @param {function(!http.IncomingMessage)=} callback
* @return {http.ClientRequest}
*/
http.get = function(urlOrOptions, optionsOrCallback, callback) {};
/**
* @constructor
* @struct
* @extends events.EventEmitter
*/
http.Agent = function() {};
/**
* @type {number}
*/
http.Agent.prototype.maxSockets;
/**
* @type {number}
*/
http.Agent.prototype.sockets;
/**
* @type {Array.}
*/
http.Agent.prototype.requests;
/**
* @type {http.Agent}
*/
http.globalAgent;
module.exports = http;
================================================
FILE: server/externs/http/package.json
================================================
{
"description": "Fake package.json for require('http')",
"main": "http.js",
"name": "http",
}
================================================
FILE: server/externs/https/https.js
================================================
/**
* @license
* Copyright 2018 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Fake implementation of node.js's https module to
* satisfy Closure Compiler dependencies. This is mostly an
* adaptation of contrib/nodejs/https.js from
* https://github.com/google/closure-compiler.git
* @author cpcallen@google.com (Christopher Allen)
*/
// TODO(cpcallen): Use official externs directly.
var Buffer = require('buffer').Buffer;
var http = require('http');
var tls = require('tls');
/** @const */
var https = {};
/**
* @constructor
* @struct
* @extends tls.Server
*/
https.Server = function() {};
/**
* @param {...*} var_args
* @return {void}
*/
https.Server.prototype.listen;
/**
* @param {function()=} callback
* @return {void}
*/
https.Server.prototype.close;
/**
* @param {tls.CreateOptions} options
* @param {function(http.IncomingMessage, http.ServerResponse)=} requestListener
* @return {!https.Server}
*/
https.createServer;
/**
* @typedef {{host: ?string, hostname: ?string, port: ?number, method: ?string, path: ?string, headers: ?Object., auth: ?string, agent: ?(https.Agent|boolean), pfx: ?(string|Buffer), key: ?(string|Buffer), passphrase: ?string, cert: ?(string|Buffer), ca: ?Array., ciphers: ?string, rejectUnauthorized: ?boolean}}
*/
https.ConnectOptions;
/**
* @param {string|!Object} urlOrOptions
* @param {!Object|function(!http.IncomingMessage)=} optionsOrCallback
* @param {function(!http.IncomingMessage)=} callback
* @return {http.ClientRequest}
*/
https.request = function(urlOrOptions, optionsOrCallback, callback) {};
/**
* @param {string|!Object} urlOrOptions
* @param {!Object|function(!http.IncomingMessage)=} optionsOrCallback
* @param {function(!http.IncomingMessage)=} callback
* @return {http.ClientRequest}
*/
https.get = function(urlOrOptions, optionsOrCallback, callback) {};
/**
* @constructor
* @struct
* @extends http.Agent
*/
https.Agent = function() {};
/**
* @type {https.Agent}
*/
https.globalAgent;
module.exports = https;
================================================
FILE: server/externs/https/package.json
================================================
{
"description": "Fake package.json for require('https')",
"main": "https.js",
"name": "https",
}
================================================
FILE: server/externs/net/net.js
================================================
/**
* @license
* Copyright 2018 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Fake implementation of node.js's net module to
* satisfy Closure Compiler dependencies.
* @author cpcallen@google.com (Christopher Allen)
*/
var Buffer = require('buffer').Buffer;
var events = require('events');
var net = {};
/**
* @typedef {{allowHalfOpen: ?boolean}}
*/
var createOptions;
/**
* @param {(createOptions|function(...))=} options
* @param {function(...)=} connectionListener
* @return {net.Server}
*/
net.createServer = function(options, connectionListener) {};
/**
* @typedef {{port: (number|undefined),
* host: (string|undefined),
* localAddress: (string|undefined),
* path: (string|undefined),
* allowHalfOpen: (boolean|undefined)}}
*/
var connectOptions;
/**
* @param {connectOptions|number|string} arg1
* @param {(function(...)|string)=} arg2
* @param {function(...)=} arg3
* @return {!net.Socket}
*/
net.createConnection = function(arg1, arg2, arg3) {};
///////////////////////////////////////////////////////////////////////////////
// net.Server
/**
* @constructor
* @struct
* @param {createOptions=} options
* @extends {events.EventEmitter}
*/
net.Server = function(options) {};
/**
* @return {{port: number, family: string, address: string}}
*/
net.Server.prototype.address = function() {};
/**
* @param {function(...)=} callback
* @return {void}
*/
net.Server.prototype.close = function(callback) {};
/**
*
* @param {number|*} port
* @param {(string|number|function(...))=} host
* @param {(number|function(...))=} backlog
* @param {function(...)=} callback
* @return {void}
*/
net.Server.prototype.listen = function(port, host, backlog, callback) {};
///////////////////////////////////////////////////////////////////////////////
// net.Socket
/**
* @constructor
* @struct
* @param {{fd: ?*, type: ?string, allowHalfOpen: ?boolean}=} options
* @extends events.EventEmitter
*/
net.Socket = function(options) {};
/**
* @param {string|Buffer} data
* @param {(string|function(...))=} encoding
* @param {function(...)=} callback
* @return {void}
*/
net.Socket.prototype.write = function(data, encoding, callback) {};
/**
* @param {(string|Buffer)=} data
* @param {(string|function(...))=} encoding
* @param {function(...)=} callback
* @return {void}
*/
net.Socket.prototype.end = function(data, encoding, callback) {};
module.exports = net;
================================================
FILE: server/externs/net/package.json
================================================
{
"description": "Fake package.json for require('net')",
"main": "net.js",
"name": "net",
}
================================================
FILE: server/externs/node.js
================================================
/**
* @license
* Copyright 2018 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Closure Compiler externs for node.js, mostly
* excerpted from contrib/nodejs/globals.js from
* https://github.com/google/closure-compiler.git
* @author cpcallen@google.com (Christopher Allen)
* @externs
*/
// TODO(cpcallen): Use official externs directly.
/** @const {string} */
var __filename;
/** @const {string} */
var __dirname;
/** @type {!Object} */
var exports;
/** @param {boolean=} full */
var gc = function(full) {};
/** @type {!Object} */
var module;
/**
* @param {string} name
* @return {?}
*/
function require(name) {}
/** @type {!Object} */
require.main;
/**
* @param {string} request
* @param {!Object=} options
* @return {string}
*/
require.resolve = function(request, options) {};
///////////////////////////////////////////////////////////////////////////////
// process
/** @const */
var process = {};
/** @type {string} */
process.arch;
/** @type {!Array} */
process.argv;
/** @return {string} */
process.cwd = function () {};
/** @type {!Object} */
process.env;
/** @param {number=} code */
process.exit = function (code) {};
/**
* @param {!Array=} time
* @return {!Array}
*/
process.hrtime = function(time) {};
/**
* @param {number} pid
* @param {string|number} signal
*/
process.kill = function (pid, signal) {};
/**
* This is actually inherited from EventEmitter
* (===require('events')), but redefined here since
* closure-compiler won't let us require() that definition in an
* externs file.
* @param {string|symbol} event
* @param {function(...)} listener
*/
process.on = function(event, listener) {};
/**
* Also inherited from EventEmitter.
* @param {string|symbol} event
* @param {function(...)} listener
*/
process.once = function(event, listener) {};
/** @type {number} */
process.pid;
/** @type {string} */
process.platform;
/** @type {string} */
process.version;
/** @type {!Object} */
process.versions;
================================================
FILE: server/externs/path/package.json
================================================
{
"description": "Fake package.json for require('path')",
"main": "path.js",
"name": "path",
}
================================================
FILE: server/externs/path/path.js
================================================
/**
* @license
* Copyright 2018 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Fake implementation of node.js's fs module to satisfy
* Closure Compiler dependencies. This is mostly an excerpt from
* contrib/nodejs/fs.js from
* https://github.com/google/closure-compiler.git
* @author cpcallen@google.com (Christopher Allen)
*/
// TODO(cpcallen): Use official externs directly.
/** @const */
var path = {};
/**
* @param {string} path
* @return {string}
*/
path.dirname = function(path) {};
/**
* @param {string} path
* @return {string}
*/
path.extname = function(path) {};
/**
* @param {string} p
* @return {boolean}
*/
path.isAbsolute = function(p) {};
/**
* @param {...string} var_args
* @return {string}
*/
path.join = function(var_args) {};
/**
* @param {string} p
* @return {string}
*/
path.normalize = function(p) {};
module.exports = path;
================================================
FILE: server/externs/stream/package.json
================================================
{
"description": "Fake package.json for require('stream')",
"main": "stream.js",
"name": "stream",
}
================================================
FILE: server/externs/stream/stream.js
================================================
/**
* @license
* Copyright 2018 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Fake implementation of node.js's stream module to
* satisfy Closure Compiler dependencies. This is mostly an
* adaptation of contrib/nodejs/stream.js from
* https://github.com/google/closure-compiler.git
* @author cpcallen@google.com (Christopher Allen)
*/
// TODO(cpcallen): Use official externs directly.
var events = require('events');
var Buffer = require('buffer').Buffer;
/** @const */
var stream = {};
/**
* @constructor
* @struct
* @extends events.EventEmitter
* @param {Object=} options
*/
stream.Stream = function(options) {};
/**
* @param {stream.Writable} dest
* @param {{end: boolean}=} pipeOpts
* @return {stream.Writable}
*/
stream.Stream.prototype.pipe;
/**
* @constructor
* @struct
* @extends stream.Stream
* @param {Object=} options
*/
stream.Readable = function(options) {};
/**
* @type {boolean}
* @deprecated
*/
stream.Readable.prototype.readable;
/**
* @protected
* @param {string|Buffer|null} chunk
* @return {boolean}
*/
stream.Readable.prototype.push;
/**
* @param {string|Buffer|null} chunk
* @return {boolean}
*/
stream.Readable.prototype.unshift;
/**
* @param {string} enc
* @return {void}
*/
stream.Readable.prototype.setEncoding;
/**
* @param {number=} n
* @return {Buffer|string|null}
*/
stream.Readable.prototype.read;
/**
* @protected
* @param {number} n
* @return {void}
*/
stream.Readable.prototype._read;
/**
* @param {stream.Writable=} dest
* @return {stream.Readable}
*/
stream.Readable.prototype.unpipe;
/**
* @return {void}
*/
stream.Readable.prototype.resume;
/**
* @return {void}
*/
stream.Readable.prototype.pause;
/**
* @param {stream.Stream} stream
* @return {stream.Readable}
*/
stream.Readable.prototype.wrap;
/**
* @constructor
* @struct
* @extends stream.Readable
*/
stream.ReadableStream = function() {};
/**
* @type {boolean}
*/
stream.ReadableStream.prototype.readable;
/**
* @param {string=} encoding
* @return {void}
*/
stream.ReadableStream.prototype.setEncoding;
/**
* @return {void}
*/
stream.ReadableStream.prototype.destroy;
/**
* @constructor
* @struct
* @extends stream.Stream
* @param {Object=} options
*/
stream.Writable = function(options) {};
/**
* @deprecated
* @type {boolean}
*/
stream.Writable.prototype.writable;
/**
* @param {string|Buffer} chunk
* @param {string=} encoding
* @param {function(*=)=} cb
* @return {boolean}
*/
stream.Writable.prototype.write;
/**
* @protected
* @param {string|Buffer} chunk
* @param {string} encoding
* @param {function(*=)} cb
* @return {void}
*/
stream.Writable.prototype._write;
/**
* @param {string|Buffer=} chunk
* @param {string=} encoding
* @param {function(*=)=} cb
* @return {void}
*/
stream.Writable.prototype.end;
/**
* @constructor
* @struct
* @extends stream.Writable
*/
stream.WritableStream = function() {};
/**
* @return {void}
*/
stream.WritableStream.prototype.drain;
/**
* @type {boolean}
*/
stream.WritableStream.prototype.writable;
/**
* @param {string|Buffer} buffer
* @param {string=} encoding
* @return {void}
*/
stream.WritableStream.prototype.write;
/**
* @param {string|Buffer=} buffer
* @param {string=} encoding
* @param {function(*=)=} cb
* @return {void}
*/
stream.WritableStream.prototype.end;
/**
* @return {void}
*/
stream.WritableStream.prototype.destroy;
/**
* @return {void}
*/
stream.WritableStream.prototype.destroySoon;
/**
* @constructor
* @struct
* @extends stream.Readable
*/
stream.Duplex = function(options) {};
/**
* @type {boolean}
*/
stream.Duplex.prototype.allowHalfOpen;
/**
* @constructor
* @struct
* @extends stream.Duplex
* @param {Object=} options
*/
stream.Transform = function(options) {};
/**
* @protected
* @param {string|Buffer} chunk
* @param {string} encoding
* @param {function(*=)} cb
* @return {void}
*/
stream.Transform._transform;
/**
* @protected
* @param {function(*=)} cb
* @return {void}
*/
stream.Transform._flush;
/**
* @constructor
* @struct
* @extends stream.Transform
* @param {Object=} options
*/
stream.PassThrough = function(options) {};
module.exports = stream;
================================================
FILE: server/externs/tls/package.json
================================================
{
"description": "Fake package.json for require('tls')",
"main": "tls.js",
"name": "tls",
}
================================================
FILE: server/externs/tls/tls.js
================================================
/**
* @license
* Copyright 2018 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Fake implementation of node.js's tls module to
* satisfy Closure Compiler dependencies. This is mostly an
* excerpt of contrib/nodejs/tls.js from
* https://github.com/google/closure-compiler.git
* @author cpcallen@google.com (Christopher Allen)
*/
// TODO(cpcallen): Use official externs directly.
var Buffer = require('buffer').Buffer;
var events = require('events');
var net = require('net');
var stream = require('stream');
/**
* @const
*/
var tls = {};
/**
* @constructor
* @struct
* @extends stream.Stream
*/
tls.CreateOptions = function () {};
/** @type {boolean} */
tls.CreateOptions.prototype.honorCipherOrder;
/** @type {boolean} */
tls.CreateOptions.prototype.requestCert;
/** @type {boolean} */
tls.CreateOptions.prototype.rejectUnauthorized;
/** @type {Array|Buffer} */
tls.CreateOptions.prototype.NPNProtocols;
/** @type {function(string)} */
tls.CreateOptions.prototype.SNICallback;
/** @type {string} */
tls.CreateOptions.prototype.sessionIdContext;
/**
*
* @param {tls.CreateOptions} options
* @param {function(...)=} secureConnectionListener
* @return {tls.Server}
*/
tls.createServer;
/**
* @typedef {{host: string, port: number, socket: *, pfx: (string|Buffer), key: (string|Buffer), passphrase: string, cert: (string|Buffer), ca: Array., rejectUnauthorized: boolean, NPNProtocols: Array., servername: string}}
*/
tls.ConnectOptions;
/**
*
* @param {number|tls.ConnectOptions} port
* @param {(string|tls.ConnectOptions|function(...))=} host
* @param {(tls.ConnectOptions|function(...))=} options
* @param {function(...)=} callback
* @return {void}
*/
tls.connect = function(port, host, options, callback) {};
// Don't need this yet, and don't have externs for crypto yet.
// /**
// * @param {crypto.Credentials=} credentials
// * @param {boolean=} isServer
// * @param {boolean=} requestCert
// * @param {boolean=} rejectUnauthorized
// * @return {tls.SecurePair}
// */
// tls.createSecurePair;
/**
* @constructor
* @struct
* @extends events.EventEmitter
*/
tls.SecurePair = function() {};
/**
* @constructor
* @struct
* @extends net.Server
*/
tls.Server = function() {};
/**
* @param {string} hostname
* @param {string|Buffer} credentials
* @return {void}
*/
tls.Server.prototype.addContext = function(hostname, credentials) {};
/**
* @constructor
* @struct
* @extends stream.Duplex
*/
tls.CleartextStream = function() {};
/**
* @type {boolean}
*/
tls.CleartextStream.prototype.authorized;
/**
* @type {?string}
*/
tls.CleartextStream.prototype.authorizationError;
/**
* @return {Object.)>}
*/
tls.CleartextStream.prototype.getPeerCertificate;
/**
* @return {{name: string, version: string}}
*/
tls.CleartextStream.prototype.getCipher;
/**
* @return {{port: number, family: string, address: string}}
*/
tls.CleartextStream.prototype.address;
/**
* @type {string}
*/
tls.CleartextStream.prototype.remoteAddress;
/**
* @type {number}
*/
tls.CleartextStream.prototype.remotePort;
module.exports = tls;
================================================
FILE: server/externs/util/package.json
================================================
{
"description": "Fake package.json for require('util')",
"main": "util.js",
"name": "util",
}
================================================
FILE: server/externs/util/util.js
================================================
/**
* @license
* Copyright 2018 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Fake implementation of node.js's fs module to satisfy
* Closure Compiler dependencies. This is mostly an excerpt from
* contrib/nodejs/fs.js from
* https://github.com/google/closure-compiler.git
* @author cpcallen@google.com (Christopher Allen)
*/
// TODO(cpcallen): Use official externs directly.
/** @const */
var util = {};
/**
* @param {*} object
* @param {?util.inspect.Options=} options
* @return {string}
*/
util.inspect = function(object, options) {};
/**
* @const {symbol}
*/
util.inspect.custom;
/**
* @typedef {{showHidden: (boolean|undefined),
* depth: (number|null|undefined),
* colors: (boolean|undefined),
* customInspect: (boolean|undefined),
* showProxy: (boolean|undefined),
* maxArrayLength: (number|undefined),
* maxStringLength: (number|undefined),
* breakLength: (number|undefined),
* compact: (boolean|number|undefined),
* sorted: (boolean|!Function|undefined)}}
*/
util.inspect.Options;
/**
* @param {string} format
* @param {...*} var_args
* @return {string}
*/
util.format = function(format, var_args) {};
module.exports = util;
================================================
FILE: server/interpreter.js
================================================
/**
* @license
* Copyright 2013 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Interpreting JavaScript in JavaScript.
* @author fraser@google.com (Neil Fraser)
*/
'use strict';
var events = require('events');
var IterableWeakMap = require('./iterable_weakmap');
var net = require('net');
var http = require('http');
var https = require('https');
var parser = require('./parser');
var Registry = require('./registry');
var Node = parser.Node;
var Parser = parser.Parser;
/**
* Version number for the serialisation format. MUST be incremented
* when any change is made to the implementation of Interpreter and
* related classes (in this file and others) which would change how
* the runtime state is represented on disk.
* @type {number}
*/
var SERIALIZATION_VERSION = 1;
/**
* Create a new interpreter.
* @constructor
* @struct
* @param {!Interpreter.Options=} options
*/
var Interpreter = function(options) {
/** @type {!Interpreter.Options} */
this.options = options || {};
/**
* Serialisation version for this Interpreter instance. Will be set
* to SERIALIZATION_VERSION, but not here, because there exist .city
* files that have no .serlizationVersion in them, and loading one
* won't overwrite what we set here. Instead, set it in
* .preSerialize, and check in in .postDeserialize.
* @type {number|undefined}
*/
this.serializationVersion = undefined;
// Install .Object, .Function, etc.
this.installTypes();
/**
* Registry of builtins - e.g. Object, Function.prototype, Array.pop, etc.
* @const {!Registry}
*/
this.builtins = new Registry;
/**
* For cycle detection in Array.prototype.toString; see spec bug
* github.com/tc39/ecma262/issues/289. (Also used in
* Error.prototype.toString, which has same issue.) Since these
* functions are atomic (i.e., take place entirely within the
* duration of a single call to .step) and do not call user code
* which could suspend, it's fine that it's not per-Thread.
* @private @const {!Set}
*/
this.toStringVisited_ = new Set;
/**
* The interpreter's global scope.
* @const {!Interpreter.Scope}
*/
this.global = new Interpreter.Scope(Interpreter.Scope.Type.GLOBAL,
/** @type {?} */ (undefined), null, undefined);
// Declare properties that wil be initialised by initBuiltins_.
/** @type {!Interpreter.prototype.Object} */ this.OBJECT;
/** @type {!Interpreter.Owner} */ this.ROOT;
/** @type {!Interpreter.prototype.Function} */ this.FUNCTION;
/** @type {!Interpreter.prototype.Array} */ this.ARRAY;
/** @type {!Interpreter.prototype.Object} */ this.STRING;
/** @type {!Interpreter.prototype.Object} */ this.BOOLEAN;
/** @type {!Interpreter.prototype.Object} */ this.NUMBER;
/** @type {!Interpreter.prototype.Object} */ this.DATE;
/** @type {!Interpreter.prototype.Object} */ this.REGEXP;
/** @type {!Interpreter.prototype.Error} */ this.ERROR;
/** @type {!Interpreter.prototype.Error} */ this.EVAL_ERROR;
/** @type {!Interpreter.prototype.Error} */ this.RANGE_ERROR;
/** @type {!Interpreter.prototype.Error} */ this.REFERENCE_ERROR;
/** @type {!Interpreter.prototype.Error} */ this.SYNTAX_ERROR;
/** @type {!Interpreter.prototype.Error} */ this.TYPE_ERROR;
/** @type {!Interpreter.prototype.Error} */ this.URI_ERROR;
/** @type {!Interpreter.prototype.Error} */ this.PERM_ERROR;
/** @type {!Interpreter.prototype.Object} */ this.WEAKMAP;
/** @type {!Interpreter.prototype.Object} */ this.THREAD;
/** @type {!Interpreter.Owner} */ this.ANYBODY;
// Create builtins and (minimally) initialize global scope:
this.initBuiltins_();
/** @private @const {!Array} */
this.threads_ = [];
/** @private @type {?Interpreter.Thread} */
this.thread_ = null;
/** @private @type {number|undefined} */
this.threadTimeLimit_ = undefined;
/** @private (Type is whatever is returned by setTimeout()) */
this.runner_ = null;
/** @type {boolean} */
this.done = true; // True if no non-ZOMBIE threads exist.
// TODO(cpcallen): rename this to .listeners
/** @const {!Object} */
this.listeners_ = Object.create(null);
// TODO(cpcallen): This is an ugly hack to allow the serialiser to
// know the names of step functions in an otherwise-empty
// interpreter. Find a better way to do this.
/** @const {!Object} */
this.stepFuncs = stepFuncs_;
// Bring interpreter up to PAUSED status, setting up timers etc.
/** @type {!Interpreter.Status} */
this.status = Interpreter.Status.STOPPED;
/** @private @type {number} */
this.previousTime_ = 0;
/** @private @type {number} */
this.cumulativeTime_ = 0;
/** @private @type {!Array} */
this.hrStartTime_; // Initialised by pause.
this.pause();
};
/**
* Return a monotonically increasing count of milliseconds since this
* Interpreter was last brought to PAUSED or RUNNING status from
* STOPPED. This excludes time when Node was suspended by the host OS
* (say, because the machine was asleep).
* @return {number} Elapsed time in milliseconds.
*/
Interpreter.prototype.uptime = function() {
var t = process.hrtime(this.hrStartTime_);
return t[0] * 1000 + t[1] / 1000000;
};
/**
* Return a monotonically increasing count of milliseconds since this
* Interpreter instance was created. In the event of an interpreter
* being serialized / deserialized, this count will continue from
* where it left off before serialization.
* @return {number} Elapsed total time in milliseconds.
*/
Interpreter.prototype.now = function() {
return this.uptime() + this.previousTime_;
};
/**
* Create a new thread and add it to .threads_, and create a companion
* user-visible wrapper object and return it.
* @param {!Interpreter.Owner} owner Owner of new thread.
* @param {!Interpreter.State} state Initial state
* @param {number=} runAt Time at which thread should begin execution
* (default: now).
* @param {number=} timeLimit Maximum runtime without suspending (in ms).
* @return {!Interpreter.prototype.Thread} Userland Thread object.
*/
Interpreter.prototype.createThread = function(owner, state, runAt, timeLimit) {
var id = this.threads_.length;
var thread =
new Interpreter.Thread(id, state, runAt || this.now(), timeLimit);
this.threads_[this.threads_.length] = thread;
this.go_();
return new this.Thread(thread, owner);
};
/**
* Create a new thread to execute arbitrary JavaScript code. Thread
* will have specified owner, but code will be evaluated directly in
* global scope and will consequently runs wit whatever permissions
* the global scope has.
* @param {string} src JavaScript source code to parse and run.
* @param {number=} timeLimit Maximum runtime without suspending (in ms).
* @return {!Interpreter.prototype.Thread} Userland Thread object.
*/
Interpreter.prototype.createThreadForSrc = function(src, timeLimit) {
if (typeof src !== 'string') throw new TypeError('src must be a string');
if (this.options.trimProgram) {
src = src.trim();
}
var ast = this.compile_(src);
this.populateScope_(ast, this.global);
var state = new Interpreter.State(ast, this.global);
return this.createThread(this.ROOT, state, undefined, timeLimit);
};
/**
* Create a new thread to execute a particular function call.
* @param {!Interpreter.Owner} owner Owner of new thread; also becomes
* caller perms of function.
* @param {!Interpreter.prototype.Function} func Function to call.
* @param {?Interpreter.Value} thisVal value of 'this' in function call.
* @param {!Array} args Arguments to pass.
* @param {number=} runAt Time at which thread should begin execution
* (default: now).
* @param {number=} timeLimit Maximum runtime without suspending (in ms).
* @return {!Interpreter.prototype.Thread} Userland Thread object.
*/
Interpreter.prototype.createThreadForFuncCall = function(
owner, func, thisVal, args, runAt, timeLimit) {
var state = Interpreter.State.newForCall(func, thisVal, args, owner);
return this.createThread(owner, state, runAt, timeLimit);
};
/**
* Schedule the next runnable thread. Returns 0 if a READY thread
* successfuly scheduled (or if the current thread was already
* runnable, which can happen when interpreter has just been
* deserialised); otherwise returns earliest .runAt time
* amongst SLEEPING threads (if any), or Number.MAX_VALUE if there are
* none. If there are additionally no BLOCKED threads left (i.e.,
* there are no non-ZOMBIE theads at all) it will also set .done to
* true.
* @return {number} See description.
*/
Interpreter.prototype.schedule = function() {
if (this.thread_ && this.thread_.status === Interpreter.Thread.Status.READY) {
return 0; // Nothing to do. Don't reset .threadTimeLimit_!
}
var now = this.now();
var runAt = Number.MAX_VALUE;
var threads = this.threads_;
// Assume all remaining threads are ZOMBIEs until proven otherwise.
this.done = true;
this.thread_ = null;
// .threads_ will be very sparse, so use for-in loop.
for (var i in threads) {
i = Number(i); // Make Closure Compiler happy.
if (!threads.hasOwnProperty(i)) {
continue;
}
switch (threads[i].status) {
case Interpreter.Thread.Status.ZOMBIE:
// Remove zombie from threads.
delete threads[i];
continue;
case Interpreter.Thread.Status.BLOCKED:
// Ignore blocked threads except noting existence.
this.done = false;
continue;
case Interpreter.Thread.Status.SLEEPING:
if (threads[i].runAt > now) {
runAt = Math.min(runAt, threads[i].runAt);
this.done = false;
continue;
}
// Done sleeping; wake thread.
threads[i].status = Interpreter.Thread.Status.READY;
// fall through
case Interpreter.Thread.Status.READY:
// Is this this most-overdue thread found so far?
if (threads[i].runAt < runAt) {
this.thread_ = threads[i];
runAt = this.thread_.runAt;
}
this.done = false;
break;
default:
throw new Error('Unknown thread state');
}
}
this.threadTimeLimit_ = (this.thread_ && this.thread_.timeLimit) ?
now + this.thread_.timeLimit : undefined;
return runAt < now ? 0 : runAt;
};
/**
* Execute one step of the interpreter. Schedules the next runnable
* thread if required.
* @return {boolean} True if a step was executed, false if no more
* READY threads.
*/
Interpreter.prototype.step = function() {
/* NOTE: Beware that an async (user) Function might reject
* immediately, unwinding the stack before the Call step function
* returns.
*/
if (this.status !== Interpreter.Status.PAUSED) {
throw new Error('Can only step paused interpreter');
}
if (!this.thread_ ||
this.thread_.status !== Interpreter.Thread.Status.READY) {
if (this.schedule() > 0) {
return false;
}
}
if (!this.thread_) throw new Error('Scheduling failed'); // Satisfy compiler.
this.step_(this.thread_, this.thread_.stateStack_);
return true;
};
/**
* Execute the interpreter to program completion. Vulnerable to
* infinite loops. Alternates between waking any past-due SLEEPING
* threads and running the most-overdue READY thread until there are
* no more READY threads, then returns an integer as follows:
*
* - If there are SLEEPING threads, then a positive number that is the
* smallest .runAt value of any sleeping thread.
* - If there are no SLEEPING threads, but there are BLOCKED threads
* then a negative number is returned.
* - If only ZOMBIE threads remain, then zero is returned.
* @return {number} See description.
*/
Interpreter.prototype.run = function() {
/* NOTE: Beware that an async (user) Function might reject
* immediately, unwinding the stack before the Call step function
* returns.
*/
if (this.status === Interpreter.Status.STOPPED) {
throw new Error("Can't run stopped interpreter");
}
var t;
while ((t = this.schedule()) === 0) {
var thread = this.thread_;
var stack = thread.stateStack_;
while (thread.status === Interpreter.Thread.Status.READY) {
this.step_(thread, stack);
}
}
if (t === Number.MAX_VALUE) {
return this.done ? 0 : -1;
}
return t;
};
/**
* Actually execute one step of the interpreter. Presumes thread is
* the currently-scheduled thread, is runnable, etc.
* @private
* @param {!Interpreter.Thread} thread The current thread.
* @param {!Array} stack The current thread's state stack.
*/
Interpreter.prototype.step_ = function(thread, stack) {
var state = stack[stack.length - 1];
var node = state.node;
try {
var nextState = state.stepFunc.call(this, thread, stack, state, node);
} catch (e) {
this.throw_(thread, e, state.scope.perms);
nextState = undefined;
}
if (nextState) {
stack[stack.length] = nextState;
}
if (stack.length === 0) {
thread.status = Interpreter.Thread.Status.ZOMBIE;
}
};
/**
* If interpreter status is RUNNING, use setTimeout to arrange for
* .run() to be called repeatedly until there are no more sleeping
* threads.
* @private
*/
Interpreter.prototype.go_ = function() {
// Ignore calls to .go_ when PAUSED or STOPPED
if (this.status !== Interpreter.Status.RUNNING) {
return;
}
// Kill any existing runner and restart.
if (this.runner_) clearTimeout(this.runner_);
var intrp = this;
this.runner_ = setTimeout(function runner() {
// Invariant check: pausing or stopping interpreter should cancel
// timeout, so we should never get here while it is not RUNNING.
if (intrp.status !== Interpreter.Status.RUNNING) {
throw new Error('Un-cancelled runner on non-RUNNING interpreteter');
}
// N.B.: .run may indirectly call .go_ or even .pause or .stop
// (e.g. via native function calling .createThread, .pause, etc.).
var r = intrp.run();
if (intrp.runner_) {
// Clear any outstanding timeout. This might be the
// just-completed one that called this invocation of runner, but
// it might be a new one created by a reentrant call to .go_
// (e.g. via .run -> [native function] -> .createThread).
clearTimeout(intrp.runner_);
intrp.runner_ = null;
}
if (r > 0 && intrp.status === Interpreter.Status.RUNNING) {
// No more code to run right now, but there is an outstanding
// userland timeout, so set up a future reinvocation of runner
// when it's time for that to run.
intrp.runner_ = setTimeout(runner, r - intrp.now());
}
});
};
/**
* Set the interpreter status to RUNNING and kick it into action if
* there is anything to do.
*/
Interpreter.prototype.start = function() {
if (this.status !== Interpreter.Status.RUNNING) {
// Take care of STOPPED -> PAUSED transition if required.
this.pause();
}
this.status = Interpreter.Status.RUNNING;
this.go_();
};
/**
* Set the interpreter status to PAUSED. If it was previously
* STOPPED, begin listening on any listened ports. If it was
* previously RUNNING, ensure the interpreter takes no further action
* of its own.
*
* Call this function before serializing a RUNNING or PAUSED
* interpreter to ensure correct timer restoration when deserializing.
* (No need to call it if instance is already STOPPED.)
*/
Interpreter.prototype.pause = function() {
switch (this.status) {
case Interpreter.Status.RUNNING:
clearTimeout(this.runner_);
this.runner_ = null;
this.cumulativeTime_ = this.now(); // Save elapsed time.
break;
case Interpreter.Status.PAUSED:
// No state change; just update elapsed time.
this.cumulativeTime_ = this.now();
break;
case Interpreter.Status.STOPPED:
// Re-listen to any previously listened ports:
for (var port in this.listeners_) {
var intrp = this;
var server = this.listeners_[Number(port)];
server.listen(function(error) {
if (!error) return;
// Something went wrong while re-listening. Maybe port in use.
intrp.log('net', 'Re-listen on port %s failed: %s: %s', server.port,
error.name, error.message);
// Report this to userland by calling .onError on proto
// (with this === proto) - for lack of a better option.
if (!server.owner) return;
var func = server.proto.get('onError', server.owner);
if (!(func instanceof intrp.Function)) return;
var userError = intrp.errorNativeToPseudo(error, server.owner);
// TODO(cpcallen:perms): Is server.owner the correct owner
// for this thread? Note that this will typically be root,
// and .onError will therefore get caller perms === root,
// which is probably dangerous.
intrp.createThreadForFuncCall(
server.owner, func, server.proto, [userError],
undefined, server.timeLimit);
});
}
// Reset .uptime() to start counting from *NOW*, and .now() to
// continue from where it was before the interpreter was stopped.
this.previousTime_ = this.cumulativeTime_;
this.hrStartTime_ = process.hrtime();
}
this.status = Interpreter.Status.PAUSED;
};
/**
* Set the interpreter status to STOPPED, stop listening on any port
* (but do not close any open sockets), and ensure the interpreter
* takes no further action of its own.
*/
Interpreter.prototype.stop = function() {
if (this.status === Interpreter.Status.STOPPED) {
return;
}
// Do RUNNING -> PAUSED transition if required; update elapsed time.
this.pause();
// Unlisten to network sockets.
for (var port in this.listeners_) {
this.listeners_[Number(port)].unlisten();
}
this.status = Interpreter.Status.STOPPED;
};
/**
* Prepare an interpreter to be seralized.
*/
Interpreter.prototype.preSerialize = function() {
// As noted in constructor: set .seralizationVersion only just
// before serialising, so as to avoid mistaking old, un-versioned
// .city files for the current version.
this.serializationVersion = SERIALIZATION_VERSION;
};
/**
* Prepare an interpreter to run after being deseralized.
*/
Interpreter.prototype.postDeserialize = function() {
// Check to make sure deseralised interpreter is compatible with the
// current implementation.
if (this.serializationVersion !== SERIALIZATION_VERSION) {
throw new Error('version error: seralized interpreter was version ' +
this.serializationVersion + '; current version is ' +
SERIALIZATION_VERSION);
}
// Checkpointed interpreter was probably paused, but because we're
// restoring from a checkpoint the resurrected interpreter is
// actually stopped (i.e., with no listening sockets, and with
// questionable timer state information).
this.status = Interpreter.Status.STOPPED;
};
/**
* Convert source code into a ready-to-execute parse tree.
* @private
* @param {string} src The source code to be compiled.
* @param {!Interpreter.Owner=} perms Re-throw parse errors as
* user errors owned by perms. (Default: re-throw parse
* errors as internal (native) errors.)
* @return {!Node} node Root AST node.
*/
Interpreter.prototype.compile_ = function(src, perms) {
try {
var ast = Parser.parse(src);
} catch (e) { // Acorn threw a SyntaxError. Rethrow as a trappable error?
throw perms ? this.errorNativeToPseudo(e, perms) : e;
}
(function analyse(node) {
for (var name in node) { // Recursively analyse subtrees.
var prop = node[name];
if (prop && typeof prop !== 'object') continue;
if (Array.isArray(prop)) {
for (var i = 0; i < prop.length; i++) {
if (prop[i] && prop[i] instanceof Node) {
analyse(prop[i]);
}
}
} else {
if (prop instanceof Node) {
analyse(prop);
}
}
}
// Populate props on this node.
node['stepFunc'] = stepFuncs_[node['type']];
})(ast);
ast['source'] = new Interpreter.Source(src);
return ast;
};
/**
* Create and register the builtin classes and functions specified in
* the ECMAScript specification plus our extensions. Add a few items
* (e.g., eval) to the global scope that can't be added any other way.
* @private
*/
Interpreter.prototype.initBuiltins_ = function() {
// Initialize uneditable global properties.
this.global.createImmutableBinding('NaN', NaN);
this.global.createImmutableBinding('Infinity', Infinity);
this.global.createImmutableBinding('undefined', undefined);
// Create the objects which will become Object.prototype and
// Function.prototype, which are needed to bootstrap everything else.
this.OBJECT = new this.Object(null, null);
this.builtins.set('Object.prototype', this.OBJECT);
// Create the object that will own all of the system objects.
var root = new this.Object(null, this.OBJECT);
this.ROOT = /** @type {!Interpreter.Owner} */ (root);
this.builtins.set('CC.root', root);
this.global.perms = this.ROOT;
// Retroactively apply root ownership to Object.prototype:
this.OBJECT.owner = this.ROOT;
// NativeFunction constructor adds new function to the map of builtins.
this.FUNCTION = new this.NativeFunction({
id: 'Function.prototype', name: '', length: 0, proto: this.OBJECT,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {/* do nothing */}
});
// Initialize global objects.
this.initObject_();
this.initFunction_();
this.initArray_();
this.initString_();
this.initBoolean_();
this.initNumber_();
this.initDate_();
this.initRegExp_();
this.initError_();
this.initMath_();
this.initJSON_();
this.initWeakMap_();
this.initPerms_();
// Initialize ES standard global functions.
var eval_ = new this.NativeFunction({
id: 'eval', length: 1,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var code = args[0];
var perms = state.scope.perms;
if (intrp.options.trimEval) {
code = code.trim();
}
if (typeof code !== 'string') { // eval()
// Eval returns the argument if the argument is not a string.
// eval(Array) -> Array
return code;
}
var ast = intrp.compile_(code, perms);
// Change node type from Program to EvalProgram_.
ast['type'] = 'EvalProgram_';
ast['stepFunc'] = stepFuncs_['EvalProgram_'];
// Create new scope and update it with definitions in eval().
var outerScope = state.info_.directEval ? state.scope : intrp.global;
var scope =
new Interpreter.Scope(Interpreter.Scope.Type.EVAL, perms, outerScope);
intrp.populateScope_(ast, scope);
thread.stateStack_[thread.stateStack_.length] =
new Interpreter.State(ast, scope);
thread.value = undefined; // In case no ExpressionStatements evaluated.
return Interpreter.FunctionResult.AwaitValue;
}
});
// eval is a special case; it must be added to the global scope at
// startup time (rather than by a "var eval = new 'eval';" statement
// in es5.js) because assigning to eval is illegal in strict mode.
// This also means that it is effectively immutable despite being
// created with createMutableBinding.
this.global.createMutableBinding('eval', eval_);
this.createNativeFunction('isFinite', isFinite, false);
this.createNativeFunction('isNaN', isNaN, false);
this.createNativeFunction('parseFloat', parseFloat, false);
this.createNativeFunction('parseInt', parseInt, false);
var strFunctions = [
[escape, 'escape'], [unescape, 'unescape'],
[decodeURI, 'decodeURI'], [decodeURIComponent, 'decodeURIComponent'],
[encodeURI, 'encodeURI'], [encodeURIComponent, 'encodeURIComponent']
];
var intrp = this;
for (var i = 0; i < strFunctions.length; i++) {
var wrapper = (function(nativeFunc) {
return function(str) {
try {
return nativeFunc(str);
} catch (e) {
// decodeURI('%xy') will throw an error. Catch and rethrow.
throw intrp.errorNativeToPseudo(e, intrp.thread_.perms());
}
};
})(strFunctions[i][0]);
this.createNativeFunction(strFunctions[i][1], wrapper, false);
}
// Initialize CC-specific globals.
this.initThread_();
this.initNetwork_();
};
/**
* Initialize the Object class.
* @private
*/
Interpreter.prototype.initObject_ = function() {
// Object constructor.
new this.NativeFunction({
id: 'Object', length: 1,
/** @type {!Interpreter.NativeConstructImpl} */
construct: function(intrp, thread, state, args) {
var value = args[0];
if (value instanceof intrp.Object) {
return value;
} else if (typeof value === 'boolean' || typeof value === 'number' ||
typeof value === 'string') {
// No boxed primitives in Code City.
throw new intrp.Error(state.scope.perms, intrp.TYPE_ERROR,
'boxed primitives not supported');
} else if (value === undefined || value === null) {
return new intrp.Object(state.scope.perms);
} else {
throw new TypeError('Unknown value type??');
}
},
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
return this.construct.call(this, intrp, thread, state, args);
}
});
// Static methods on Object.
this.createNativeFunction('Object.is', Object.is, false);
new this.NativeFunction({
id: 'Object.getOwnPropertyNames', length: 1,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var perms = state.scope.perms;
// N.B.: we use ES6 definition; ES5.1 would throw TypeError if
// passed a non-object.
var obj = intrp.toObject(args[0], perms);
return intrp.createArrayFromList(obj.ownKeys(perms), perms);
}
});
new this.NativeFunction({
id: 'Object.keys', length: 1,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var perms = state.scope.perms;
var obj = intrp.toObject(args[0], perms);
var keys = obj.ownKeys(perms);
var enumerableKeys = [];
for (var i = 0; i < keys.length; i++) {
var key = keys[i];
var pd = obj.getOwnPropertyDescriptor(key, perms);
if (pd.enumerable) enumerableKeys.push(key);
}
return intrp.createArrayFromList(enumerableKeys, perms);
}
});
new this.NativeFunction({
id: 'Object.create', length: 2,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var proto = args[0];
// Support for the second argument is the responsibility of a polyfill.
if (proto === null) {
return new intrp.Object(state.scope.perms, null);
}
if (!(proto === null || proto instanceof intrp.Object)) {
throw new intrp.Error(state.scope.perms, intrp.TYPE_ERROR,
'Object prototype may only be an Object or null');
}
return new intrp.Object(state.scope.perms, proto);
}
});
new this.NativeFunction({
id: 'Object.defineProperty', length: 3,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var obj = args[0];
var key = args[1];
var attr = args[2];
var perms = state.scope.perms;
if (!(obj instanceof intrp.Object)) {
throw new intrp.Error(perms, intrp.TYPE_ERROR,
'Object.defineProperty called on non-object');
}
key = String(key);
if (!(attr instanceof intrp.Object)) {
throw new intrp.Error(perms, intrp.TYPE_ERROR,
'Property description must be an object');
}
// Can't just use pseudoToNative since descriptors can inherit properties.
var desc = new Descriptor;
if (attr.has('configurable', perms)) {
desc.configurable = Boolean(attr.get('configurable', perms));
}
if (attr.has('enumerable', perms)) {
desc.enumerable = Boolean(attr.get('enumerable', perms));
}
if (attr.has('writable', perms)) {
desc.writable = Boolean(attr.get('writable', perms));
}
if (attr.has('value', perms)) {
desc.value = attr.get('value', perms);
}
obj.defineProperty(key, desc, perms);
return obj;
}
});
new this.NativeFunction({
id: 'Object.getOwnPropertyDescriptor', length: 2,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var obj = args[0];
var prop = args[1];
var perms = state.scope.perms;
if (!(obj instanceof intrp.Object)) {
throw new intrp.Error(perms, intrp.TYPE_ERROR,
'Object.getOwnPropertyDescriptor called on non-object');
}
prop = String(prop);
var pd = obj.getOwnPropertyDescriptor(prop, perms);
if (!pd) {
return undefined;
}
var descriptor = new intrp.Object(perms);
descriptor.set('configurable', pd.configurable, perms);
descriptor.set('enumerable', pd.enumerable, perms);
descriptor.set('writable', pd.writable, perms);
descriptor.set('value', pd.value, perms);
return descriptor;
}
});
new this.NativeFunction({
id: 'Object.getPrototypeOf', length: 1,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
// N.B.: This conforms to ES6. ES5.1 would throw TypeError for
// Object.getPrototypeOf()
var o = intrp.toObject(args[0], state.scope.perms);
return o.proto;
}
});
new this.NativeFunction({
id: 'Object.setPrototypeOf', length: 2,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var obj = args[0];
var proto = args[1];
var perms = state.scope.perms;
if (obj === null || obj === undefined) {
throw new intrp.Error(perms, intrp.TYPE_ERROR,
'Object.setPrototypeOf called on null or undefined');
}
if (proto !== null && !(proto instanceof intrp.Object)) {
throw new intrp.Error(perms, intrp.TYPE_ERROR,
'Object prototype may only be an Object or null');
}
if (obj instanceof intrp.Object) {
// obj.setPrototypeOf handles security and circularity checks.
if (!obj.setPrototypeOf(proto, perms)) {
throw new intrp.Error(perms, intrp.TYPE_ERROR,
'setPrototypeOf failed');
}
}
return obj;
}
});
new this.NativeFunction({
id: 'Object.isExtensible', length: 1,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var obj = args[0];
if (!(obj instanceof intrp.Object)) {
return false; // ES6 §19.1.2.11. ES5.1 would throw TypeError.
}
return obj.isExtensible(state.scope.perms);
}
});
new this.NativeFunction({
id: 'Object.preventExtensions', length: 1,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var obj = args[0];
var perms = state.scope.perms;
if (!(obj instanceof intrp.Object)) {
return obj; // ES6 §19.1.2.15. ES5.1 would throw TypeError.
}
if (!obj.preventExtensions(perms)) {
// Can only happen once we have Proxy objects.
throw new intrp.Error(perms, intrp.TYPE_ERROR,
obj.toString() + " can't be made non-extensible.");
}
return obj;
}
});
// Properties of the Object prototype object.
this.createNativeFunction('Object.prototype.toString',
this.Object.prototype.toString, false);
this.createNativeFunction('Object.prototype.toLocaleString',
this.Object.prototype.toLocaleString, false);
this.createNativeFunction('Object.prototype.valueOf',
this.Object.prototype.valueOf, false);
new this.NativeFunction({
id: 'Object.prototype.hasOwnProperty', length: 1,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var key = args[0];
var perms = state.scope.perms;
var obj = intrp.toObject(thisVal, perms);
return Boolean(obj.getOwnPropertyDescriptor(String(key), perms));
}
});
new this.NativeFunction({
id: 'Object.prototype.propertyIsEnumerable', length: 1,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var key = String(args[0]);
var perms = state.scope.perms;
var obj = intrp.toObject(thisVal, perms);
var desc = obj.getOwnPropertyDescriptor(key, perms);
if (desc === undefined) {
return false;
}
return desc.enumerable;
}
});
new this.NativeFunction({
id: 'Object.prototype.isPrototypeOf', length: 1,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var v = args[0];
if (!(v instanceof intrp.Object)) return false;
var o = intrp.toObject(thisVal, state.scope.perms);
while (true) {
v = v.proto;
if (v === null) return false; // No parent; reached the top.
if (o === v) return true;
}
}
});
};
/**
* Initialize the Function class.
* @private
*/
Interpreter.prototype.initFunction_ = function() {
var intrp = this;
var wrapper;
// Function constructor.
new this.NativeFunction({
id: 'Function', length: 1,
/** @type {!Interpreter.NativeConstructImpl} */
construct: function(intrp, thread, state, args) {
args = args.slice(); // Copy, so we can .pop safely.
var body = args.length ? String(args.pop()) : '';
// Concatenate formal parameter names. Let Acorn verify they
// are valid Identifiers.
var argsStr = args.map(function(arg) {return String(arg);}).join(',');
// Acorn needs to parse body in the context of a function or
// else 'return' statements will be syntax errors. The name
// "anonymous" and extra line breaks were standardised in ES2019
// via https://tc39.es/Function-prototype-toString-revision/
var source = '(function anonymous(' + argsStr + '\n) {\n' + body + '\n})';
var ast = intrp.compile_(source, state.scope.perms);
if (ast['body'].length !== 1) {
// Function('a', 'return a + 6;}; {alert(1);');
// TODO: there must be a cleaner way to detect this!
throw new intrp.Error(state.scope.perms, intrp.SYNTAX_ERROR,
'Invalid code in function body');
}
// Interestingly, the scope for constructed functions is the global
// scope, even if they were constructed in some other scope.
return new intrp.UserFunction(ast['body'][0]['expression'],
intrp.global, new Interpreter.Source(source), state.scope.perms);
},
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
return this.construct.call(this, intrp, thread, state, args);
}
});
// Properties of the Function prototype object.
new this.NativeFunction({
id: 'Function.prototype.toString', length: 0,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var func = thisVal;
if (!(func instanceof intrp.Function)) {
throw new intrp.Error(state.scope.perms, intrp.TYPE_ERROR,
'Function.prototype.toString is not generic');
}
// TODO(cpcallen:perms): Perm check here? Or in toString?
return func.toString();
}
});
new this.NativeFunction({
id: 'Function.prototype.apply', length: 2,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var func = thisVal;
var thisArg = args[0];
var argArray = args[1];
var perms = state.scope.perms;
if (!(func instanceof intrp.Function)) {
throw new intrp.Error(perms, intrp.TYPE_ERROR,
func + ' is not a function');
} else if (argArray === null || argArray === undefined) {
var argList = [];
} else {
argList = intrp.createListFromArrayLike(argArray, perms);
}
// Rewrite state.info_, as a short-circuit optimisation in case
// we get called again due to FunctionResult.CallAgain, and also
// to produce more useful callers() output / stack traces.
var info = state.info_;
info.func = func;
info.this = thisArg;
info.args = argList;
info.construct = false;
// But just go and do the first .call directly.
return func.call(intrp, thread, state, thisArg, argList);
}
});
new this.NativeFunction({
id: 'Function.prototype.bind', length: 1,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var target = thisVal;
if (!(target instanceof intrp.Function)) {
throw new intrp.Error(state.scope.perms, intrp.TYPE_ERROR,
target + ' is not a function');
}
var thisArg = args[0];
var argList = args.slice(1);
var perms = state.scope.perms;
var f = new intrp.BoundFunction(target, thisArg, argList, perms);
var len = 0;
if (target.has('length', perms)) {
var targetLen = target.get('length', perms);
if (typeof targetLen === 'number') {
len = Math.max(0, targetLen - argList.length);
}
}
f.defineProperty('length', Descriptor.c.withValue(len), perms);
var targetName = target.get('name', perms);
if (typeof targetName !== 'string') {
targetName = '';
}
f.setName(targetName, 'bound');
return f;
}
});
new this.NativeFunction({
id: 'Function.prototype.call', length: 1,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var func = thisVal;
if (!(func instanceof intrp.Function)) {
throw new intrp.Error(state.scope.perms, intrp.TYPE_ERROR,
func + ' is not a function');
}
var thisArg = args[0];
var argList = args.slice(1);
// Rewrite state.info_, as a short-circuit optimisation in case
// we get called again due to FunctionResult.CallAgain, and also
// to produce more useful callers() output / stack traces.
var info = state.info_;
info.func = func;
info.this = thisArg;
info.args = argList;
info.construct = false;
// But just go and do the first .call directly.
return func.call(intrp, thread, state, thisArg, argList);
}
});
};
/**
* Initialize the Array class.
* @private
*/
Interpreter.prototype.initArray_ = function() {
// Array prototype.
this.ARRAY = new this.Array(this.ROOT, this.OBJECT);
this.builtins.set('Array.prototype', this.ARRAY);
// Array constructor.
new this.NativeFunction({
id: 'Array', length: 1,
/** @type {!Interpreter.NativeConstructImpl} */
construct: function(intrp, thread, state, args) {
var len = args[0];
var perms = state.scope.perms;
// TODO(ES6): Need to do GetPrototypeFromConstructor, ArrayCreate, etc.
var arr = new intrp.Array(perms);
if (args.length === 0) { // ES6 §22.1.1.1
// Nothing to do.
} else if (args.length === 1) {
if (typeof len !== 'number') {
arr.defineProperty('0', Descriptor.wec.withValue(len), perms);
var intLen = 1;
} else { // ES6 §22.1.1.2
intLen = Interpreter.toUint32(len);
if (intLen !== len) {
throw new intrp.Error(perms, intrp.RANGE_ERROR,
'Invalid array length');
}
}
arr.set('length', intLen, perms);
} else { // ES6 §22.1.1.3
arr.set('length', args.length, perms);
for (var k = 0; k < args.length; k++) {
arr.defineProperty(
String(k), Descriptor.wec.withValue(args[k]), perms);
}
}
return arr;
},
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
return this.construct.call(this, intrp, thread, state, args);
}
});
// Static methods on Array.
new this.NativeFunction({
id: 'Array.isArray', length: 1,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
return args[0] instanceof intrp.Array;
}
});
// Properties of the Array prototype object.
new this.NativeFunction({
id: 'Array.prototype.concat', length: 1,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var perms = state.scope.perms;
var obj = intrp.toObject(thisVal, perms);
var arr = new intrp.Array(perms);
var n = 0;
var doConcat = function(item) {
// TODO(ES6): IsConcatSpreadable?
if (item instanceof intrp.Array) { // Add elements of item.
var len = Interpreter.toLength(item.get('length', perms));
if (len + n > Number.MAX_SAFE_INTEGER) {
throw new intrp.Error(perms, intrp.TYPE_ERROR, 'Concatenating ' +
len + ' elements on an array-like of length ' + n +
' is disallowed, as the total surpasses 2**53-1');
}
for (var k = 0; k < len; n++, k++) {
var kP = String(k);
if (item.has(kP, perms)) {
arr.defineProperty(String(n),
Descriptor.wec.withValue(item.get(kP, perms)), perms);
}
}
} else { // Add item as single element, rather than spread.
if (n >= Number.MAX_SAFE_INTEGER) {
throw new intrp.Error(perms, intrp.TYPE_ERROR,
'Concatenating onto an array-like of length ' + n +
' is disallowed, as the total surpasses 2**53-1');
}
arr.defineProperty(
String(n++), Descriptor.wec.withValue(item), perms);
}
};
doConcat(thisVal);
for (var i = 0; i < args.length; i++) {
doConcat(args[i]);
}
arr.set('length', n, perms);
return arr;
}
});
new this.NativeFunction({
id: 'Array.prototype.includes', length: 1,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var searchElement = args[0];
var fromIndex = args[1];
var perms = state.scope.perms;
var obj = intrp.toObject(thisVal, perms);
var len = Interpreter.toLength(obj.get('length', perms));
if (len === 0) return false;
var n = (fromIndex === undefined ? 0 : Interpreter.toInteger(fromIndex));
if (n >= len) return false;
var k = (n >= 0) ? n : Math.max(len - Math.abs(n), 0);
for (; k < len; k++) {
if (obj.has(String(k), perms)) {
var v = obj.get(String(k), perms);
if (v === searchElement ||
(Number.isNaN(/** @type{?} */(v)) &&
Number.isNaN(/** @type{?} */(searchElement)))) {
return true;
}
}
}
return false;
}
});
new this.NativeFunction({
id: 'Array.prototype.indexOf', length: 1,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var searchElement = args[0];
var fromIndex = args[1];
var perms = state.scope.perms;
var obj = intrp.toObject(thisVal, perms);
var len = Interpreter.toLength(obj.get('length', perms));
if (len === 0) return -1;
var n = (fromIndex === undefined ? 0 : Interpreter.toInteger(fromIndex));
if (n >= len) return -1;
var k = (n >= 0) ? n : Math.max(len - Math.abs(n), 0);
for (; k < len; k++) {
if (obj.has(String(k), perms) &&
obj.get(String(k), perms) === searchElement) {
return k;
}
}
return -1;
}
});
new this.NativeFunction({
id: 'Array.prototype.lastIndexOf', length: 1,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var searchElement = args[0];
var fromIndex = args[1];
var perms = state.scope.perms;
var obj = intrp.toObject(thisVal, perms);
var len = Interpreter.toLength(obj.get('length', perms));
if (len === 0) return -1;
var n = (fromIndex === undefined) ? len - 1 :
Interpreter.toInteger(fromIndex);
var k = (n >= 0) ? Math.min(n, len - 1) : len - Math.abs(n);
for (; k >= 0 ; k--) {
if (obj.has(String(k), perms) &&
obj.get(String(k), perms) === searchElement) {
return k;
}
}
return -1;
}
});
new this.NativeFunction({
id: 'Array.prototype.pop', length: 0,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var perms = state.scope.perms;
var obj = intrp.toObject(thisVal, perms);
var len = Interpreter.toLength(obj.get('length', perms));
if (len === 0) {
obj.set('length', 0, perms);
return undefined;
}
var newLen = len - 1;
var element = obj.get(String(newLen), perms);
obj.deleteProperty(String(newLen), perms);
obj.set('length', newLen, perms);
return element;
}
});
new this.NativeFunction({
id: 'Array.prototype.push', length: 1,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var perms = state.scope.perms;
var obj = intrp.toObject(thisVal, perms);
var len = Interpreter.toLength(obj.get('length', perms));
var argCount = args.length;
if (len + args.length > Number.MAX_SAFE_INTEGER) {
throw new intrp.Error(perms, intrp.TYPE_ERROR, 'Pushing ' + argCount +
' elements on an array-like of length ' + len +
' is disallowed, as the total surpasses 2**53-1');
}
for (var i = 0; i < argCount; i++) {
obj.set(String(len++), args[i], perms);
}
obj.set('length', len, perms);
return len;
}
});
new this.NativeFunction({
id: 'Array.prototype.reverse', length: 0,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var perms = state.scope.perms;
var obj = intrp.toObject(thisVal, perms);
var len = Interpreter.toLength(obj.get('length', perms));
var middle = Math.floor(len / 2);
for (var lower = 0; lower < middle; lower++) {
var upper = len - lower - 1;
var upperP = String(upper);
var lowerP = String(lower);
var lowerExists = obj.has(lowerP, perms);
if (lowerExists) {
var lowerValue = obj.get(lowerP, perms);
}
var upperExists = obj.has(upperP, perms);
if (upperExists) {
var upperValue = obj.get(upperP, perms);
}
if (lowerExists && upperExists) {
obj.set(lowerP, upperValue, perms);
obj.set(upperP, lowerValue, perms);
} else if (!lowerExists && upperExists) {
obj.set(lowerP, upperValue, perms);
obj.deleteProperty(upperP, perms);
} else if (lowerExists && !upperExists) {
obj.deleteProperty(lowerP, perms);
obj.set(upperP, lowerValue, perms);
} // else neither exist, and no action required.
}
// ES spec would have us return obj, which would be a boxed
// primitive (Boolean, Number or String object) if thisVal was a
// number, boolean or the empty string. We decline to do that.
// (Note that nonempty strings will already have thrown
// TypeError due to non-writable properties.)
return thisVal;
}
});
new this.NativeFunction({
id: 'Array.prototype.shift', length: 0,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var perms = state.scope.perms;
var obj = intrp.toObject(thisVal, perms);
var len = Interpreter.toLength(obj.get('length', perms));
if (len === 0) {
obj.set('length', 0, perms);
return undefined;
}
var first = obj.get('0', perms);
for (var k = 1; k < len; k++) {
var from = String(k);
var to = String(k - 1);
if (obj.has(from, perms)) {
obj.set(to, obj.get(from, perms), perms);
} else {
obj.deleteProperty(to, perms);
}
}
obj.deleteProperty(String(len - 1), perms);
obj.set('length', len - 1, perms);
return first;
}
});
new this.NativeFunction({
id: 'Array.prototype.slice', length: 2,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var start = args[0];
var end = args[1];
var perms = state.scope.perms;
var obj = intrp.toObject(thisVal, perms);
var len = Interpreter.toLength(obj.get('length', perms));
var relativeStart = Interpreter.toInteger(start);
var k = (relativeStart < 0) ? Math.max(len + relativeStart, 0) :
Math.min(relativeStart, len);
var relativeEnd = (end === undefined) ? len : Interpreter.toInteger(end);
var final = (relativeEnd < 0) ? Math.max(len + relativeEnd, 0) :
Math.min(relativeEnd, len);
// TODO(cpcallen): ArraySpeciesCreate should take count as an argument.
// var count = Math.max(final - k, 0);
var arr = new intrp.Array(perms);
for (var n = 0; k < final; k++, n++) {
var kP = String(k);
if (obj.has(kP, perms)) {
arr.defineProperty(
String(n), Descriptor.wec.withValue(obj.get(kP, perms)), perms);
}
}
arr.set('length', n, perms);
return arr;
}
});
new this.NativeFunction({
id: 'Array.prototype.splice', length: 2,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var start = args[0];
var deleteCount = args[1];
var perms = state.scope.perms;
var obj = intrp.toObject(thisVal, perms);
var len = Interpreter.toLength(obj.get('length', perms));
var relativeStart = Interpreter.toInteger(start);
var actualStart = relativeStart < 0 ? Math.max(len + relativeStart, 0) :
Math.min(relativeStart, len);
if (args.length === 0) {
var insertCount = 0;
var actualDeleteCount = 0;
} else if (args.length === 1) {
insertCount = 0;
actualDeleteCount = len - actualStart;
} else {
insertCount = args.length - 2;
var dc = Interpreter.toInteger(deleteCount);
actualDeleteCount = Math.min(Math.max(dc, 0), len - actualStart);
}
if (len + insertCount - actualDeleteCount > Number.MAX_SAFE_INTEGER) {
throw new intrp.Error(perms, intrp.TYPE_ERROR, 'Splicing ' +
insertCount - actualDeleteCount +
' elements on an array-like of length ' + len +
' is disallowed, as the total surpasses 2**53-1');
}
var arr = new intrp.Array(perms);
for (var k = 0; k < actualDeleteCount; k++) {
var from = String(actualStart + k);
if (obj.has(from, perms)) {
arr.defineProperty(
String(k), Descriptor.wec.withValue(obj.get(from, perms)), perms);
}
}
arr.set('length', actualDeleteCount, perms);
var itemCount = Math.max(args.length - 2, 0);
if (itemCount < actualDeleteCount) {
for (k = actualStart; k < len - actualDeleteCount; k++) {
from = String(k + actualDeleteCount);
var to = String(k + itemCount);
if (obj.has(from, perms)) {
obj.set(to, obj.get(from, perms), perms);
} else {
obj.deleteProperty(to, perms);
}
}
for (k = len; k > len - actualDeleteCount + itemCount; k--) {
obj.deleteProperty(String(k - 1), perms);
}
} else if (itemCount > actualDeleteCount) {
for (k = len - actualDeleteCount; k > actualStart; k--) {
from = String(k + actualDeleteCount - 1);
to = String(k + itemCount - 1);
if (obj.has(from, perms)) {
obj.set(to, obj.get(from, perms), perms);
} else {
obj.deleteProperty(to, perms);
}
}
}
for (var j = 2, k = actualStart; j < args.length; j++, k++) {
obj.set(String(k), args[j], perms);
}
obj.set('length', len - actualDeleteCount + itemCount, perms);
return arr;
}
});
new this.NativeFunction({
id: 'Array.prototype.toString', length: 0,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var perms = state.scope.perms;
var obj = intrp.toObject(thisVal, perms);
var join = obj.get('join', perms);
if (join instanceof intrp.Function) {
var func = join;
} else {
func = /** @type {!Interpreter.prototype.Function} */ (
intrp.builtins.get('Object.prototype.toString'));
}
var newState = Interpreter.State.newForCall(func, thisVal, [], perms);
thread.stateStack_.push(newState);
return Interpreter.FunctionResult.AwaitValue;
}
});
new this.NativeFunction({
id: 'Array.prototype.unshift', length: 1,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var perms = state.scope.perms;
var obj = intrp.toObject(thisVal, perms);
var len = Interpreter.toLength(obj.get('length', perms));
var argCount = args.length;
if (argCount > 0) {
if (len + args.length > Number.MAX_SAFE_INTEGER) {
throw new intrp.Error(perms, intrp.TYPE_ERROR, 'Unshifting ' +
argCount + ' elements on an array-like of length ' + len +
' is disallowed, as the total surpasses 2**53-1');
}
for (var k = len; k > 0; k--) {
var from = String(k - 1);
var to = String(k);
if (obj.has(from, perms)) {
obj.set(to, obj.get(from, perms), perms);
} else {
obj.deleteProperty(to, perms);
}
}
for (var j = 0; j < argCount; j++) {
obj.set(String(j), args[j], perms);
}
}
obj.set('length', len + argCount, perms);
return len + argCount;
}
});
};
/**
* Initialize the String class.
* @private
*/
Interpreter.prototype.initString_ = function() {
var intrp = this;
var wrapper;
// String prototype. It's a String object (but the only one!)
this.STRING = new this.Object(this.ROOT);
this.builtins.set('String.prototype', this.STRING);
this.STRING.class = 'String';
// String constructor. ES6 §21.1.1.1.
new this.NativeFunction({
id: 'String', length: 1,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
// We don't handle symbols, so String(x) should just return
// ToString(x) (ES6 §7.1.12) if x is primitive, or
// ToString(ToPrimitive(x, hint String)) if not. Note that
// ToPrimitive (ES6 §7.1.1) is guaranteed to return a primitive
// or throw.
var value = args.length > 0 ? args[0] : '';
var perms = state.scope.perms;
if (!(value instanceof intrp.Object)) {
return String(value);
}
var step = Number(state.info_.funcState) || 0;
if (step > 0 && !(state.value instanceof intrp.Object)) {
// Call of .toString or .valueOf by previous visit returned a
// primitive. Convert to string and return.
return String(state.value);
}
switch(step) {
case 0: // Try calling toString.
var method = value.get('toString', perms);
if (method instanceof intrp.Function) {
thread.stateStack_[thread.stateStack_.length] =
Interpreter.State.newForCall(method, value, [], perms);
state.info_.funcState = 1;
return Interpreter.FunctionResult.CallAgain;
}
// FALL THROUGH
case 1: // toString call complete (or skipped); try calling valueOf.
method = value.get('valueOf', perms);
if (method instanceof intrp.Function) {
thread.stateStack_[thread.stateStack_.length] =
Interpreter.State.newForCall(method, value, [], perms);
state.info_.funcState = 2;
return Interpreter.FunctionResult.CallAgain;
}
// FALL THROUGH
case 2: // valueOf complete (or skipped); throw TypeError.
throw new intrp.Error(perms, intrp.TYPE_ERROR,
'Cannot convert object to primitive value');
default:
throw new Error('Invalid funcStep in String??');
}
},
/** @type {!Interpreter.NativeConstructImpl} */
construct: function(intrp, thread, state, args) {
throw new intrp.Error(state.scope.perms, intrp.TYPE_ERROR,
'String objects not supported.');
}
});
/**
* The thisStringValue specification method from ES6 §21.1.3.
* Converts value arg to string or throws TypeError.
* @param {!Interpreter} intrp The interpreter.
* @param {?Interpreter.Value} value The this value passed into function.
* @param {string} name Name of built-in function (for TypeError message).
* @param {!Interpreter.Owner} perms Who called built-in?
* @return {string}
*/
var thisStringValue = function(intrp, value, name, perms) {
if (typeof value === 'string') { // String primitive.
return value;
} else if (value === intrp.STRING) { // The only String object.
return '';
}
throw new intrp.Error(perms, intrp.TYPE_ERROR,
name + " requires that 'this' be a String");
};
// Static methods on String.
this.createNativeFunction('String.fromCharCode', String.fromCharCode, false);
// Properties of the String prototype object.
// Methods with exclusively primitive arguments.
var functions = ['charAt', 'charCodeAt', 'concat', 'endsWith', 'includes',
'indexOf', 'lastIndexOf', 'slice', 'startsWith', 'substr', 'substring',
'toLocaleLowerCase', 'toLocaleUpperCase', 'toLowerCase', 'toUpperCase',
'trim'];
for (var i = 0; i < functions.length; i++) {
this.createNativeFunction('String.prototype.' + functions[i],
String.prototype[functions[i]], false);
}
wrapper = function(compareString /*, locales, options*/) {
// Messing around with arguments so that function's length is 1.
var locales = arguments.length > 1 ?
intrp.pseudoToNative(arguments[1]) : undefined;
var options = arguments.length > 2 ?
intrp.pseudoToNative(arguments[2]) : undefined;
return this.localeCompare(compareString, locales, options);
};
this.createNativeFunction('String.prototype.localeCompare', wrapper, false);
wrapper = function(separator, limit) {
if (separator instanceof intrp.RegExp) {
separator = separator.regexp;
}
var jsList = this.split(separator, limit);
return intrp.createArrayFromList(jsList, intrp.thread_.perms());
};
this.createNativeFunction('String.prototype.split', wrapper, false);
wrapper = function(regexp) {
if (regexp instanceof intrp.RegExp) {
regexp = regexp.regexp;
}
var m = this.match(regexp);
return m && intrp.createArrayFromList(m, intrp.thread_.perms());
};
this.createNativeFunction('String.prototype.match', wrapper, false);
wrapper = function(regexp) {
if (regexp instanceof intrp.RegExp) {
regexp = regexp.regexp;
}
return this.search(regexp);
};
this.createNativeFunction('String.prototype.search', wrapper, false);
wrapper = function(substr, newSubstr) {
// Support for function replacements is the responsibility of a polyfill.
if (substr instanceof intrp.RegExp) {
substr = substr.regexp;
}
return String(this).replace(substr, newSubstr);
};
this.createNativeFunction('String.prototype.replace', wrapper, false);
wrapper = function(count) {
try {
return this.repeat(count);
} catch (e) {
// 'abc'.repeat(-1) will throw an error. Catch and rethrow.
throw intrp.errorNativeToPseudo(e, intrp.thread_.perms());
}
};
this.createNativeFunction('String.prototype.repeat', wrapper, false);
new this.NativeFunction({
id: 'String.prototype.toString', length: 0,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
return thisStringValue(intrp, thisVal,
'String.prototype.toString', state.scope.perms);
}
});
new this.NativeFunction({
id: 'String.prototype.valueOf', length: 0,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
return thisStringValue(intrp, thisVal,
'String.prototype.valueOf', state.scope.perms);
}
});
};
/**
* Initialize the Boolean class.
* @private
*/
Interpreter.prototype.initBoolean_ = function() {
// Boolean prototype. It's a Boolean object (but the only one!)
this.BOOLEAN = new this.Object(this.ROOT);
this.builtins.set('Boolean.prototype', this.BOOLEAN);
this.BOOLEAN.class = 'Boolean';
// Boolean constructor.
new this.NativeFunction({
id: 'Boolean', length: 1,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
return Boolean(args[0]);
},
/** @type {!Interpreter.NativeConstructImpl} */
construct: function(intrp, thread, state, args) {
throw new intrp.Error(state.scope.perms, intrp.TYPE_ERROR,
'Boolean objects not supported.');
}
});
/**
* The thisBooleanValue specification method from ES6 §19.3.3.
* Converts value arg to boolean or throws TypeError.
* @param {!Interpreter} intrp The interpreter.
* @param {?Interpreter.Value} value The this value passed into function.
* @param {string} name Name of built-in function (for TypeError message).
* @param {!Interpreter.Owner} perms Who called built-in?
* @return {boolean}
*/
var thisBooleanValue = function(intrp, value, name, perms) {
if (typeof value === 'boolean') { // Boolean primitive.
return value;
} else if (value === intrp.BOOLEAN) { // The only Boolen object.
return false;
}
throw new intrp.Error(perms, intrp.TYPE_ERROR,
name + " requires that 'this' be a Boolean");
};
// Instance methods on Boolean.
new this.NativeFunction({
id: 'Boolean.prototype.toString', length: 0,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
return String(thisBooleanValue(intrp, thisVal,
'Boolean.prototype.toString', state.scope.perms));
}
});
new this.NativeFunction({
id: 'Boolean.prototype.valueOf', length: 0,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
return thisBooleanValue(intrp, thisVal,
'Boolean.prototype.valueOf', state.scope.perms);
}
});
};
/**
* Initialize the Number class.
* @private
*/
Interpreter.prototype.initNumber_ = function() {
var intrp = this;
var wrapper;
// Number prototype. It's a Number object (but the only one!)
this.NUMBER = new this.Object(this.ROOT);
this.builtins.set('Number.prototype', this.NUMBER);
this.NUMBER.class = 'Number';
// Number constructor.
new this.NativeFunction({
id: 'Number', length: 1,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
return Number(args.length ? args[0] : 0);
},
/** @type {!Interpreter.NativeConstructImpl} */
construct: function(intrp, thread, state, args) {
throw new intrp.Error(state.scope.perms, intrp.TYPE_ERROR,
'Number objects not supported.');
}
});
/**
* The thisNumberValue specification method from ES6 §20.1.3.
* Converts value arg to number or throws TypeError.
* @param {!Interpreter} intrp The interpreter.
* @param {?Interpreter.Value} value The this value passed into function.
* @param {string} name Name of built-in function (for TypeError message).
* @param {!Interpreter.Owner} perms Who called built-in?
* @return {number}
*/
var thisNumberValue = function(intrp, value, name, perms) {
if (typeof value === 'number') { // Number primitive.
return value;
} else if (value === intrp.NUMBER) { // The only Boolen object.
return 0;
}
throw new intrp.Error(perms, intrp.TYPE_ERROR,
name + " requires that 'this' be a Number");
};
// Static methods on Number.
this.createNativeFunction('Number.isFinite', Number.isFinite, false);
this.createNativeFunction('Number.isInteger', Number.isInteger, false);
this.createNativeFunction('Number.isNaN', Number.isNaN, false);
this.createNativeFunction('Number.isSafeInteger', Number.isSafeInteger,
false);
// Properties of the Number prototype object.
wrapper = function(fractionDigits) {
try {
return this.toExponential(fractionDigits);
} catch (e) {
// Throws if fractionDigits isn't within 0-20.
throw intrp.errorNativeToPseudo(e, intrp.thread_.perms());
}
};
this.createNativeFunction('Number.prototype.toExponential', wrapper, false);
wrapper = function(digits) {
try {
return this.toFixed(digits);
} catch (e) {
// Throws if digits isn't within 0-20.
throw intrp.errorNativeToPseudo(e, intrp.thread_.perms());
}
};
this.createNativeFunction('Number.prototype.toFixed', wrapper, false);
wrapper = function(precision) {
try {
return this.toPrecision(precision);
} catch (e) {
// Throws if precision isn't within range (depends on implementation).
throw intrp.errorNativeToPseudo(e, intrp.thread_.perms());
}
};
this.createNativeFunction('Number.prototype.toPrecision', wrapper, false);
wrapper = function(/*locales, options*/) {
// Messing around with arguments so that function's length is 0.
var locales = arguments.length > 0 ?
intrp.pseudoToNative(arguments[0]) : undefined;
var options = arguments.length > 1 ?
intrp.pseudoToNative(arguments[1]) : undefined;
return this.toLocaleString(locales, options);
};
this.createNativeFunction('Number.prototype.toLocaleString', wrapper, false);
new this.NativeFunction({
id: 'Number.prototype.toString', length: 1,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var x = thisNumberValue(
intrp, thisVal, 'Number.prototype.toString', state.scope.perms);
var radix = args[0];
try {
// Throws if radix isn't within 2-36. Cast requried because
// Closure Compiler thinks radix should be a number.
return Number.prototype.toString.call(x, /** @type {?} */(radix));
} catch (e) {
throw intrp.errorNativeToPseudo(e, intrp.thread_.perms());
}
}
});
new this.NativeFunction({
id: 'Number.prototype.valueOf', length: 0,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
return thisNumberValue(intrp, thisVal,
'Number.prototype.valueOf', state.scope.perms);
}
});
};
/**
* Initialize the Date class.
* @private
*/
Interpreter.prototype.initDate_ = function() {
var intrp = this;
var wrapper;
// Date prototype. As of ES6 this is just an ordinary object. (In
// ES5 it had [[Class]] Date.)
this.DATE = new this.Object(this.ROOT);
this.builtins.set('Date.prototype', this.DATE);
// Date constructor.
wrapper = function(value, var_args) {
if (!intrp.calledWithNew()) {
// Called as Date().
// Calling Date() as a function returns a string, no arguments are heeded.
return Date();
}
// Called as new Date().
var args = [null].concat(Array.from(arguments));
var date = new (Function.prototype.bind.apply(Date, args))();
return new intrp.Date(date, intrp.thread_.perms());
};
this.createNativeFunction('Date', wrapper, true);
// Static methods on Date.
this.createNativeFunction('Date.now', Date.now, false);
this.createNativeFunction('Date.parse', Date.parse, false);
this.createNativeFunction('Date.UTC', Date.UTC, false);
// Instance methods on Date.
new this.NativeFunction({
id: 'Date.prototype.toString', length: 0,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var date = thisVal;
if (!(date instanceof intrp.Date)) {
throw new intrp.Error(state.scope.perms, intrp.TYPE_ERROR,
'Date.prototype.toString is not generic');
}
// TODO(cpcallen:perms): Perm check here? Or in toString?
return date.toString();
}
});
var functions = ['getDate', 'getDay', 'getFullYear', 'getHours',
'getMilliseconds', 'getMinutes', 'getMonth', 'getSeconds', 'getTime',
'getTimezoneOffset', 'getUTCDate', 'getUTCDay', 'getUTCFullYear',
'getUTCHours', 'getUTCMilliseconds', 'getUTCMinutes', 'getUTCMonth',
'getUTCSeconds', 'getYear',
'setDate', 'setFullYear', 'setHours', 'setMilliseconds',
'setMinutes', 'setMonth', 'setSeconds', 'setTime', 'setUTCDate',
'setUTCFullYear', 'setUTCHours', 'setUTCMilliseconds', 'setUTCMinutes',
'setUTCMonth', 'setUTCSeconds', 'setYear',
'toDateString', 'toISOString', 'toJSON', 'toGMTString',
'toTimeString', 'toUTCString'];
for (var i = 0; i < functions.length; i++) {
wrapper = (function(nativeFunc) {
return function(var_args) {
return this.date[nativeFunc].apply(this.date, arguments);
};
})(functions[i]);
this.createNativeFunction('Date.prototype.' + functions[i], wrapper, false);
}
functions = ['toLocaleDateString', 'toLocaleString', 'toLocaleTimeString'];
for (var i = 0; i < functions.length; i++) {
wrapper = (function(nativeFunc) {
return function(/*locales, options*/) {
// Messing around with arguments so that function's length is 0.
var locales = arguments.length > 0 ?
intrp.pseudoToNative(arguments[0]) : undefined;
var options = arguments.length > 1 ?
intrp.pseudoToNative(arguments[1]) : undefined;
return this.date[nativeFunc].call(this.date, locales, options);
};
})(functions[i]);
this.createNativeFunction('Date.prototype.' + functions[i], wrapper, false);
}
};
/**
* Initialize Regular Expression object.
* @private
*/
Interpreter.prototype.initRegExp_ = function() {
var intrp = this;
var wrapper;
// RegExp prototype. As of ES6 this is just an ordinary object.
// (In ES5 it had [[Class]] RegExp.)
this.REGEXP = new this.Object(this.ROOT);
this.builtins.set('RegExp.prototype', this.REGEXP);
// RegExp constructor.
new this.NativeFunction({
id: 'RegExp', length: 1,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var pattern = args[0];
var flags = args[1];
if (pattern instanceof intrp.RegExp && flags === undefined) {
// Per ES6 §21.2.3.1 step 4.b, (now
// https://tc39.es/ecma262/#sec-regexp-constructor step 2.b),
// check pattern.constructor to see if it's RegExp.
var patternConstructor = pattern.get('constructor', state.scope.perms);
if (patternConstructor === this) return pattern;
}
return this.construct.call(this, intrp, thread, state, args);
},
/** @type {!Interpreter.NativeConstructImpl} */
construct: function(intrp, thread, state, args) {
var pattern = args[0];
var flags = args[1];
var perms = state.scope.perms;
if (pattern instanceof intrp.RegExp) {
pattern = pattern.regexp.source;
// ES5.1 required that TypeError be thown here if flags !==
// undefined, but ES6 and later do not.
}
// TODO(ES6): ES6 §21.2.3.1 step 6 (now
// https://tc39.es/ecma262/#sec-regexp-constructor step 5).
pattern = (pattern === undefined ? '' : String(pattern));
flags = (flags === undefined ? '' : String(flags));
// TODO(ES6): also accept [uy]; ES8: [s], soon: [p].
if (!/^(?:([gim])(?!.*\1))*$/.test(flags)) { // Reject repeated flags.
throw new intrp.Error(perms, intrp.SYNTAX_ERROR,
"Invalid flags supplied to RegExp constructor '" + flags + "'");
}
return new intrp.RegExp(new RegExp(pattern, flags), perms);
}
});
new this.NativeFunction({
id: 'RegExp.prototype.toString', length: 0,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var regexp= thisVal;
if (!(regexp instanceof intrp.RegExp)) {
throw new intrp.Error(state.scope.perms, intrp.TYPE_ERROR,
'RegExp.prototype.toString is not generic');
}
// TODO(cpcallen:perms): Perm check here? Or in toString?
return regexp.toString();
}
});
wrapper = function(str) {
if (!(this instanceof intrp.RegExp) ||
!(this.regexp instanceof RegExp)) {
throw new intrp.Error(intrp.thread_.perms(), intrp.TYPE_ERROR,
'Method RegExp.prototype.exec called on incompatible receiver' +
this);
}
return this.regexp.test(str);
};
this.createNativeFunction('RegExp.prototype.test', wrapper, false);
wrapper = function(str) {
var perms = intrp.thread_.perms();
if (!(this instanceof intrp.RegExp)) {
throw new intrp.Error(perms, intrp.TYPE_ERROR,
'Method RegExp.prototype.exec called on incompatible receiver ' +
this);
}
str = String(str);
// Get lastIndex from wrapped regex, since this is settable.
this.regexp.lastIndex = this.get('lastIndex', perms);
var match = this.regexp.exec(str);
this.set('lastIndex', this.regexp.lastIndex, perms);
if (match) {
var result = new intrp.Array(perms);
for (var i = 0; i < match.length; i++) {
result.set(String(i), match[i], perms);
}
// match has additional properties.
result.set('index', match.index, perms);
result.set('input', match.input, perms);
return result;
}
return null;
};
this.createNativeFunction('RegExp.prototype.exec', wrapper, false);
};
/**
* Initialize the Error class.
* @private
*/
Interpreter.prototype.initError_ = function() {
var intrp = this;
var createErrorClass = function(name, protoKey) {
var protoproto = name === 'Error' ? intrp.OBJECT : intrp.ERROR;
var proto = new intrp.Error(intrp.ROOT, protoproto);
intrp.builtins.set(name + '.prototype', proto);
new intrp.NativeFunction({
id: name, name: name, length: 1,
/** @type {!Interpreter.NativeConstructImpl} */
construct: function(intrp, thread, state, args) {
var message = (args[0] === undefined) ? undefined : String(args[0]);
var perms = state.scope.perms;
// Use intrp[protoKey] instead of proto because
// deserialisation will set up intrp.ERROR et al correctly but
// can't modify values of variables in native closures.
/** @suppress {checkTypes} */
var err = new intrp.Error(perms, intrp[protoKey], message);
err.makeStack(thread.callers(perms).slice(1), perms);
return err;
},
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
return this.construct.call(this, intrp, thread, state, args);
}
});
return proto;
};
intrp.ERROR = createErrorClass('Error', 'ERROR'); // Must be first!
intrp.EVAL_ERROR = createErrorClass('EvalError', 'EVAL_ERROR');
intrp.RANGE_ERROR = createErrorClass('RangeError', 'RANGE_ERROR');
intrp.REFERENCE_ERROR = createErrorClass('ReferenceError', 'REFERENCE_ERROR');
intrp.SYNTAX_ERROR = createErrorClass('SyntaxError', 'SYNTAX_ERROR');
intrp.TYPE_ERROR = createErrorClass('TypeError', 'TYPE_ERROR');
intrp.URI_ERROR = createErrorClass('URIError', 'URI_ERROR');
intrp.PERM_ERROR = createErrorClass('PermissionError', 'PERM_ERROR');
this.createNativeFunction('Error.prototype.toString',
this.Error.prototype.toString, false);
};
/**
* Initialize Math object.
* @private
*/
Interpreter.prototype.initMath_ = function() {
var numFunctions = ['abs', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2',
'atanh', 'cbrt', 'ceil', 'clz32', 'cos', 'cosh', 'exp', 'expm1', 'floor',
'fround', 'hypot', 'imul', 'log', 'log10', 'log1p', 'log2', 'max', 'min',
'pow', 'random', 'round', 'sign', 'sin', 'sinh', 'sqrt', 'tan', 'tanh',
'trunc'];
for (var i = 0; i < numFunctions.length; i++) {
this.createNativeFunction('Math.' + numFunctions[i], Math[numFunctions[i]],
false);
}
};
/**
* Initialize JSON object.
* @private
*/
Interpreter.prototype.initJSON_ = function() {
var intrp = this;
var wrapper;
wrapper = function(text) {
try {
var nativeObj = JSON.parse(String(text));
} catch (e) {
throw intrp.errorNativeToPseudo(e, intrp.thread_.perms());
}
return intrp.nativeToPseudo(nativeObj, intrp.thread_.perms());
};
this.createNativeFunction('JSON.parse', wrapper, false);
wrapper = function(value, replacer, space) {
var nativeObj = intrp.pseudoToNative(value);
var perms = intrp.thread_.perms();
if (replacer instanceof intrp.Function) {
throw new intrp.Error(perms, intrp.TYPE_ERROR,
'Function replacer on JSON.stringify not supported');
} else if (replacer instanceof intrp.Array) {
replacer = intrp.createListFromArrayLike(replacer, perms);
replacer = replacer.filter(function(word) {
// Spec says we should also support boxed primitives here.
return typeof word === 'string' || typeof word === 'number';
});
} else {
replacer = null;
}
// Spec says we should also support boxed primitives here.
if (typeof space !== 'string' && typeof space !== 'number') {
space = undefined;
}
try {
var str = JSON.stringify(nativeObj, replacer, space);
} catch (e) {
throw intrp.errorNativeToPseudo(e, perms);
}
return str;
};
this.createNativeFunction('JSON.stringify', wrapper, false);
};
/**
* Initialize the WeakMap class.
* @private
*/
Interpreter.prototype.initWeakMap_ = function() {
// WeakMap prototype.
this.WEAKMAP = new this.Object(this.ROOT);
this.builtins.set('WeakMap.prototype', this.WEAKMAP);
// WeakMap constructor.
new this.NativeFunction({
id: 'WeakMap', length: 0, // N.B. length is correct; arg is optional!
/** @type {!Interpreter.NativeConstructImpl} */
construct: function(intrp, thread, state, args) {
// TODO(cpcallen): Support iterable argument to populate map.
return new intrp.WeakMap(state.scope.perms);
}
});
// Properties of the WeakMap prototype object.
/**
* A narrowing of Interpreter.NativeCallImpl for decorated WeakMap
* .call implementations.
* @typedef {function(this: Interpreter.prototype.NativeFunction,
* !Interpreter,
* !Interpreter.Thread,
* !Interpreter.State,
* !Interpreter.prototype.WeakMap,
* !Array)
* : (?Interpreter.Value|!Interpreter.FunctionResult)}
*/
var WeakMapCallImpl;
/**
* Decorator to add standard permission and type checks for WeakMap
* prototype methods.
* @param {!WeakMapCallImpl} func Function to decorate.
* @param {string=} name Name of decorated function (default:
* func.name). (N.B. needed because 'delete' is a reserve word.
* @return {!Interpreter.NativeCallImpl} The decorated function.)
*/
var withChecks = function(func, name) {
name = (name === undefined ? func.name : name);
return function call(intrp, thred, state, thisVal, args) {
// TODO(cpcallen:perms): add controls()-type and/or
// object-readability check(s) here.
if (!(thisVal instanceof intrp.WeakMap)) {
throw new intrp.Error(state.scope.perms, intrp.TYPE_ERROR,
'Method WeakMap.prototype.' + name +
' called on incompatible receiver ' + String(thisVal));
} else if (!(args[0] instanceof intrp.Object)) {
throw new intrp.Error(state.scope.perms, intrp.TYPE_ERROR,
'Invalid value used as weak map key');
}
return func.apply(this, arguments);
};
};
new this.NativeFunction({
id: 'WeakMap.prototype.delete', length: 1,
call: withChecks(function(intrp, thread, state, thisVal, args) {
return thisVal.weakMap.delete(args[0]);
}, 'delete')
});
new this.NativeFunction({
id: 'WeakMap.prototype.get', length: 1,
call: withChecks(function get(intrp, thread, state, thisVal, args) {
return thisVal.weakMap.get(args[0]);
})
});
new this.NativeFunction({
id: 'WeakMap.prototype.has', length: 1,
call: withChecks(function has(intrp, thread, state, thisVal, args) {
return thisVal.weakMap.has(args[0]);
})
});
new this.NativeFunction({
id: 'WeakMap.prototype.set', length: 2,
call: withChecks(function set(intrp, thread, state, thisVal, args) {
thisVal.weakMap.set(args[0], args[1]);
return thisVal;
})
});
};
/**
* Initialize the thread system API.
* @private
*/
Interpreter.prototype.initThread_ = function() {
// Thread prototype.
this.THREAD = new this.Object(this.ROOT);
this.builtins.set('Thread.prototype', this.THREAD);
/* Thread constructor. Usage:
*
* var thread = new Thread(func, delay, thisArg, ...args);
*
* - func is function to run in thread. (Maybe in future we will
* accept src to eval, but not for now.)
* - delay is time to wait (in ms) before starting thread.
* - thisArg is the 'this' value to use for the call (as if via .apply).
* - ...args are additional arguments to pass to func.
*/
new this.NativeFunction({
id: 'Thread', length: 1,
/** @type {!Interpreter.NativeConstructImpl} */
construct: function(intrp, thread, state, args) {
var func = args[0];
var delay = Number(args[1]) || 0;
var thisArg = args[2];
args = args.slice(3);
var perms = state.scope.perms;
if (!(func instanceof intrp.Function)) {
throw new intrp.Error(perms, intrp.TYPE_ERROR,
func + ' is not a function');
}
return intrp.createThreadForFuncCall(
perms, func, thisArg, args, intrp.now() + delay, thread.timeLimit);
}
});
new this.NativeFunction({
id: 'Thread.current', length: 0,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
return thread.wrapper;
}
});
new this.NativeFunction({
id: 'Thread.kill', length: 1,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var t = args[0];
var perms = state.scope.perms;
if (!(t instanceof intrp.Thread)) {
throw new intrp.Error(perms, intrp.TYPE_ERROR, t + ' is not a Thread');
}
// TODO(cpcallen:perms): add security check here.
var id = t.thread.id;
if (intrp.threads_[id]) {
intrp.threads_[id].status = Interpreter.Thread.Status.ZOMBIE;
}
}
});
new this.NativeFunction({
id: 'Thread.suspend', length: 1,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var delay = Number(args[0]) || 0;
if (delay < 0) {
delay = 0;
}
thread.runAt = intrp.now() + delay;
return Interpreter.FunctionResult.Sleep;
}
});
new this.NativeFunction({
id: 'Thread.callers', length: 0,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var perms = state.scope.perms;
var frames = thread.callers(state.scope.perms);
var callers = [];
for (var i = 1, frame; (frame = frames[i]); i++) {
var caller = new intrp.Object(perms);
// Copy properties of frame to caller.
for (var key in frame) {
if (!frame.hasOwnProperty(key)) continue;
var value = frame[key];
if (typeof value === 'function' || typeof value === 'object' &&
!(value instanceof intrp.Object) && value !== null) {
throw new TypeError('Unexpected native object');
}
caller.defineProperty(key, Descriptor.wec.withValue(value), perms);
}
callers.push(caller);
}
return intrp.createArrayFromList(callers, perms);
}
});
// Properties of the Thread prototype object.
/**
* A narrowing of Interpreter.NativeCallImpl for decorated Thread
* .call implementations.
* @typedef {function(this: Interpreter.prototype.NativeFunction,
* !Interpreter,
* !Interpreter.Thread,
* !Interpreter.State,
* !Interpreter.prototype.Thread,
* !Array)
* : (?Interpreter.Value|!Interpreter.FunctionResult)}
*/
var ThreadCallImpl;
/**
* Decorator to add standard permission and type checks for Thread
* prototype methods.
* @param {!ThreadCallImpl} func Function to decorate.
* @return {!Interpreter.NativeCallImpl} The decorated function.)
*/
var withChecks = function(func) {
name = (name === undefined) ? func.name : name;
return function call(intrp, thred, state, thisVal, args) {
// TODO(cpcallen:perms): add controls()-type and/or
// object-readability check(s) here.
if (!(thisVal instanceof intrp.Thread)) {
throw new intrp.Error(state.scope.perms, intrp.TYPE_ERROR,
'Method Thread.prototype.' + name +
' called on incompatible receiver ' + String(thisVal));
}
return func.apply(this, arguments);
};
};
new this.NativeFunction({
id: 'Thread.prototype.getTimeLimit', length: 0,
call: withChecks(function getTimeLimit(
intrp, thread, state, thisVal, args) {
return thisVal.thread.timeLimit;
})
});
// BUG(cpcallen): this only sets the time limit for future slices;
// until suspend is called the current Thread will run with its
// existing limit.
new this.NativeFunction({
id: 'Thread.prototype.setTimeLimit', length: 1,
call: withChecks(function setTimeLimit(
intrp, thread, state, thisVal, args) {
var limit = args[0];
var perms = state.scope.perms;
var old = thisVal.thread.timeLimit || Number.MAX_VALUE;
if (typeof limit !== 'number' || Number.isNaN(limit)) {
throw new intrp.Error(perms, intrp.TYPE_ERROR,
'new limit must be a number (and not NaN)');
} else if (limit <= 0) {
throw new intrp.Error(perms, intrp.RANGE_ERROR,
'new limit must be > 0');
} else if (limit > old) {
throw new intrp.Error(perms, intrp.RANGE_ERROR,
'new limit must be <= previous limit');
}
thisVal.thread.timeLimit = limit;
})
});
};
/**
* Initialize the permissions model API.
* @private
*/
Interpreter.prototype.initPerms_ = function() {
// Create object, never available to userland, to be used to
// rpresent the permissions of "a generic user" when such a thing is
// needed (e.g., for internal toString implementations, which have
// no information about caller perms but need to access properties
// on the object - something which can't be done with the null
// permissions).
var anybody = new this.Object(null, this.OBJECT);
this.ANYBODY = /** @type {!Interpreter.Owner} */ (anybody);
new this.NativeFunction({
id: 'perms', length: 0,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
return /** @type {!Interpreter.prototype.Object} */ (state.scope.perms);
}
});
new this.NativeFunction({
id: 'setPerms', length: 0,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var perms = args[0];
if (!(perms instanceof intrp.Object)) {
throw new intrp.Error(state.scope.perms, intrp.TYPE_ERROR,
'New perms must be an object');
}
// TODO(cpcallen:perms): throw if current perms does not
// control new perms.
state.scope.perms = /** @type {!Interpreter.Owner} */ (perms);
}
});
new this.NativeFunction({
id: 'Object.getOwnerOf', length: 0,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var obj = args[0];
if (!(obj instanceof intrp.Object)) {
throw new intrp.Error(state.scope.perms, intrp.TYPE_ERROR,
"Can't get owner of non-object");
}
return /** @type {?Interpreter.prototype.Object} */(obj.owner);
}
});
new this.NativeFunction({
id: 'Object.setOwnerOf', length: 0,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var obj = args[0];
var owner = args[1];
var perms = state.scope.perms;
if (!(obj instanceof intrp.Object)) {
throw new intrp.Error(perms, intrp.TYPE_ERROR,
"Can't set owner of non-object");
}
if (!(owner instanceof intrp.Object) && owner !== null) {
throw new intrp.Error(perms, intrp.TYPE_ERROR,
'New owner must be an object or null');
}
// TODO(cpcallen:perms): throw if current perms does not
// control obj and (new) owner.
obj.owner = /** @type {?Interpreter.Owner} */(owner);
return obj;
}
});
};
/**
* Initialize the networking subsystem API.
* @private
*/
Interpreter.prototype.initNetwork_ = function() {
new this.NativeFunction({
id: 'CC.connectionListen', length: 2,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var port = args[0];
var proto = args[1];
var timeLimit = Number(args[2]) || thread.timeLimit;
var perms = state.scope.perms;
if (port !== (port >>> 0) || port > 0xffff) {
throw new intrp.Error(perms, intrp.RANGE_ERROR, 'invalid port');
} else if (port in intrp.listeners_) {
throw new intrp.Error(perms, intrp.RANGE_ERROR,
'port already listened');
}
if (!(proto instanceof intrp.Object)) {
throw new intrp.Error(perms, intrp.TYPE_ERROR,
'prototype argument to connectionListen must be an object');
}
// TODO(cpcallen): do validity check on timeLimit. It should
// probaly not be larger than current limit (unless root).
var server = new intrp.Server(perms, port, proto, timeLimit);
intrp.listeners_[port] = server;
var rr = intrp.getResolveReject(thread, state);
server.listen(function(error) {
if (!error) {
rr.resolve();
} else {
rr.reject(intrp.errorNativeToPseudo(error, perms), perms);
}
});
return Interpreter.FunctionResult.Block;
}
});
new this.NativeFunction({
id: 'CC.connectionUnlisten', length: 1,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var port = args[0];
var perms = state.scope.perms;
if (port !== (port >>> 0) || port > 0xffff) {
throw new intrp.Error(perms, intrp.RANGE_ERROR, 'invalid port');
} else if (!(port in intrp.listeners_)) {
throw new intrp.Error(perms, intrp.RANGE_ERROR, 'port not listening');
}
if (!(intrp.listeners_[port].server_ instanceof net.Server)) {
throw new Error('no net.Serfer object for port %s??', port);
}
var rr = intrp.getResolveReject(thread, state);
intrp.listeners_[port].unlisten(function() {
// Socket (and all open connections on it) now closed.
delete intrp.listeners_[/** @type {number} */(port)];
rr.resolve();
});
return Interpreter.FunctionResult.Block;
}
});
new this.NativeFunction({
id: 'CC.connectionWrite', length: 2,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var obj = args[0];
var data = args[1];
if (!(obj instanceof intrp.Object) || !obj.socket) {
throw new intrp.Error(state.scope.perms, intrp.TYPE_ERROR,
'object is not connected');
} else if (typeof data !== 'string') {
throw new intrp.Error(state.scope.perms, intrp.TYPE_ERROR,
'data is not a string');
}
obj.socket.write(data);
}
});
new this.NativeFunction({
id: 'CC.connectionClose', length: 2,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var obj = args[0];
if (!(obj instanceof intrp.Object) || !obj.socket) {
throw new intrp.Error(state.scope.perms, intrp.TYPE_ERROR,
'object is not connected');
}
obj.socket.end();
}
});
new this.NativeFunction({
id: 'CC.xhr', length: 1,
/** @type {!Interpreter.NativeCallImpl} */
call: function(intrp, thread, state, thisVal, args) {
var url = String(args[0]);
var perms = state.scope.perms;
if (url.match(/^http:\/\//)) {
var req = http.get(url);
} else if (url.match(/^https:\/\//)) {
req = https.get(url);
} else {
throw new intrp.Error(perms, intrp.SYNTAX_ERROR,
'Unrecognized URL "' + url + '"');
}
intrp.log('net', 'XHR for %s: connect', url);
var rr = intrp.getResolveReject(thread, state);
req.on('response', function(res) {
intrp.log('net', 'XHR for %s: response', url);
if (res.statusCode !== 200) {
var err = new intrp.Error(perms, intrp.ERROR,
'HTTP request failed: ' + res.statusCode + ' ' +
res.statusMessage);
err.set('statusCode', Number(res.statusCode), perms);
err.set('statusMessage', String(res.statusMessage), perms);
res.resume();
rr.reject(err, perms);
return;
}
var body = '';
res.on('data', function(data) {
body += String(data);
});
res.on('end', function() {
intrp.log('net', 'XHR for %s: end', url);
rr.resolve(body);
});
}).on('error', function(e) {
intrp.log('net', 'XHR for %s: %s', url, e);
rr.reject(intrp.errorNativeToPseudo(e, perms), perms);
});
return Interpreter.FunctionResult.Block;
}
});
};
/**
* The ToInteger function from ES6 §7.1.4. The abstract operation
* ToInteger converts argument to an integral numeric value.
* @param {?Interpreter.Value} value
* @return {number} An integer if the value can be converted to such;
* 0 otherwise.
*/
Interpreter.toInteger = function toInteger(value) {
var number = Number(value);
if (isNaN(number)) {
return 0;
} else if (number === 0 || !isFinite(number)) {
return number;
}
return Math.trunc(number);
};
/**
* The ToUint32 function from ES6 §7.1.6. The abstract operation
* ToUint32 converts argument to one of 2**32 integer values in the
* range 0 through 2**32−1, inclusive.
* @param {?Interpreter.Value} value
* @return {number} A non-negative integer less than 2**32.
*/
Interpreter.toUint32 = function toUint32(value) {
return Interpreter.toInteger(value) >>> 0;
};
/**
* The ToLength function from ES6 §7.1.15. Note that this does NOT
* enforce the actual array length limit of 2**32-1, but deals with
* lengths up to 2**53-1, which is correct for the polymorphic
* Array.prototype methods.
* @param {?Interpreter.Value} value
* @return {number} A non-negative integer less than 2**53.
*/
Interpreter.toLength = function toLength(value) {
var len = Interpreter.toInteger(value);
if (len <= 0) return 0;
return Math.min(len, Number.MAX_SAFE_INTEGER); // Handles len === Infinity.
};
/**
* Create a new native function. Function will be owned by root.
* @param {string} id ID to register new function in builtins registry.
* @param {!Function} nativeFunc Any JavaScript function.
* @param {boolean} legalConstructor True if the function can be used as a
* constructor (e.g. Array), false if not (e.g. escape).
* @return {!Interpreter.prototype.Function} New function.
*/
Interpreter.prototype.createNativeFunction = function(
id, nativeFunc, legalConstructor) {
if (nativeFunc instanceof this.Object) {
throw new TypeError('createNativeFunction passed non-native function??');
}
// Make sure impl function has an id for serialization.
if (!nativeFunc.id) nativeFunc.id = id;
return new this.OldNativeFunction(nativeFunc, legalConstructor, {id: id});
};
/**
* Converts from a native JS object or value to a JS interpreter
* object. Can handle JSON-style values plus regexps and errors (of
* all standard native types), and handles additional properties on
* arrays, regexps and errors (just as for plain objects). Ignores
* prototype and inherited properties. Efficiently handles
* sparse arrays. Does NOT handle cyclic structures.
* @param {*} nativeObj The native JS object to be converted.
* @return {?Interpreter.Value} The equivalent JS interpreter object.
* @param {!Interpreter.Owner} owner Owner for new object.
*/
Interpreter.prototype.nativeToPseudo = function(nativeObj, owner) {
if ((typeof nativeObj !== 'object' && typeof nativeObj !== 'function') ||
nativeObj === null) {
// It's a primitive; just return it.
return /** @type {boolean|number|string|undefined|null} */ (nativeObj);
} else if (nativeObj instanceof this.Object) {
throw new TypeError('nativeToPseudo called on a pseudo-object??');
}
var pseudoObj;
switch (Object.prototype.toString.apply(nativeObj)) {
case '[object Array]':
pseudoObj = new this.Array(owner);
break;
case '[object RegExp]':
pseudoObj = new this.RegExp(/** @type {!RegExp} */(nativeObj), owner);
break;
case '[object Error]':
var proto;
if (nativeObj instanceof EvalError) {
proto = this.EVAL_ERROR;
} else if (nativeObj instanceof RangeError) {
proto = this.RANGE_ERROR;
} else if (nativeObj instanceof ReferenceError) {
proto = this.REFERENCE_ERROR;
} else if (nativeObj instanceof SyntaxError) {
proto = this.SYNTAX_ERROR;
} else if (nativeObj instanceof TypeError) {
proto = this.TYPE_ERROR;
} else if (nativeObj instanceof URIError) {
proto = this.URI_ERROR;
} else {
proto = this.ERROR;
}
pseudoObj = new this.Error(owner, proto);
break;
default:
pseudoObj = new this.Object(owner);
}
// Cast to satisfy type-checker; it might be a lie: nativeObj could
// be an object (i.e., non-primitive) but not an Object (i.e.,
// inherits from Object.prototype). Fortunately we don't care.
var keys = Object.getOwnPropertyNames(/** @type {!Object} */(nativeObj));
for (var i = 0; i < keys.length; i++) {
var key = keys[i];
var desc = Object.getOwnPropertyDescriptor(nativeObj, key);
var pd = new Descriptor(desc.writable, desc.enumerable, desc.configurable);
pd.value = this.nativeToPseudo(desc.value, owner);
pseudoObj.defineProperty(key, pd, owner);
}
return pseudoObj;
};
/**
* Converts from a JS interpreter object to native JS object.
* Can handle JSON-style values, plus cycles.
*
* TODO(cpcallen): Audit this to ensure that it can safely accept any
* user object (especially because it is used by our implementations
* of JSON.stringify, String.prototype.localeCompare, etc.)
*
* TODO(cpcallen:perms): Audit all callers of this to ensure that they
* do not allow circumvention of access control.
* @param {?Interpreter.Value} pseudoObj The JS interpreter object to
* be converted.
* @param {!Object=} cycles Cycle detection (used only in recursive calls).
* @return {*} The equivalent native JS object or value.
*/
Interpreter.prototype.pseudoToNative = function(pseudoObj, cycles) {
// BUG(cpcallen:perms): Kludge. Incorrect except when doing .step
// or run. Should be an argument instead, forcing caller to decide.
try {
var perms = this.thread_.perms();
} catch (e) {
perms = this.ROOT;
}
if (typeof pseudoObj === 'boolean' ||
typeof pseudoObj === 'number' ||
typeof pseudoObj === 'string' ||
pseudoObj === null || pseudoObj === undefined) {
// It's a primitive; just return it.
return pseudoObj;
} else if (!(pseudoObj instanceof this.Object)) {
throw new TypeError('pseudoToObject called on wrong type??');
} else if (pseudoObj instanceof this.RegExp) { // Regular expression.
return pseudoObj.regexp;
} else if (pseudoObj instanceof this.Function) { // Function.
return undefined;
}
if (!cycles) {
cycles = {pseudo: [], native: []};
}
var i = cycles.pseudo.indexOf(pseudoObj);
if (i !== -1) {
return cycles.native[i];
}
cycles.pseudo[cycles.pseudo.length] = pseudoObj;
var nativeObj = pseudoObj instanceof this.Array ? [] : {};
cycles.native[cycles.native.length] = nativeObj;
var keys = pseudoObj.ownKeys(perms);
for (i = 0; i < keys.length; i++) {
var key = keys[i];
var pd = pseudoObj.getOwnPropertyDescriptor(key, perms);
Object.defineProperty(nativeObj, key, {
writable: pd.writable,
enumerable: pd.enumerable,
configurable: pd.configurable,
value: this.pseudoToNative(pd.value, cycles)
});
}
cycles.pseudo.pop();
cycles.native.pop();
return nativeObj;
};
/**
* CreateArrayFromList from ES6 §7.3.16
*
* Converts from a native array to an Interpreter.prototype.Array.
* Does NOT recursively convert the type of the array's contents.
* @param {!Array} elements The native array to be
* converted.
* @param {!Interpreter.Owner} owner Owner for new object.
* @return {!Interpreter.prototype.Array} The equivalent interpreter array.
*/
Interpreter.prototype.createArrayFromList = function(elements, owner) {
if (!Array.isArray(elements) || (elements instanceof this.Object)) {
throw new TypeError('CreateArrayFromList called on wrong type??');
}
var array = new this.Array(owner);
for (var n = 0; n < elements.length; n++) {
array.defineProperty(
String(n), Descriptor.wec.withValue(elements[n]), owner);
}
return array;
};
/**
* CreateListFromArrayLike from ES6 §7.3.17.
*
* This function converts from an Interpreter.prototype.Array (or
* array-like I.p.Object) to a native array. This is an evolution of
* the algorithm from ES5.1 §15.3.4.3 (Function.prototype.apply). It
* does NOT recursively convert the type of the array's contents.
*
* TODO(ES6): Add elementTypes param and associated type checks.
* @param {?Interpreter.Value} obj The interpreter array or array-like
* object to be converted. Error thrown if non-object.
* @param {!Interpreter.Owner} perms Who is trying convert it?
* @return {!Array} The equivalent native JS array.
*/
Interpreter.prototype.createListFromArrayLike = function(obj, perms) {
if (!(obj instanceof this.Object)) {
throw new this.Error(perms, this.TYPE_ERROR,
'CreateListFromArrayLike called on non-object');
}
var len = Interpreter.toLength(obj.get('length', perms));
var list = [];
for (var i = 0; i < len; i++) {
list[i] = obj.get(String(i), perms);
}
return list;
};
/**
* Converts from a native Error to a JS interpreter Error. Unlike
* pseudoToNative, this fucntion only converts type and .message.
* @param {!Error} err Native Error value to be converted.
* @param {?Interpreter.Owner} owner Owner for new (pseudo) Error object.
* @return {!Interpreter.prototype.Error}
*/
Interpreter.prototype.errorNativeToPseudo = function(err, owner) {
var proto;
if (err instanceof this.Object) {
throw new TypeError('errorNativeToPseudo called on wrong type??');
}
if (err instanceof EvalError) {
proto = this.EVAL_ERROR;
} else if (err instanceof RangeError) {
proto = this.RANGE_ERROR;
} else if (err instanceof ReferenceError) {
proto = this.REFERENCE_ERROR;
} else if (err instanceof SyntaxError) {
proto = this.SYNTAX_ERROR;
} else if (err instanceof TypeError) {
proto = this.TYPE_ERROR;
} else if (err instanceof URIError) {
proto = this.URI_ERROR;
} else {
proto = this.ERROR;
}
return new this.Error(owner, proto, err.message);
};
/**
* Implements the ToObject specification method from ES5.1 §9.9 / ES6
* §7.1.13, but returning temporary Box objects instead of boxed
* Boolean, Number or String instances.
* @param {?Interpreter.Value} value The value to be converted to an Object.
* @param {!Interpreter.Owner} perms Who is trying convert it?
* @return {!Interpreter.ObjectLike}
*/
Interpreter.prototype.toObject = function(value, perms) {
if (value === null || value === undefined) {
throw new this.Error(perms, this.TYPE_ERROR,
"Can't convert " + value + ' to Object');
} else if (typeof value === 'boolean' || typeof value === 'number' ||
typeof value === 'string') {
return new this.Box(value);
}
return value;
};
/**
* Retrieves a value from the scope chain.
* @param {!Interpreter.Scope} scope Scope to read from.
* @param {string} name Name of variable.
* @return {?Interpreter.Value} Value (may be undefined).
*/
Interpreter.prototype.getValueFromScope = function(scope, name) {
for (var s = scope; s; s = s.outerScope) {
if (name in s.vars) {
return s.vars[name];
}
}
throw new this.Error(this.thread_.perms(), this.REFERENCE_ERROR,
name + ' is not defined');
};
/**
* Sets a value to the current scope.
* @param {!Interpreter.Scope} scope Scope to write to.
* @param {string} name Name of variable.
* @param {?Interpreter.Value} value Value.
*/
Interpreter.prototype.setValueToScope = function(scope, name, value) {
for (var s = scope; s; s = s.outerScope) {
if (name in s.vars) {
try {
s.vars[name] = value;
} catch (e) { // Trying to set immutable binding.
// TODO(cpcallen:perms): we have a scope here, but scope.perms
// is probably not the right value for owner of new error.
throw new this.Error(this.thread_.perms(), this.TYPE_ERROR,
'Assignment to constant variable ' + name);
}
return;
}
}
throw new this.Error(this.thread_.perms(), this.REFERENCE_ERROR,
name + ' is not defined');
};
/**
* Populate a scope with declarations from given node.
* @param {!Node} node AST node (program or function).
* @param {!Interpreter.Scope} scope Scope dictionary to populate.
* @param {!Interpreter.Source=} source Original source code. If not
* supplied, will use node['source'] instead.
* @private
*/
Interpreter.prototype.populateScope_ = function(node, scope, source) {
if (!source) {
if (!node['source']) throw new Error('Source not found');
source = node['source'];
}
// Obtain list of bound names for node. We cache this on the AST
// node to save time when repeatedly calling the same function.
var boundNames = getBoundNames(node);
for (var name in boundNames) {
var boundValue = boundNames[name];
var value = boundValue ?
new this.UserFunction(boundValue, scope, source, scope.perms)
: undefined;
if (!scope.hasBinding(name)) scope.createMutableBinding(name, value);
if (value) this.setValueToScope(scope, name, value);
}
};
/**
* Is the current state directly being called with as a construction with 'new'.
* @return {boolean} True if 'new foo()', false if 'foo()'.
*/
Interpreter.prototype.calledWithNew = function() {
return this.thread_.stateStack_[this.thread_.stateStack_.length - 1]
.info_.construct;
};
/**
* Implements IsUnresolvableReference from ES5 §8.7 / ES6 §6.2.3.
* @param {!Interpreter.Scope} scope Current scope dictionary.
* @param {!Array} ref Reference tuple.
* @param {!Interpreter.Owner} perms Who is trying to get it?
* @return {boolean} True iff refernece is unresolvable.
*/
Interpreter.prototype.isUnresolvableReference = function(scope, ref, perms) {
// Property references never unresolvable.
return ref[0] === null;
};
/**
* Gets the value of a referenced name from the scope or object referred to.
* @param {!Array} ref Reference tuple.
* @param {!Interpreter.Owner} perms Who is trying to get it?
* @return {?Interpreter.Value} Value (may be undefined).
*/
Interpreter.prototype.getValue = function(ref, perms) {
var base = ref[0];
var name = ref[1];
if (base === null) { // Unresolvable reference.
throw new this.Error(perms, this.REFERENCE_ERROR, name + ' is not defined');
} else if (base instanceof Interpreter.Scope) { // An environment reference.
return base.get(name);
} else { // A property reference.
return this.toObject(base, perms).get(name, perms);
}
};
/**
* Sets value of a referenced name to the scope or object referred to.
* @param {!Array} ref Reference tuple.
* @param {?Interpreter.Value} value Value.
* @param {!Interpreter.Owner} perms Who is trying to set it?
*/
Interpreter.prototype.setValue = function(ref, value, perms) {
var base = ref[0];
var name = ref[1];
if (base === null) { // Unresolvable reference.
throw new this.Error(perms, this.REFERENCE_ERROR, name + ' is not defined');
} else if (base instanceof Interpreter.Scope) { // An environment reference.
var err = base.set(name, value);
if (err) {
throw this.errorNativeToPseudo(err, perms);
}
} else { // A property reference.
this.toObject(ref[0], perms).set(name, value, perms);
}
};
/**
* Check to see if the current thread has run too long. Called at the
* top of loops and before making function calls.
* @private
* @param {!Interpreter.Owner} perms Perm to use to create Error object.
*/
Interpreter.prototype.checkTimeLimit_ = function(perms) {
if (this.threadTimeLimit_ && this.now() > this.threadTimeLimit_) {
throw new this.Error(perms, this.RANGE_ERROR, 'Thread ran too long');
}
};
/**
* Carry out the mechanics of throwing an exception.
*
* This is intended only to be called from exception handlers in
* .step() and .run(), and from async function's reject() callback.
* Elsewhere, just throw.
* @param {!Interpreter.Thread} thread in which throw is occurring.
* @param {?Interpreter.Value} e Exception being thrown.
* @param {!Interpreter.Owner} perms Perm to use to obtain (e.g.)
* function names, etc.
*/
Interpreter.prototype.throw_ = function(thread, e, perms) {
if (e instanceof this.Error) {
// Userland Error object thrown; make sure it has a .stack.
// BUG(cpcallen): this will set .stack on Error.prototype, etc.
e.makeStack(thread.callers(perms), perms);
} else if (e instanceof Error) {
// Uh oh. This is an internal error in the interpreter. Kill
// thread and rethrow.
thread.status = Interpreter.Thread.Status.ZOMBIE;
throw e;
} else if (!(e instanceof this.Object) && e !== null &&
(typeof e === 'object' || typeof e === 'function')) {
// WTF: not a native exception, not an interpreter object and not
// a primitive, but just some random (internal) object.
throw new TypeError('Unexpected exception value ' + String(e));
}
this.unwind_(thread, Interpreter.CompletionType.THROW, e, undefined);
};
/**
* Unwind the stack to the innermost relevant enclosing TryStatement,
* For/ForIn/WhileStatement or Call. If this results in
* the stack being completely unwound the thread will be terminated
* and an appropriate error being logged.
*
* N.B. Normally unwind should be called from the current stack frame
* (i.e., do NOT do stack.pop() before calling unwind) because the
* target label of a break statement can be the statement itself
* (e.g., `foo: break foo;`).
* @private
* @param {!Interpreter.Thread} thread The thread whose stack is to be unwound.
* @param {!Interpreter.CompletionType} type Completion type.
* @param {?Interpreter.Value=} value Value computed, returned or thrown.
* @param {string=} label Target label for break or return.
*/
Interpreter.prototype.unwind_ = function(thread, type, value, label) {
if (type === Interpreter.CompletionType.NORMAL) {
throw new TypeError('Should not unwind for NORMAL completions');
}
for (var stack = thread.stateStack_; stack.length > 0; stack.pop()) {
var state = stack[stack.length - 1];
switch (state.node['type']) {
case 'TryStatement':
state.info_ = {type: type, value: value, label: label};
return;
case 'Call':
switch (type) {
case Interpreter.CompletionType.BREAK:
case Interpreter.CompletionType.CONTINUE:
throw new Error('Unsynatctic break/continue not rejected by Acorn');
case Interpreter.CompletionType.RETURN:
state.value = value;
return;
}
break;
}
if (type === Interpreter.CompletionType.BREAK) {
if (label ? (state.labels && state.labels.includes(label)) :
(state.isLoop || state.isSwitch)) {
// Top of stack is now target of break. But we are breaking
// out of this statement, so pop to discard it.
stack.pop();
return;
}
} else if (type === Interpreter.CompletionType.CONTINUE) {
if (label ? (state.labels && state.labels.includes(label)) :
state.isLoop) {
return;
}
}
}
// Unhandled completion. Terminate thread.
thread.status = Interpreter.Thread.Status.ZOMBIE;
if (type === Interpreter.CompletionType.THROW) {
// Log exception and stack trace.
if (value instanceof this.Error) {
this.log('unhandled', 'Unhandled %s', value);
var stackTrace = value.get('stack', this.ROOT);
if (stackTrace) {
this.log('unhandled', stackTrace);
}
} else {
var native = this.pseudoToNative(value);
this.log('unhandled', 'Unhandled exception with value: %o', native);
}
} else {
throw new Error('Unsynatctic break/continue/return not rejected by Acorn');
}
};
/**
* Get a {resovle, reject} tuple for the specified thread and state,
* which is presumed to be about to block on an async function call.
*
* The resolve function takes a single argument and, when called, will
* unblock the thread and save its argument in state.value.
*
* The reject function takes a single argument and, when called, will
* unblock the thread and unwind the stack as if its argument had been
* thrown.
*
* Only one of these may be called, and only once, or an internal
* Error will be thrown.
* @param {!Interpreter.Thread} thread The thread to be controlled.
* @param {!Interpreter.State} state The state in which thread to block.
* @return {{resolve: function(?Interpreter.Value=):void,
* reject: function(?Interpreter.Value, !Interpreter.Owner):void}}
*/
Interpreter.prototype.getResolveReject = function(thread, state) {
var /** boolean */ done = false;
/**
* Throw an internal error if previously invoked or if the thread
* does not appear to be in a plausible state.
*/
var check = function() {
if (done) {
throw new Error('Async resolved or rejected more than once??');
}
done = true;
if (thread.status !== Interpreter.Thread.Status.BLOCKED ||
thread.stateStack_[thread.stateStack_.length - 1] !== state) {
throw new Error('Thread state corrupt at async resolve/reject??');
}
};
var intrp = this;
return {
resolve: function resolve(value) {
check();
state.value = value;
thread.status = Interpreter.Thread.Status.READY;
intrp.go_();
},
reject: function reject(value, perms) {
check();
thread.status = Interpreter.Thread.Status.READY;
intrp.throw_(thread, value, perms);
intrp.go_();
}
};
};
/**
* Log something.
* @param {string} category About what topic is this log?
* @param {...*} var_args
*/
Interpreter.prototype.log = function(category, var_args) {
if (this.options.noLog && this.options.noLog.includes(category)) {
return;
}
console.log.apply(console, Array.prototype.slice.call(arguments, 1));
};
///////////////////////////////////////////////////////////////////////////////
// Nested types & constants (not fully-fledged classes)
///////////////////////////////////////////////////////////////////////////////
/**
* The Completion Specification Type, from ES5.1 §8.9
* @typedef {{type: Interpreter.CompletionType,
* value: ?Interpreter.Value,
* label: (string|undefined)}}
*/
Interpreter.Completion;
/**
* Completion Value Types.
* @enum {number}
*/
Interpreter.CompletionType = {
NORMAL: 0,
BREAK: 1,
CONTINUE: 2,
RETURN: 3,
THROW: 4
};
/**
* Special sentinel values returned by the call or construct method of
* a (pseudo)Function to indicate that a return value is not
* immediately available (e.g., in the case of a user function that
* needs to be evaluated, or an async function that blocks).
* @constructor
* @struct
*/
Interpreter.FunctionResult = function() {};
/**
* Please evaluate whatever state(s) have been pushed onto the stack,
* and use their completion value as the return value of the function.
* @const
*/
Interpreter.FunctionResult.AwaitValue = new Interpreter.FunctionResult;
/**
* Please mark this thread as blocked awaiting eternal event (e.g.,
* async callback).
* @const
*/
Interpreter.FunctionResult.Block = new Interpreter.FunctionResult;
/**
* Please invoke .call or .construct again the next time this state is
* encountered.
* @const
*/
Interpreter.FunctionResult.CallAgain = new Interpreter.FunctionResult;
/**
* Please mark this thread as sleeping until its .runAt time.
* @const
*/
Interpreter.FunctionResult.Sleep = new Interpreter.FunctionResult;
/**
* Options object for Interpreter constructor.
* @typedef {{
* noLog: (!Array|undefined),
* trimEval: (boolean|undefined),
* trimProgram: (boolean|undefined),
* stackLimit: (number|undefined),
* }}
*/
Interpreter.Options;
/**
* Interpreter statuses.
* @enum {number}
*/
Interpreter.Status = {
/**
* Won't run code. Any listening sockets are unlistened. No time
* passes (as measured by .uptime() and .now(), which underly
* setTimeout etc.)
*/
STOPPED: 0,
/**
* Will run code *only* if .step() or .run() is called. Will listen
* on network sockets (including re-listening on any that were
* unlistened because the interpreter was stopped). Time will pass
* (as measured by .uptime() and .now()).
*/
PAUSED: 1,
/**
* Will run code automatically in response to thread creation,
* timeouts and network activity.
*/
RUNNING: 2
};
///////////////////////////////////////////////////////////////////////////////
// Nested (but not fully inner) classes: Scope, State, Thread, etc.
///////////////////////////////////////////////////////////////////////////////
/**
* Typedef for the functions used to implement NativeFunction.call.
* @typedef {function(this: Interpreter.prototype.NativeFunction,
* !Interpreter,
* !Interpreter.Thread,
* !Interpreter.State,
* ?Interpreter.Value,
* !Array)
* : (?Interpreter.Value|!Interpreter.FunctionResult)}
*/
Interpreter.NativeCallImpl;
/**
* Typedef for the functions used to implement NativeFunction.construct.
* @typedef {function(this: Interpreter.prototype.NativeFunction,
* !Interpreter,
* !Interpreter.Thread,
* !Interpreter.State,
* !Array)
* : (?Interpreter.Value|!Interpreter.FunctionResult)}
*/
Interpreter.NativeConstructImpl;
/**
* An iterator over the properties of an ObjectLike and its
* prototypes, following the usual for-in loop rules.
* @constructor
* @struct
* @param {!Interpreter.ObjectLike} obj Object or Box whose properties
* are to be iterated over.
* @param {!Interpreter.Owner} perms Who is doing the iteration?
*/
Interpreter.PropertyIterator = function(obj, perms) {
if (obj === undefined) { // Deserializing
return;
}
/** @private @type {?Interpreter.ObjectLike} */
this.obj_ = obj;
/** @private @const {!Interpreter.Owner} */
this.perms_ = perms;
/** @private @type {!Array} */
this.keys_ = this.obj_.ownKeys(this.perms_);
/** @private @type {number} */
this.i_ = 0;
/** @private @const {!Set} */
this.visited_ = new Set();
};
/**
* Return the next key in the iteration, skipping non-enumerable keys
* or keys already seen earlier in the prototype chain (even if they
* were non-enumerable). Returns undefined when iteration is done.
* @return {string|undefined}
*/
Interpreter.PropertyIterator.prototype.next = function() {
while (true) {
if (this.i_ >= this.keys_.length) {
this.obj_ = this.obj_.proto;
if (this.obj_ === null) {
// Done iteration.
return undefined;
}
this.keys_ = this.obj_.ownKeys(this.perms_);
this.i_ = 0;
}
var key = this.keys_[this.i_++];
var pd = this.obj_.getOwnPropertyDescriptor(key, this.perms_);
// Skip deleted or already-visited properties.
if (!pd || this.visited_.has(key)) {
continue;
}
this.visited_.add(key);
if (pd.enumerable) {
return key;
}
}
};
/**
* Class for a scope. Implements Lexical Environments and the
* Environment Record specification type from E5.1 §10.2 / ES6 §8.1.
* @constructor
* @struct
* @param {!Interpreter.Scope.Type} type What variety of scope is it?
* @param {!Interpreter.Owner} perms The permissions with which code
* in the current scope is executing.
* @param {?Interpreter.Scope} outerScope The enclosing scope ("outer
* lexical environment reference", in ECMAScript spec parlance)
* @param {?Interpreter.Value=} thisVal Value of 'this' in scope.
* (Default: copy value from outerScope. N.B.: passing undefined
* is NOT treated the same as passing no value!)
*/
Interpreter.Scope = function(type, perms, outerScope, thisVal) {
/** @type {!Interpreter.Scope.Type} */
this.type = type;
/** @type {!Interpreter.Owner} */
this.perms = perms;
/** @type {?Interpreter.Scope} */
this.outerScope = outerScope;
/** @type {?Interpreter.Value} */
this.this = (outerScope && arguments.length < 4) ? outerScope.this : thisVal;
/** @const {!Object} */
this.vars = Object.create(null);
};
/**
* Returns true iff this scope has a binding for the given name.
*
* Based on HasBinding for declarative environment records,
* from ES5.1 §10.2.1.1.1 / ES6 §8.1.1.1.1.
* @param {string} name Name of variable.
* @return {boolean} True iff name is bound in this scope.
*/
Interpreter.Scope.prototype.hasBinding = function(name) {
return name in this.vars;
};
/**
* Returns true iff this scope has an immutable binding for the given
* name.
*
* @param {string} name Name of variable.
* @return {boolean} True iff name is immutably bound in this scope.
*/
Interpreter.Scope.prototype.hasImmutableBinding = function(name) {
var pd = Object.getOwnPropertyDescriptor(this.vars, name);
return Boolean(pd && !pd.writable);
};
/**
* Creates a mutable binding in this scope and initialises it to
* undefined or the provided value.
*
* Based on CreateMutableBinding for declarative environment records,
* from ES5.1 §10.2.1.1.2 / ES6 §8.1.1.1.2.
* @param {string} name Name of variable.
* @param {?Interpreter.Value=} value Initial value (default: undefined).
*/
Interpreter.Scope.prototype.createMutableBinding = function(name, value) {
if (name in this.vars) {
throw new Error(name + ' already has binding in this scope??');
}
this.vars[name] = value;
};
/**
* Creates an immutable binding in this scope and initialises it
* to the provided value.
*
* Based on CreateImmutableBinding for declarative environment records,
* from ES5.1 §10.2.1.1.7 / ES6 §8.1.1.1.3.
* @param {string} name Name of variable.
* @param {?Interpreter.Value} value Initial value.
*/
Interpreter.Scope.prototype.createImmutableBinding = function(name, value) {
if (name in this.vars) {
throw new Error(name + ' already has binding in this scope??');
}
Object.defineProperty(this.vars, name, Descriptor.ec.withValue(value));
};
/**
* Updates a mutable binding in this scope to the the provided value.
*
* Based on SetMutableBinding for declarative environment records,
* from ES5.1 §10.2.1.1.3 / ES6 §8.1.1.1.5.
* @param {string} name Name of variable.
* @param {?Interpreter.Value} value New value to set it to.
* @return {!Error|undefined} If an error occurs, a (native) Error
* object is returned. It shoud be converted into a user error
* (e.g., by errorNativeToPseudo) and thrown. (This is done
* because Scope is not an inner class of interpreter, and thus
* this method has no access to the Error constructor or error
* prototypes.)
*/
Interpreter.Scope.prototype.set = function(name, value) {
try {
this.vars[name] = value;
} catch (e) { // Trying to set immutable binding.
return TypeError('Assignment to constant variable ' + name);
}
};
/**
* Returns the value of a binding in this scope.
*
* Based on GetBindingValue for declarative environment records, from
* ES5.1 §10.2.1.1.4 / ES6 §8.1.1.1.6.
* @param {string} name Name of variable.
* @return {?Interpreter.Value} The current value of the named variable
* in this scope.
*/
Interpreter.Scope.prototype.get = function(name) {
return this.vars[name];
};
/**
* Searches through this scope and its outer scopes to find a binding
* for name, and returns the scope containing that binding or null if
* name is not bound.
*
* Based on the Identifier Resolution algorithm of ES5.1 §10.3.1, or
* equivalently the ResolveBinding specification function from ES6
* §8.3.1.
* @param {string} name Name of variable.
* @return {?Interpreter.Scope} The scope that binds name, or null if none.
*/
Interpreter.Scope.prototype.resolve = function(name) {
for (var s = this; s; s = s.outerScope) {
if (name in s.vars) return s;
}
return null;
};
/**
* Scope types. These correspond roughly to the list of environment
* record types in ES6 §8.1.1 (declarative, object, function, global),
* but omit ones we do not use (e.g., object), and distinguish between
* different uses of declarative environment records (e.g., for
* binding the name of a named function expression vs. binding the
* name of the exception in a catch clause).
* @enum {string}
*/
Interpreter.Scope.Type = {
/** The global scope. */
GLOBAL: 'global',
/** A function invocation scope. */
FUNCTION: 'function',
/** A scope to contain the name of a named function expression. */
FUNEXP: 'funexp',
/** An eval body scope. */
EVAL: 'eval',
/** A catch clause scope. */
CATCH: 'catch',
/** For use as a dummy - e.g. the caller scope in createThreadForFuncCall */
DUMMY: 'dummy',
};
/**
* Source is an encapsulated hunk of source text. Source objects can
* be sliced to obtain a Source object representing a substring of the
* original source text. Such sliced objects "remember" their
* position within the original source text.
* @constructor
* @struct
* @param {string} src Some source text
* @param {number=} offset_ For internal use only.
*/
Interpreter.Source = function(src, offset_) {
if (src === undefined) return; // Deserializing.
/** @private @type {string} */
this.src_ = src;
/** @private @type {number} */
this.offset_ = offset_ || 0;
Object.freeze(this);
};
/**
* Return the contents of a Source object as an ordinary string.
* @return {string}
*/
Interpreter.Source.prototype.toString = function() {
return this.src_;
};
/**
* Return a Source object representing a substring of this Source
* object.
* @param {number} start Offset of first character of slice, as an absolute
* position within the original source text.
* @param {number} end Offset of character following last character of
* slice, as an absolute position within the original source text.
* @return {!Interpreter.Source} The sliced source.
*/
Interpreter.Source.prototype.slice = function(start, end) {
if (start < this.offset_ || start > this.offset_ + this.src_.length) {
throw new RangeError('Source slice start out of range');
}
if (end < this.offset_ || end > this.offset_ + this.src_.length) {
throw new RangeError('Source slice end out of range');
}
if (start > end) {
throw new RangeError('Source slice start past end');
}
return new Interpreter.Source(
this.src_.slice(start - this.offset_, end - this.offset_),
start);
};
/**
* Return the (1-based) line and column numbers of a given position
* within the Source object.
* @param {number} pos Position whose line number we are interested
* in, as an absolute position within the original source text.
* @return {{line: number, col: number}} {line, col} tuple for the
* position pos, relative to the start of this particular slice.
*/
Interpreter.Source.prototype.lineColForPos = function(pos) {
if (pos < this.offset_ || pos > this.offset_ + this.src_.length) {
throw new RangeError('Source position out of range');
}
var lines = this.src_.slice(0, pos - this.offset_).split('\n');
return {line: lines.length, col: lines[lines.length - 1].length + 1};
};
/**
* Class for a state.
* @constructor
* @struct
* @param {!Node} node AST node for the state.
* @param {!Interpreter.Scope} scope Scope dictionary for the state.
* @param {boolean=} wantRef Does parent state want reference (rather
* than evaluated value)? (Default: false.)
*/
Interpreter.State = function(node, scope, wantRef) {
/** @const {!Node} */
this.node = node;
/** @const {!Interpreter.Scope} */
this.scope = scope;
/** @const {!Interpreter.StepFunction} */
this.stepFunc = node['stepFunc'];
/** @private @const {boolean} */
this.wantRef_ = wantRef || false;
/** @type {?Interpreter.Value} */
this.value = undefined;
/** @type {?Array} */
this.ref = null;
/** @type {?Array} */
this.labels = null;
/** @type {boolean} */
this.isLoop = false;
/** @type {boolean} */
this.isSwitch = false;
/** @private @type {number} */
this.step_ = 0;
/** @private @type {number} */
this.n_ = 0;
/** @private @type {?Interpreter.Value|undefined} */
this.tmp_ = undefined;
/** @private @type {?Interpreter.CallInfo|
* ?Interpreter.ForInInfo|
* ?Interpreter.SwitchInfo|
* ?Interpreter.Completion}
*/
this.info_ = null;
};
/**
* Create a new State pre-configured to begin executing a function call.
* @param {!Interpreter.prototype.Function} func Function to call.
* @param {?Interpreter.Value} thisVal value of 'this' in function call.
* @param {!Array} args Arguments to pass.
* @param {!Interpreter.Owner} perms Who is doing the call?
* @return {!Interpreter.State} The newly-created state.
*/
Interpreter.State.newForCall = function(func, thisVal, args, perms) {
// Dummy node (used only for type).
var node = new Node;
node['type'] = 'Call';
node['stepFunc'] = stepFuncs_['Call'];
// Dummy outer scope (used ony for perms, which will be caller perms).
var scope = new Interpreter.Scope(Interpreter.Scope.Type.DUMMY, perms, null);
var state = new Interpreter.State(node, scope);
state.info_ = {func: func,
this: thisVal,
arguments: args,
directEval: false,
construct: false,
funcState: undefined};
return state;
};
/**
* Information about a single call stack frame.
* @typedef{(!{func: !Interpreter.prototype.Function,
* this: ?Interpreter.Value,
* callerPerms: !Interpreter.Owner}|
* !{func: !Interpreter.prototype.Function,
* this: ?Interpreter.Value,
* callerPerms: !Interpreter.Owner,
* line: number,
* col: number}|
* !{program: string}|
* !{program: string,
* line: number,
* col: number}|
* !{eval: string}|
* !{eval: string,
* line: number,
* col: number})}
*/
var FrameInfo;
/**
* If this state represents a call stack frame, or otherwise should be
* reported in the output of callers() or in the .stack of an Error
* object, return an object containing information about it;
* otherwise return undefined.
* @return {!FrameInfo|undefined}
*/
Interpreter.State.prototype.frame = function() {
switch (this.node['type']) {
case 'Call':
var info = /** @type{!Interpreter.CallInfo} */(this.info_);
if (!info.func) throw new Error('No function for Call??');
return {
func: info.func,
this: info.this,
callerPerms: this.scope.perms, // BUG(cpcallen:perms): wrong for bind.
};
case 'Program':
var source = this.node['source'];
if (!source) throw new Error('No source for Program??');
return {program: String(source)};
case 'EvalProgram_':
source = this.node['source'];
if (!source) throw new Error('No source for EvalProgram_??');
return {eval: String(source)};
default:
return undefined;
}
};
/**
* Class for a thread of execution.
*
* Note that this is an internal class; it has a companion wrapper
* class - Interpreter.prototype.Thread a.k.a. intrp.Thread - which
* serves as a user-visible wrapper for this class. The two are
* separate for performance reasons only.
* @constructor
* @struct
* @param {number} id Thread ID. Should correspond to index of this
* thread in .threads_ array.
* @param {!Interpreter.State} state Starting state for thread.
* @param {number} runAt Time at which to start running thread.
* @param {number=} timeLimit Maximum runtime without suspending (in ms).
*/
Interpreter.Thread = function(id, state, runAt, timeLimit) {
/** @type {number} */
this.id = id;
// Say it's sleeping for now. May be woken immediately.
/** @type {!Interpreter.Thread.Status} */
this.status = Interpreter.Thread.Status.SLEEPING;
/** @private @type {!Array} */
this.stateStack_ = [state];
/** @type {number} */
this.runAt = runAt;
/** @type {number} */
this.timeLimit = timeLimit || 0;
/** @type {?Interpreter.prototype.Thread} */
this.wrapper = null;
/** @type {?Interpreter.Value} */
this.value = undefined;
};
/**
* Returns the original source code for current state.
* @param {number=} index Optional index in stack to look from.
* @return {?Interpreter.Source} Source code or null if none.
*/
Interpreter.Thread.prototype.getSource = function(index) {
index = (index === undefined) ? this.stateStack_.length - 1 : index;
for (var i = index; i >= 0; i--) {
var source = this.stateStack_[i].node['source'];
if (source) return source;
}
return null;
};
/**
* Return information about the call stack.
* @param {!Interpreter.Owner} perms Who wants callers info?
* @return {!Array} The thread's call stack.
*/
Interpreter.Thread.prototype.callers = function(perms) {
var frames = [];
var pos;
var lc;
for (var i = this.stateStack_.length - 1; i >= 0; i--) {
var state = this.stateStack_[i];
var node = state.node;
if (pos !== undefined && 'source' in node) {
lc = node['source'].lineColForPos(pos);
}
var frame;
if ((frame = state.frame())) {
// TODO(cpcallen:perms): Only include line/column info if func
// is readable by perms - otherwise it leaks some information
// about a supposedly-unreadable function.
if (lc) {
frame.line = lc.line;
frame.col = lc.col;
}
lc = pos = undefined;
frames[frames.length++] = frame;
}
if ((frame || frames.length === 0) && pos === undefined) {
pos = node['start'];
}
}
// TODO(cpcallen): add thread-initiator info.
return frames;
};
/**
* Returns the permissions with which currently-executing code is
* running (equivalent to a unix EUID, but in the form of a
* user/group/etc. object). It is an error to call this function on a
* thread that is a zombie.
* @deprecated
* @return {!Interpreter.Owner}
*/
Interpreter.Thread.prototype.perms = function() {
if (this.status === Interpreter.Thread.Status.ZOMBIE) {
throw new Error('Zombie thread has no perms');
}
return this.stateStack_[this.stateStack_.length - 1].scope.perms;
};
/**
* Legal thread statuses.
* @enum {number}
*/
Interpreter.Thread.Status = {
/** Execution of the thread has terminated. */
ZOMBIE: 0,
/** The thread is ready to run (or is running). */
READY: 1,
/** The thread is blocked, awaiting an external event (e.g. callback). */
BLOCKED: 2,
/** The thread is sleeping, awaiting arrival of its .runAt time. */
SLEEPING: 3,
};
///////////////////////////////////////////////////////////////////////////////
// Inner classes of Interpreter: Declarations.
///////////////////////////////////////////////////////////////////////////////
// Types representing JS objects - Object, Function, Array, etc.
/**
* Typedef for JS values.
* @typedef {!Interpreter.prototype.Object|boolean|number|string|undefined|null}
*/
Interpreter.Value;
/**
* Interface for owners. Anything that is an Owner is really just a
* normal !Interpreter.prototype.Object, but since since no concrete
* class @implements this interface we force oruselves to cast back
* and forth, helping to catch type errors.
* @interface
*/
Interpreter.Owner = function() {};
/**
* An interface for object-like entities: either actual
* Interpreter.prototype.Objects or by non-user-visible boxed
* primitives.
* @interface
*/
Interpreter.ObjectLike = function() {};
/** @type {?Interpreter.prototype.Object} */
Interpreter.ObjectLike.prototype.proto;
/**
* @param {string} key
* @param {!Interpreter.Owner} perms
* @return {!Interpreter.Descriptor|undefined}
*/
Interpreter.ObjectLike.prototype.getOwnPropertyDescriptor =
function(key, perms) {};
/**
* @param {string} key
* @param {!Interpreter.Descriptor} desc
* @param {!Interpreter.Owner} perms
*/
Interpreter.ObjectLike.prototype.defineProperty =
function(key, desc, perms) {};
/**
* @param {string} key
* @param {!Interpreter.Owner} perms
* @return {boolean}
*/
Interpreter.ObjectLike.prototype.has = function(key, perms) {};
/**
* @param {string} key
* @param {!Interpreter.Owner} perms
* @return {?Interpreter.Value}
*/
Interpreter.ObjectLike.prototype.get = function(key, perms) {};
/**
* @param {string} key
* @param {?Interpreter.Value} value
* @param {!Interpreter.Owner} perms
*/
Interpreter.ObjectLike.prototype.set = function(key, value, perms) {};
/**
* @param {string} key
* @param {!Interpreter.Owner} perms
* @return {boolean}
*/
Interpreter.ObjectLike.prototype.deleteProperty = function(key, perms) {};
/** @param {!Interpreter.Owner} perms @return {!Array} */
Interpreter.ObjectLike.prototype.ownKeys = function(perms) {};
/** @return {string} */
Interpreter.ObjectLike.prototype.toString = function() {};
/** @return {?Interpreter.Value} */
Interpreter.ObjectLike.prototype.valueOf = function() {};
/**
* @constructor
* @struct
* @implements {Interpreter.ObjectLike}
* @param {?Interpreter.Owner=} owner
* @param {?Interpreter.prototype.Object=} proto
*/
Interpreter.prototype.Object = function(owner, proto) {
/** @type {?Interpreter.Owner} */
this.owner;
/** @type {?Interpreter.prototype.Object} */
this.proto;
/** @const {!Object} */
this.properties;
// TODO(cpcallen): this is kind of ugly, because connected Objects
// have their shape mutated by the on('connect') handler in Server.
// Consider rewriting it so that there is a WeakMap on Interpreter
// instances mapping objects to their corresponding Socket.
/** @type {!net.Socket|undefined} */
this.socket;
throw new Error('Inner class constructor not callable on prototype');
};
/** @type {?Interpreter.prototype.Object} */
Interpreter.prototype.Object.prototype.proto = null;
/** @type {string} */
Interpreter.prototype.Object.prototype.class = '';
/**
* @param {?Interpreter.prototype.Object} proto
* @param {!Interpreter.Owner} perms
* @return {boolean}
*/
Interpreter.prototype.Object.prototype.setPrototypeOf = function(proto, perms) {
throw new Error('Inner class method not callable on prototype');
};
/** @param {!Interpreter.Owner} perms @return {boolean} */
Interpreter.prototype.Object.prototype.isExtensible = function(perms) {
throw new Error('Inner class method not callable on prototype');
};
/** @param {!Interpreter.Owner} perms @return {boolean} */
Interpreter.prototype.Object.prototype.preventExtensions = function(perms) {
throw new Error('Inner class method not callable on prototype');
};
/**
* @param {string} key
* @param {!Interpreter.Owner} perms
* @return {!Interpreter.Descriptor|undefined}
*/
Interpreter.prototype.Object.prototype.getOwnPropertyDescriptor = function(
key, perms) {
throw new Error('Inner class method not callable on prototype');
};
/**
* @param {string} key
* @param {!Interpreter.Descriptor} desc
* @param {!Interpreter.Owner=} perms
*/
Interpreter.prototype.Object.prototype.defineProperty = function(
key, desc, perms) {
throw new Error('Inner class method not callable on prototype');
};
/**
* @param {string} key
* @param {!Interpreter.Owner} perms
* @return {boolean}
*/
Interpreter.prototype.Object.prototype.has = function(key, perms) {
throw new Error('Inner class method not callable on prototype');
};
/**
* @param {string} key
* @param {!Interpreter.Owner} perms
* @return {?Interpreter.Value}
*/
Interpreter.prototype.Object.prototype.get = function(key, perms) {
throw new Error('Inner class method not callable on prototype');
};
/**
* @param {string} key
* @param {?Interpreter.Value} value
* @param {!Interpreter.Owner} perms
*/
Interpreter.prototype.Object.prototype.set = function(key, value, perms) {
throw new Error('Inner class method not callable on prototype');
};
/**
* @param {string} key
* @param {!Interpreter.Owner} perms
* @return {boolean}
*/
Interpreter.prototype.Object.prototype.deleteProperty = function(key, perms) {
throw new Error('Inner class method not callable on prototype');
};
/** @param {!Interpreter.Owner} perms @return {!Array} */
Interpreter.prototype.Object.prototype.ownKeys = function(perms) {
throw new Error('Inner class method not callable on prototype');
};
/** @return {string} */
Interpreter.prototype.Object.prototype.toString = function() {
throw new Error('Inner class method not callable on prototype');
};
/** @return {?Interpreter.Value} */
Interpreter.prototype.Object.prototype.valueOf = function() {
throw new Error('Inner class method not callable on prototype');
};
/**
* @constructor
* @struct
* @extends {Interpreter.prototype.Object}
* @param {?Interpreter.Owner=} owner
* @param {?Interpreter.prototype.Object=} proto
*/
Interpreter.prototype.Function = function(owner, proto) {
throw new Error('Inner class constructor not callable on prototype');
};
/**
* @param {?Interpreter.Value} value
* @param {!Interpreter.Owner} perms
* @return {boolean}
*/
Interpreter.prototype.Function.prototype.hasInstance = function(value, perms) {
throw new Error('Inner class method not callable on prototype');
};
/**
* @param {string} name
* @param {string=} prefix
*/
Interpreter.prototype.Function.prototype.setName = function(name, prefix) {
throw new Error('Inner class method not callable on prototype');
};
/**
* @param {!Interpreter} intrp The interpreter.
* @param {!Interpreter.Thread} thread The current thread.
* @param {!Interpreter.State} state The current state.
* @param {?Interpreter.Value} thisVal The this value passed into function.
* @param {!Array} args The arguments to the call.
* @return {?Interpreter.Value|!Interpreter.FunctionResult}
*/
Interpreter.prototype.Function.prototype.call = function(
intrp, thread, state, thisVal, args) {
throw new Error('Inner class method not callable on prototype');
};
/**
* @param {!Interpreter} intrp The interpreter.
* @param {!Interpreter.Thread} thread The current thread.
* @param {!Interpreter.State} state The current state.
* @param {!Array} args The arguments to the call.
* @return {?Interpreter.Value|!Interpreter.FunctionResult}
*/
Interpreter.prototype.Function.prototype.construct = function(
intrp, thread, state, args) {
throw new Error('Inner class method not callable on prototype');
};
/**
* @constructor
* @struct
* @extends {Interpreter.prototype.Function}
* @param {!Node} node
* @param {!Interpreter.Scope} scope Enclosing scope.
* @param {!Interpreter.Source} source
* @param {?Interpreter.Owner=} owner
* @param {?Interpreter.prototype.Object=} proto
*/
Interpreter.prototype.UserFunction = function(
node, scope, source, owner, proto) {
/** @type {!Node} */
this.node;
/** @type {!Interpreter.Scope} */
this.scope;
throw new Error('Inner class constructor not callable on prototype');
};
/**
* @param {!Interpreter.Owner} owner
* @param {?Interpreter.Value} thisVal
* @param {!Array} args
* @return {!Interpreter.Scope}
* @private
*/
Interpreter.prototype.UserFunction.prototype.instantiateDeclarations_ =
function(owner, thisVal, args) {
throw new Error('Inner class method not callable on prototype');
};
/**
* @constructor
* @struct
* @extends {Interpreter.prototype.Function}
* @param {!Interpreter.prototype.Function} func
* @param {?Interpreter.Value} thisVal
* @param {!Array} args
* @param {?Interpreter.Owner=} owner
*/
Interpreter.prototype.BoundFunction = function(func, thisVal, args, owner) {
/** @type {!Interpreter.prototype.Function} */
this.boundFunc;
/** @type {?Interpreter.Value} */
this.thisVal;
/** @type {!Array} */
this.args;
throw new Error('Inner class constructor not callable on prototype');
};
/**
* @constructor
* @struct
* @extends {Interpreter.prototype.Function}
* @param {!NativeFunctionOptions=} options
*/
Interpreter.prototype.NativeFunction = function(options) {
throw new Error('Inner class constructor not callable on prototype');
};
/**
* @constructor
* @struct
* @extends {Interpreter.prototype.NativeFunction}
* @param {!Function} impl
* @param {boolean} legalConstructor
* @param {!NativeFunctionOptions=} options
*/
Interpreter.prototype.OldNativeFunction =
function(impl, legalConstructor, options) {
throw new Error('Inner class constructor not callable on prototype');
};
/**
* @constructor
* @struct
* @extends {Interpreter.prototype.Object}
* @param {?Interpreter.Owner=} owner
* @param {?Interpreter.prototype.Object=} proto
*/
Interpreter.prototype.Array = function(owner, proto) {
throw new Error('Inner class constructor not callable on prototype');
};
/**
* @constructor
* @struct
* @extends {Interpreter.prototype.Object}
* @param {!Date} date
* @param {?Interpreter.Owner=} owner
* @param {?Interpreter.prototype.Object=} proto
*/
Interpreter.prototype.Date = function(date, owner, proto) {
/** @type {!Date} */
this.date;
throw new Error('Inner class constructor not callable on prototype');
};
/**
* @constructor
* @struct
* @extends {Interpreter.prototype.Object}
* @param {!RegExp=} re
* @param {?Interpreter.Owner=} owner
* @param {?Interpreter.prototype.Object=} proto
*/
Interpreter.prototype.RegExp = function(re, owner, proto) {
/** @type {!RegExp} */
this.regexp;
throw new Error('Inner class constructor not callable on prototype');
};
/**
* @constructor
* @struct
* @extends {Interpreter.prototype.Object}
* @param {?Interpreter.Owner=} owner
* @param {?Interpreter.prototype.Object=} proto
* @param {string=} message
* @param {!Array=} callers
*/
Interpreter.prototype.Error = function(owner, proto, message, callers) {
throw new Error('Inner class constructor not callable on prototype');
};
/**
* @param {!Array} callers
* @param {!Interpreter.Owner} perms
*/
Interpreter.prototype.Error.prototype.makeStack = function(callers, perms) {
throw new Error('Inner class method not callable on prototype');
};
/**
* @constructor
* @struct
* @extends {Interpreter.prototype.Object}
* @param {?Interpreter.Owner=} owner
* @param {?Interpreter.prototype.Object=} proto
*/
Interpreter.prototype.Arguments = function(owner, proto) {
throw new Error('Inner class constructor not callable on prototype');
};
/**
* @constructor
* @struct
* @extends {Interpreter.prototype.Object}
* @param {?Interpreter.Owner=} owner
* @param {?Interpreter.prototype.Object=} proto
*/
Interpreter.prototype.WeakMap = function(owner, proto) {
/** @type {!IterableWeakMap} */
this.weakMap;
throw new Error('Inner class constructor not callable on prototype');
};
/**
* @constructor
* @struct
* @extends {Interpreter.prototype.Object}
* @param {!Interpreter.Thread} thread
* @param {!Interpreter.Owner} owner
* @param {?Interpreter.prototype.Object=} proto
*/
Interpreter.prototype.Thread = function(thread, owner, proto) {
/** @type {!Interpreter.Thread} */
this.thread;
throw new Error('Inner class constructor not callable on prototype');
};
///////////////////////////////////////////////////////////////////////////////
// Other types, not representing JS objects.
/**
* @constructor
* @struct
* @implements {Interpreter.ObjectLike}
* @param {(boolean|number|string)} prim
*/
Interpreter.prototype.Box = function(prim) {
/** @private @type {(undefined|null|boolean|number|string)} */
this.primitive_;
/** @type {!Interpreter.prototype.Object} */
this.proto;
throw new Error('Inner class constructor not callable on prototype');
};
/**
* @param {string} key
* @param {!Interpreter.Owner} perms
* @return {!Interpreter.Descriptor|undefined}
*/
Interpreter.prototype.Box.prototype.getOwnPropertyDescriptor = function(
key, perms) {
throw new Error('Inner class method not callable on prototype');
}
/**
* @param {string} key
* @param {!Interpreter.Descriptor} desc
* @param {!Interpreter.Owner} perms
*/
Interpreter.prototype.Box.prototype.defineProperty = function(
key, desc, perms) {
throw new Error('Inner class method not callable on prototype');
};
/**
* @param {string} key
* @param {!Interpreter.Owner} perms
* @return {boolean}
*/
Interpreter.prototype.Box.prototype.has = function(key, perms) {
throw new Error('Inner class method not callable on prototype');
};
/**
* @param {string} key
* @param {!Interpreter.Owner} perms
* @return {?Interpreter.Value}
*/
Interpreter.prototype.Box.prototype.get = function(key, perms) {
throw new Error('Inner class method not callable on prototype');
};
/**
* @param {string} key
* @param {!Interpreter.Owner} perms
* @param {?Interpreter.Value} value
*/
Interpreter.prototype.Box.prototype.set = function(key, value, perms) {
throw new Error('Inner class method not callable on prototype');
};
/**
* @param {string} key
* @param {!Interpreter.Owner} perms
* @return {boolean}
*/
Interpreter.prototype.Box.prototype.deleteProperty = function(key, perms) {
throw new Error('Inner class method not callable on prototype');
};
/**
* @param {!Interpreter.Owner} perms
* @return {!Array}
*/
Interpreter.prototype.Box.prototype.ownKeys = function(perms) {
throw new Error('Inner class method not callable on prototype');
};
/** @return {string} String value. */
Interpreter.prototype.Box.prototype.toString = function() {
throw new Error('Inner class method not callable on prototype');
};
/** @return {?Interpreter.Value} Value. */
Interpreter.prototype.Box.prototype.valueOf = function() {
throw new Error('Inner class method not callable on prototype');
};
/**
* @constructor
* @struct
* @param {!Interpreter.Owner} owner
* @param {number} port
* @param {!Interpreter.prototype.Object} proto
* @param {number=} timeLimit
*/
Interpreter.prototype.Server = function(owner, port, proto, timeLimit) {
/** @type {!Interpreter.Owner} */
this.owner;
/** @type {number} */
this.port;
/** @type {!Interpreter.prototype.Object} */
this.proto;
/** @type {number} */
this.timeLimit;
/** @private @type {!net.Server} */
this.server_;
throw new Error('Inner class constructor not callable on prototype');
};
/** @param {!function(!Error=)=} callback */
Interpreter.prototype.Server.prototype.listen = function(callback) {
throw new Error('Inner class method not callable on prototype');
};
/** @param {!function()=} callback */
Interpreter.prototype.Server.prototype.unlisten = function(callback) {
throw new Error('Inner class method not callable on prototype');
};
///////////////////////////////////////////////////////////////////////////////
// Inner classes of Interpreter: Implementations.
///////////////////////////////////////////////////////////////////////////////
/**
* Install the actual Object, Function, Array, RegExp, Error,
* etc. constructors on an Interpreter instance. Should
* be called just once, from the Interpreter constructor.
*/
Interpreter.prototype.installTypes = function() {
var intrp = this; // The interpreter instance to which these classes belong.
/////////////////////////////////////////////////////////////////////////////
// Types representing JS objects - Object, Function, Array, etc.
/**
* Class for an object.
* @constructor
* @struct
* @extends {Interpreter.prototype.Object}
* @param {?Interpreter.Owner=} owner Owner object or null.
* @param {?Interpreter.prototype.Object=} proto Prototype object or null.
*/
intrp.Object = function(owner, proto) {
if (proto === undefined) {
proto = intrp.OBJECT;
}
if (owner === undefined) {
owner = null;
}
this.owner = owner;
this.proto = proto;
this.properties = Object.create((proto === null) ? null : proto.properties);
};
/** @type {?Interpreter.prototype.Object} */
intrp.Object.prototype.proto = null;
/** @type {string} */
intrp.Object.prototype.class = 'Object';
/**
* The [[SetPrototypeOf]] internal method from ES6 §9.1.2, with
* substantial adaptations for Code City including added perms
* checks.
*
* N.B.: Note that instead of returning false, this implementation
* will throw a more specific error in the event that the set fails.
* approriate error upon failure.
* @param {?Interpreter.prototype.Object} proto The new prototype or null.
* @param {!Interpreter.Owner} perms Who is trying set the prototype?
* @return {boolean} True iff the set succeeded.
*/
intrp.Object.prototype.setPrototypeOf = function(proto, perms) {
if (perms === null) throw new TypeError("null can't check extensibility");
// TODO(cpcallen:perms): add "controls"-type perm check.
if (proto === this.proto) { // Doing nothing always succeeds.
return true;
} else if (!this.isExtensible(perms)) {
throw new intrp.Error(perms, intrp.TYPE_ERROR,
"Can't set prototype of non-extensible object");
}
for (var p = proto; p !== null; p = p.proto) {
if (p === this) {
throw new intrp.Error(perms, intrp.TYPE_ERROR,
"An object's prototype chain can't include the object itself");
}
}
Object.setPrototypeOf(this.properties, proto && proto.properties);
this.proto = proto;
return true;
};
/**
* The [[IsExtensible]] internal method from ES6 §9.1.3, with
* substantial adaptations for Code City including added perms
* checks.
* @param {!Interpreter.Owner} perms Who is trying to check?
* @return {boolean} Is the object extensible?
*/
intrp.Object.prototype.isExtensible = function(perms) {
if (perms === null) throw new TypeError("null can't check extensibility");
// TODO(cpcallen:perms): add check for (object) readability.
return Object.isExtensible(this.properties);
};
/**
* The [[PreventExtensions]] internal method from ES6 §9.1.4, with
* substantial adaptations for Code City including added perms
* checks.
* @param {!Interpreter.Owner} perms Who is trying to prevent extensions?
* @return {boolean} Is the object extensible afterwards?
*/
intrp.Object.prototype.preventExtensions = function(perms) {
if (perms === null) throw new TypeError("null can't prevent extensibions");
// TODO(cpcallen:perms): add "controls"-type perm check.
Object.preventExtensions(this.properties);
return true;
};
/**
* The [[GetOwnOwnProperty]] internal method from ES5.1 §8.12.1,
* with substantial adaptations for Code City including added perms
* checks (but no support for getter or setters).
* @param {string} key Key (name) of property to get.
* @param {!Interpreter.Owner} perms Who is trying to get it?
* @return {!Interpreter.Descriptor|undefined} The property
* descriptor, or undefined if no such property exists.
*/
intrp.Object.prototype.getOwnPropertyDescriptor = function(key, perms) {
if (perms === null) {
throw new TypeError("null can't getOwnPropertyDescriptor");
}
// TODO(cpcallen:perms): add check for (property) readability.
var pd = Object.getOwnPropertyDescriptor(this.properties, key);
// TODO(cpcallen): can we eliminate this pointless busywork while
// still maintaining type safety?
return pd && new Descriptor(pd.writable, pd.enumerable, pd.configurable)
.withValue(/** @type {?Interpreter.Value} */ (pd.value));
};
/**
* The [[DefineOwnProperty]] internal method from ES5.1 §8.12.9,
* with substantial adaptations for Code City including added perms
* checks (but no support for getter or setters).
* @param {string} key Key (name) of property to set.
* @param {!Interpreter.Descriptor} desc The property descriptor.
* @param {!Interpreter.Owner=} perms Who is trying to set it? If
* omitted, defaults to this.owner but skips perm check. (This
* is intended to be used only when constructing.)
*/
intrp.Object.prototype.defineProperty = function(key, desc, perms) {
if (perms !== undefined) {
if (perms === null) throw new TypeError("null can't defineProperty");
// TODO(cpcallen:perms): add "controls"-type perm check.
}
try {
Object.defineProperty(this.properties, key, desc);
} catch (e) {
throw intrp.errorNativeToPseudo(e, perms || this.owner);
}
};
/**
* The [[HasProperty]] internal method from ES5.1 §8.12.6, with
* substantial adaptations for Code City including added perms
* checks.
* @param {string} key Key (name) of property to get.
* @param {!Interpreter.Owner} perms Who is trying to get it?
* @return {boolean} The value of the property, or undefined.
*/
intrp.Object.prototype.has = function(key, perms) {
if (perms === null) throw new TypeError("null can't has");
// TODO(cpcallen:perms): add check for (object) readability.
return key in this.properties;
};
/**
* The [[Get]] internal method from ES5.1 §8.12.3, with substantial
* adaptations for Code City including added perms checks (but no
* support for getters).
* @param {string} key Key (name) of property to get.
* @param {!Interpreter.Owner} perms Who is trying to get it?
* @return {?Interpreter.Value} The value of the property, or undefined.
*/
intrp.Object.prototype.get = function(key, perms) {
if (perms === null) throw new TypeError("null can't get");
// TODO(cpcallen:perms): add check for (property) readability.
return this.properties[key];
};
/**
* The [[Set]] internal method from ES5.1 §8.12.5, with substantial
* adaptations for Code City including added perms checks (but no
* support for setters).
* @param {string} key Key (name) of property to set.
* @param {!Interpreter.Owner} perms Who is trying to set it?
* @param {?Interpreter.Value} value The new value of the property.
*/
intrp.Object.prototype.set = function(key, value, perms) {
if (perms === null) throw new TypeError("null can't set");
// TODO(cpcallen:perms): add "controls"-type perm check.
try {
this.properties[key] = value;
} catch (e) {
throw intrp.errorNativeToPseudo(e, perms);
}
};
/**
* The [[Delete]] internal method from ES5.1 §8.12.7, with
* substantial adaptations for Code City including added perms
* checks (but no support for getters).
* @param {string} key Key (name) of property to get.
* @param {!Interpreter.Owner} perms Who is trying to get it?
* @return {boolean} True iff successful.
*/
intrp.Object.prototype.deleteProperty = function(key, perms) {
if (perms === null) throw new TypeError("null can't delete");
// TODO(cpcallen:perms): add "controls"-type perm check.
try {
delete this.properties[key];
} catch (e) {
throw intrp.errorNativeToPseudo(e, perms);
}
return true;
};
/**
* The [[OwnPropertyKeys]] internal method from ES6 §9.1.12, with
* substantial adaptations for Code City including added perms
* checks.
*
* TODO(cpcallen:perms): decide whether null user can read
* properties. (At the moment this is forbidden redundantly by type
* signature an runtime check; one or both should be removed.)
* @param {!Interpreter.Owner} perms Who is trying to get it?
* @return {!Array} An array of own property keys.
*/
intrp.Object.prototype.ownKeys = function(perms) {
if (perms === null) throw new TypeError("null can't ownPropertyKeys");
// TODO(cpcallen:perms): add check for (object) readability.
return Object.getOwnPropertyNames(this.properties);
};
/**
* Convert this object into a string.
* @return {string} String value.
* @override
*/
intrp.Object.prototype.toString = function() {
var c;
// TODO(cpcallen:perms): perms check here?
if (this instanceof intrp.Object) {
c = this.class;
} else {
c = ({
undefined: 'Undefined',
null: 'Null',
boolean: 'Boolean',
number: 'Number',
string: 'String',
})[typeof this];
}
return '[object ' + c + ']';
};
/**
* Return the object value.
* @return {?Interpreter.Value} Value.
* @override
*/
intrp.Object.prototype.valueOf = function() {
return this;
};
/**
* Class for a function.
* @constructor
* @struct
* @extends {Interpreter.prototype.Function}
* @param {?Interpreter.Owner=} owner Owner object (default: null).
* @param {?Interpreter.prototype.Object=} proto Prototype object or null.
*/
intrp.Function = function(owner, proto) {
intrp.Object.call(/** @type {?} */ (this), owner,
(proto === undefined ? intrp.FUNCTION : proto));
};
intrp.Function.prototype = Object.create(intrp.Object.prototype);
intrp.Function.prototype.constructor = intrp.Function;
intrp.Function.prototype.class = 'Function';
/**
* Convert this function into a string.
* @override
* @this {!Interpreter.prototype.Function}
*/
intrp.Function.prototype.toString = function() {
// Just do the simplest possible (spec-compliant) thing here.
return 'function () { [native code] }';
};
/**
* The [[HasInstance]] internal method from §15.3.5.3 of the ES5.1 spec.
* @param {?Interpreter.Value} value The value to be checked for
* being an instance of this function.
* @param {!Interpreter.Owner} perms Who wants to know? Used in
* readability check of .constructor property and as owner of
* any Errors thrown.
* @return {boolean}
* @override
*/
intrp.Function.prototype.hasInstance = function(value, perms) {
if (!(value instanceof intrp.Object)) {
return false;
}
var prot = this.get('prototype', perms);
if (!(prot instanceof intrp.Object)) {
throw new intrp.Error(perms, intrp.TYPE_ERROR,
"Function has non-object prototype '" + prot +
"' in instanceof check");
}
for (var v = value.proto; v !== null; v = v.proto) {
if (v === prot) {
return true;
}
}
return false;
};
/**
* Add a .name property to this function object. Implements
* SetFunctionName from ES6 §9.2.11.
*
* N.B.: The setting is not subject to any perms checks, so it must
* not be possible for a user to cause this internal method to be
* invoked on any function object owned by another user. Typically
* this will be enforced by only invoking this method at the time
* the function is constructed, or immediately afterwards by a
* lexically-enclosing expression having first used tested the
* expression which resulted in the function value with
* isAnonymousFunctionDefinition (q.v.).
*
* TODO(ES6): allow name to be type Symbol.
* @param {string} name Name of function.
* @param {string=} prefix Prefix for function name (e.g. 'get', 'bound').
* @override
*/
intrp.Function.prototype.setName = function(name, prefix) {
if (prefix) {
name = prefix + ' ' + name;
}
this.defineProperty('name', Descriptor.c.withValue(name));
};
/**
* The [[Call]] internal method defined by §13.2.1 of the ES5.1 spec.
* Generic functions (neither native nor user) can't be called.
* @param {!Interpreter} intrp The interpreter.
* @param {!Interpreter.Thread} thread The current thread.
* @param {!Interpreter.State} state The current state.
* @param {?Interpreter.Value} thisVal The this value passed into function.
* @param {!Array} args The arguments to the call.
* @return {?Interpreter.Value}
* @override
*/
intrp.Function.prototype.call = function(
intrp, thread, state, thisVal, args) {
throw new intrp.Error(state.scope.perms, intrp.TYPE_ERROR,
"Class constructor " + this + " cannot be invoked without 'new'");
};
/**
* The [[Construct]] internal method defined by §13.2.2 of the ES5.1
* spec.
* Generic functions (neither native nor user) can't be constructed.
* @param {!Interpreter} intrp The interpreter.
* @param {!Interpreter.Thread} thread The current thread.
* @param {!Interpreter.State} state The current state.
* @param {!Array} args The arguments to the call.
* @return {?Interpreter.Value}
* @override
*/
intrp.Function.prototype.construct = function(
intrp, thread, state, args) {
throw new intrp.Error(state.scope.perms, intrp.TYPE_ERROR,
this + ' is not a constructor');
};
/**
* Class for a user-defined function.
* @constructor
* @struct
* @extends {Interpreter.prototype.UserFunction}
* @param {!Node} node AST node for function body.
* @param {!Interpreter.Scope} scope Enclosing scope.
* @param {!Interpreter.Source} source Source from which AST was parsed.
* @param {?Interpreter.Owner=} owner Owner object (default: null).
* @param {?Interpreter.prototype.Object=} proto Prototype object or null.
*/
intrp.UserFunction = function(node, scope, source, owner, proto) {
if (!node) { // Deserializing
return;
}
intrp.Function.call(/** @type {?} */ (this), owner, proto);
this.node = node;
this.scope = scope;
if (node['id']) {
this.setName(node['id']['name']);
}
var length = node['params'].length;
this.defineProperty('length', Descriptor.none.withValue(length));
// Record the source on the function node's body node. Store it
// on the AST (rather than on the UserFunction instance) because
// each time a function expression is evaluated a new UserFunction
// is created, but they all have identical source code. Store it
// on the body node (rather than on the function node) because the
// function node never appears on the stateStack_ when the
// function is being executed.
if (!node['body']['source']) {
node['body']['source'] = source.slice(node['start'], node['end']);
}
// Add .prototype property pointing at a new plain Object.
var protoObj = new intrp.Object(this.owner);
this.defineProperty('prototype', Descriptor.w.withValue(protoObj));
protoObj.defineProperty('constructor', Descriptor.wc.withValue(this));
};
intrp.UserFunction.prototype = Object.create(intrp.Function.prototype);
intrp.UserFunction.prototype.constructor = intrp.UserFunction;
/**
* Convert this function into a string.
* @override
*/
intrp.UserFunction.prototype.toString = function() {
// TODO(cpcallen:perms): perms check here?
return String(this.node['body']['source']);
};
/**
* The [[Call]] internal method defined by §13.2.1 of the ES5.1 spec.
* N.B.: This function (or any called from or overriding it) must
* not use state.info_.funcState, as that it used by
* Userfunction.prototype.construct, which calls us.
* @override
*/
intrp.UserFunction.prototype.call = function(
intrp, thread, state, thisVal, args) {
if (this.owner === null) {
throw new intrp.Error(state.scope.perms, intrp.PERM_ERROR,
'Functions with null owner are not executable');
}
var scope = this.instantiateDeclarations_(this.owner, thisVal, args);
state.value = undefined; // Default value if no explicit return.
thread.stateStack_[thread.stateStack_.length] =
new Interpreter.State(this.node['body'], scope);
return Interpreter.FunctionResult.AwaitValue;
};
/**
* The [[Construct]] internal method defined by §13.2.2 of the ES5.1
* spec.
* @override
*/
intrp.UserFunction.prototype.construct = function(
intrp, thread, state, args) {
if (!state.info_.funcState) { // First visit.
if (this.owner === null) {
throw new intrp.Error(state.scope.perms, intrp.PERM_ERROR,
'Functions with null owner are not constructable');
}
// TODO(cpcallen:perms): Is it really OK to construct if caller
// can't read .prototype?
var proto = this.get('prototype', this.owner);
// Per ES5.1 §13.2.2 step 7: if .prototype is primitive, use
// Object.prototype instead.
if (!(proto instanceof intrp.Object)) {
proto = intrp.OBJECT;
}
state.info_.funcState = new intrp.Object(state.scope.perms, proto);
this.call(intrp, thread, state, state.info_.funcState, args);
return Interpreter.FunctionResult.CallAgain;
} else { // Construction done. Check result.
// Per ES5.1 §13.2.2 steps 9, 10: if constructor returns
// primitive, return constructed object instead.
if (!(state.value instanceof intrp.Object)) {
return /** @type {?Interpreter.Value} */ (state.info_.funcState);
}
return state.value;
}
};
/**
* A simplified version of the FunctionDeclarationInstantiation
* specification function from ES6 §9.2.12 (see also Declaration
* Binding Instantiation in ES5.1 §10.5).
*
* Creates a new Scope and sets up the bindings of the function's
* parameters and variables.
* @param {!Interpreter.Owner} owner Owner for new Scope.
* @param {?Interpreter.Value} thisVal The value of 'this' for the call.
* @param {!Array} args The arguments to the call.
* @return {!Interpreter.Scope} The initialised scope
* @private
*/
intrp.UserFunction.prototype.instantiateDeclarations_ = function(
owner, thisVal, args) {
// Aside: we need to pass owner, rather than
// this.scope.perms, for the new scope perms because (1) we want
// to be able to change the owner of a function after it's
// created, and (2) functions created using the Function
// constructor have this.scope set to the global scope, which is
// owned by root!
var scope = new Interpreter.Scope(
Interpreter.Scope.Type.FUNCTION, owner, this.scope, thisVal);
// Add all arguments to the scope.
var params = this.node['params'];
for (var i = 0; i < params.length; i++) {
var paramName = params[i]['name'];
var paramValue = args.length > i ? args[i] : undefined;
scope.createMutableBinding(paramName, paramValue);
}
var body = this.node['body'];
if (!('arguments' in getBoundNames(body)) &&
hasArgumentsOrEval(body)) {
// Build arguments object.
var argsObj = new intrp.Arguments(owner);
argsObj.defineProperty(
'length', Descriptor.wc.withValue(args.length), owner);
for (i = 0; i < args.length; i++) {
argsObj.defineProperty(
String(i), Descriptor.wec.withValue(args[i]), owner);
}
scope.createImmutableBinding('arguments', argsObj);
}
// Populate local variables and other inner declarations.
intrp.populateScope_(body, scope);
return scope;
};
/**
* Class for bound functions. See ES5 §15.3.4.5 / ES6 §9.4.1.
* @constructor
* @struct
* @extends {Interpreter.prototype.BoundFunction}
* @param {!Interpreter.prototype.Function} func Function to be bound.
* @param {?Interpreter.Value} thisVal The this value passed into function.
* @param {!Array} args Arguments to prefix to the call.
* @param {?Interpreter.Owner=} owner Owner object (default: null).
*/
intrp.BoundFunction = function(func, thisVal, args, owner) {
if (!func) return; // Deserializing
intrp.Function.call(/** @type {?} */ (this), owner, func.proto);
/** @type {!Interpreter.prototype.Function} */
this.boundFunc = func;
/** @type {?Interpreter.Value} */
this.thisVal = thisVal;
/** @type {!Array} */
this.args = args;
};
intrp.BoundFunction.prototype = Object.create(intrp.Function.prototype);
intrp.BoundFunction.prototype.constructor = intrp.BoundFunction;
/**
* The [[Call]] internal method for bound functions, defined by
* ES5.1 §15.3.4.5.1 / ES6 §9.4.1.1.
*
* BUG(cpcallen:perms): the target function will see callerPerms
* being whoever called the bound function, but should see
* callerPerms being the owner of the bound function.
* @override
*/
intrp.BoundFunction.prototype.call = function(
intrp, thread, state, thisVal, args) {
// TODO(cpcallen:perms): Consider carefully whose perms should be
// used where!
if (this.owner === null) {
throw new intrp.Error(state.scope.perms, intrp.PERM_ERROR,
'Functions with null owner are not executable');
}
var argList = this.args.concat(args);
// Rewrite state.info_, as a short-circuit optimisation in case
// we get called again due to FunctionResult.CallAgain, and also
// to produce more useful callers() output / stack traces.
var info = state.info_;
info.func = this.boundFunc;
info.this = this.thisVal;
info.args = argList;
info.construct = false;
// But just go and do the first .call directly.
return this.boundFunc.call(intrp, thread, state, this.thisVal, argList);
};
/**
* The [[Construct]] internal method for bound functions, defined by
* ES5.1 §15.3.4.5.2 / ES6 §9.4.1.2.
*
* BUG(cpcallen:perms): the target function will see callerPerms
* being whoever called the bound function, but should see
* callerPerms being the owner of the bound function.
* @override
*/
intrp.BoundFunction.prototype.construct = function(
intrp, thread, state, args) {
// TODO(cpcallen:perms): Consider carefully whose perms should be
// used where!
if (this.owner === null) {
throw new intrp.Error(state.scope.perms, intrp.PERM_ERROR,
'Functions with null owner are not constructable');
}
var argList = this.args.concat(args);
// Rewrite state.info_, as a short-circuit optimisation in case
// we get called again due to FunctionResult.CallAgain, and also
// to produce more useful callers() output / stack traces.
var info = state.info_;
info.func = this.boundFunc;
info.this = this.thisVal;
info.args = argList;
info.construct = true;
// But just go and do the first .construct directly.
return this.boundFunc.construct(intrp, thread, state, argList);
};
/**
* Class for a native function. Options are as follows:
*
* If options.name is a non-empty string, the new function object's
* .name property will be set to this value. Otherwise, if
* options.id is a non-empty string, the part following the last '.'
* will be used instead.
*
* If options.length is supplied, the new object's .length will be
* set to this value.
*
* If options.id is a non-empty string, the new native function
* object will be registered as a builtin with that id value.
*
* The options.call and .construct will be used for the [[Call]] and
* [[Construct]] specifications methods respectively. If omitted,
* the function will not be callable / constructable.
*
* The new object will be owned by options.owner (default:
* intrp.ROOT), and have prototype options.proto (default:
* intrp.FUNCTION - i.e., Function.prototype).
*
* @constructor
* @struct
* @extends {Interpreter.prototype.NativeFunction}
* @param {!NativeFunctionOptions=} options Options object for
* constructing native function.
*/
intrp.NativeFunction = function(options) {
options = options || {};
var owner = (options.owner !== undefined ? options.owner : intrp.ROOT);
// Invoke super constructor.
intrp.Function.call(/** @type {?} */ (this), owner, options.proto);
// Set .name if name or id supplied, and save original name internally.
// N.B.: Function.prototype gets .name === ''.
/** The initial value of the .name property. @type {string|undefined} */
this.name = undefined;
if (options.name !== undefined) {
this.name = options.name;
} else if (options.id) {
this.name = options.id.replace(/^.*\./, '');
}
if (this.name !== undefined) this.setName(this.name);
// Set .length if length supplied.
if (options.length !== undefined) {
this.defineProperty('length', Descriptor.none.withValue(options.length),
owner);
}
// Register as builtin if id supplied.
if (options.id) {
intrp.builtins.set(options.id, this);
}
// Install [[Call]] and [[Construct]] methods, making sure they
// are labelled for serialization (if possible and not already).
var serialId = options.id || options.name;
if (options.call) {
this.call = options.call;
if (serialId && !('id' in this.call)) {
this.call.id = serialId + ' [[Call]]';
}
}
if (options.construct) {
this.construct = options.construct;
if (serialId && !('id' in this.construct)) {
this.construct.id = serialId + ' [[Construct]]';
}
}
};
intrp.NativeFunction.prototype = Object.create(intrp.Function.prototype);
intrp.NativeFunction.prototype.constructor = intrp.NativeFunction;
/**
* Convert this function into a string. This implements
* https://tc39.es/Function-prototype-toString-revision/#proposal-sec-function.prototype.tostring
* (now adopted) as it applies to "Well-known Intrinsic Object[s]"
* as well as any other NativeFunction constructed with specified
* name or id.
* @override
*/
intrp.NativeFunction.prototype.toString = function() {
if (this.name === undefined) {
return intrp.Function.prototype.toString.call(this);
}
// TODO(cpcallen): include formal parameter names?
return 'function ' + this.name + '() { [native code] }';
};
/**
* Class for an old native function.
* @constructor
* @struct
* @extends {Interpreter.prototype.OldNativeFunction}
* @param {!Function} impl Old-style native function implementation
* @param {boolean} legalConstructor True if the function can be used as a
* constructor (e.g. Array), false if not (e.g. escape).
* @param {!NativeFunctionOptions=} options Options object for
* constructing the underlying NativeFunction.
*/
intrp.OldNativeFunction = function(impl, legalConstructor, options) {
if (!impl) return; // Deserializing
intrp.NativeFunction.call(/** @type {?} */ (this), options);
/** @type {!Function} */
this.impl = impl;
/** @type {boolean} */
this.illegalConstructor = !legalConstructor;
};
intrp.OldNativeFunction.prototype =
Object.create(intrp.NativeFunction.prototype);
intrp.OldNativeFunction.prototype.constructor = intrp.OldNativeFunction;
/** @override */
intrp.OldNativeFunction.prototype.call = function(
intrp, thread, state, thisVal, args) {
if (this.owner === null) {
throw new intrp.Error(state.scope.perms, intrp.PERM_ERROR,
'Functions with null owner are not executable');
}
return this.impl.apply(thisVal, args);
};
/** @override */
intrp.OldNativeFunction.prototype.construct = function(
intrp, thread, state, args) {
if (this.illegalConstructor) {
// Pass to super, which will complain about non-callability:
intrp.Function.prototype.construct.call(
/** @type {?} */ (this), intrp, thread, state, args);
}
if (this.owner === null) {
throw new intrp.Error(state.scope.perms, intrp.PERM_ERROR,
'Functions with null owner are not constructable');
}
return this.impl.apply(undefined, args);
};
/**
* Class for an array
* @constructor
* @struct
* @extends {Interpreter.prototype.Array}
* @param {?Interpreter.Owner=} owner Owner object or null.
* @param {?Interpreter.prototype.Object=} proto Prototype object or null.
*/
intrp.Array = function(owner, proto) {
if (proto === undefined) {
proto = intrp.ARRAY;
}
intrp.Object.call(/** @type {?} */ (this), owner, proto);
this.properties = [];
Object.setPrototypeOf(this.properties,
(proto === null) ? null : proto.properties);
};
intrp.Array.prototype = Object.create(intrp.Object.prototype);
intrp.Array.prototype.constructor = intrp.Array;
intrp.Array.prototype.class = 'Array';
/**
* Convert array-like objects into a string.
* @override
*/
intrp.Array.prototype.toString = function() {
// BUG(cpcallen): toString should access properties on this with
// the caller's permissions - but at present there is no way to
// determine who it was called by, so use intrp.ANYBODY instead.
var visited = intrp.toStringVisited_;
if (visited.has(this)) {
return '';
}
visited.add(this);
try {
var strs = [];
var len = this.get('length', intrp.ANYBODY);
for (var i = 0; i < this.properties.length; i++) {
var value = this.get(String(i), intrp.ANYBODY);
if (value === null || value === undefined) {
strs[i] = '';
} else {
strs[i] = String(value);
}
}
} finally {
visited.delete(this);
}
return strs.join(',');
};
/**
* Class for a date.
* @constructor
* @struct
* @extends {Interpreter.prototype.Date}
* @param {!Date} date Date value for this Date object.
* @param {?Interpreter.Owner=} owner Owner object or null.
* @param {?Interpreter.prototype.Object=} proto Prototype object or null.
*/
intrp.Date = function(date, owner, proto) {
if (!date) return; // Deserializing
intrp.Object.call(/** @type {?} */ (this), owner,
(proto === undefined ? intrp.DATE : proto));
/** @type {!Date} */
this.date = date;
};
intrp.Date.prototype = Object.create(intrp.Object.prototype);
intrp.Date.prototype.constructor = intrp.Date;
intrp.Date.prototype.class = 'Date';
/**
* Return the date as a string.
* @override
*/
intrp.Date.prototype.toString = function() {
// TODO(cpcallen:perms): perms check here?
return this.date.toString();
};
/**
* Return the date as a numeric value.
* @override
*/
intrp.Date.prototype.valueOf = function() {
return this.date.valueOf();
};
/**
* Class for a regexp
* @constructor
* @struct
* @extends {Interpreter.prototype.RegExp}
* @param {!RegExp=} re The RegExp value for this RegExp object.
* @param {?Interpreter.Owner=} owner Owner object or null.
* @param {?Interpreter.prototype.Object=} proto Prototype object or null.
*/
intrp.RegExp = function(re, owner, proto) {
if (!re) return; // Deserializing
intrp.Object.call(/** @type {?} */ (this), owner,
(proto === undefined ? intrp.REGEXP : proto));
/** @type {!RegExp} */
this.regexp = re;
// lastIndex is settable, all others are read-only attributes
this.defineProperty('lastIndex', Descriptor.w.withValue(re.lastIndex));
this.defineProperty('source', Descriptor.none.withValue(re.source));
this.defineProperty('global', Descriptor.none.withValue(re.global));
this.defineProperty('ignoreCase', Descriptor.none.withValue(re.ignoreCase));
this.defineProperty('multiline', Descriptor.none.withValue(re.multiline));
};
intrp.RegExp.prototype = Object.create(intrp.Object.prototype);
intrp.RegExp.prototype.constructor = intrp.RegExp;
intrp.RegExp.prototype.class = 'RegExp';
/**
* Return the regexp as a string.
* @override
*/
intrp.RegExp.prototype.toString = function() {
// TODO(cpcallen:perms): perms check here?
if (!(this.regexp instanceof RegExp)) {
// TODO(cpcallen): ES5.1 §15.10.6.4 doesn't say what happens
// when this is applied to a non-RegExp. ES6 §21.2.5.14 does -
// and the results are possibly weird, e.g. returning
// "/undefined/undefined" or the like... :-/
return '//';
}
return this.regexp.toString();
};
/**
* Class for an error object
* @constructor
* @struct
* @extends {Interpreter.prototype.Error}
* @param {?Interpreter.Owner=} owner Owner object or null.
* @param {?Interpreter.prototype.Object=} proto Prototype object or null.
* @param {string=} message Optional message to be attached to error object.
*/
intrp.Error = function(owner, proto, message) {
intrp.Object.call(/** @type {?} */ (this), owner,
(proto === undefined ? intrp.ERROR : proto));
if (message !== undefined) {
this.defineProperty('message', Descriptor.wc.withValue(message));
}
};
intrp.Error.prototype = Object.create(intrp.Object.prototype);
intrp.Error.prototype.constructor = intrp.Error;
intrp.Error.prototype.class = 'Error';
/**
* Return the error as a string.
* @override
*/
intrp.Error.prototype.toString = function() {
// BUG(cpcallen): toString should access properties on this with
// the caller's permissions - but at present there is no way to
// determine who it was called by, so use intrp.ANYBODY instead.
var visited = intrp.toStringVisited_;
if (visited.has(this)) {
return '';
}
visited.add(this);
try {
var name = this.get('name', intrp.ANYBODY);
var message = this.get('message', intrp.ANYBODY);
name = (name === undefined) ? 'Error' : String(name);
message = (message === undefined) ? '' : String(message);
if (name) {
return message ? (name + ': ' + message) : name;
}
return message;
} finally {
visited.delete(this);
}
};
/**
* Create a .stack property on the error from the given call stack
* information, if it does not already have one. The stack property
* will be created with the permissions of the owner of the Error
* object.
*
* BUG(cpcallen): because this is called before unwinding the stack
* when an intrp.Error is thrown, and because .stack is set
* unconditionally (without perm check), any user can set .stack on
* any Error object that doesn't already have one (including
* e.g. Error.prototype) just by throwing it.
* @param {!Array} callers List of call stack frames,
* as returned by Thread.prototype.callers.
* @param {!Interpreter.Owner} perms Whose perms should be used to
* obtain (e.g.) function names, etc.?
* @override
*/
intrp.Error.prototype.makeStack = function(callers, perms) {
if (this.has('stack', intrp.ROOT)) {
return; // Do not overwrite existing .stack
}
var stack = [];
for (var i = 0; i < callers.length; i++) {
var /** string */ line = ' ';
var frame = callers[i];
if ('func' in frame) {
var /** !Interpreter.prototype.Function */ func = frame.func;
var /** string */ name;
try {
var pd = func.getOwnPropertyDescriptor('name', perms);
if (pd) {
name = String(pd.value);
} else {
name = 'anonymous function';
}
} catch (e) {
name = 'unreadable function';
}
} else if ('eval' in frame) {
name = '"' + frame.eval + '"';
} else if ('program' in frame) {
name = '"' + frame.program + '"';
}
if ('line' in frame) {
line += 'at ' + name + ' ' + frame.line + ':' + frame.col;
} else {
line += 'in ' + name;
}
stack.push(line);
}
this.defineProperty('stack', Descriptor.wc.withValue(stack.join('\n')));
};
/**
* Class for an arguments object. See ES5 §10.6 / ES6 §9.4.4.
*
* N.B.: Does not support mapped properties because we are always in
* strict mode. Does not implement the special always-throw getters
* for .callee and .caller, because we do not support getters.
* What's left is basically an ordinary object with a special
* [[Class]].
* @constructor
* @struct
* @extends {Interpreter.prototype.Arguments}
* @param {?Interpreter.Owner=} owner Owner object or null.
* @param {?Interpreter.prototype.Object=} proto Prototype object or null.
*/
intrp.Arguments = function(owner, proto) {
intrp.Object.call(/** @type {?} */ (this), owner, proto);
};
intrp.Arguments.prototype = Object.create(intrp.Object.prototype);
intrp.Arguments.prototype.constructor = intrp.Arguments;
intrp.Arguments.prototype.class = 'Arguments';
/**
* The WeakMap class from ES6.
* @constructor
* @struct
* @extends {Interpreter.prototype.WeakMap}
* @param {?Interpreter.Owner=} owner Owner object or null.
* @param {?Interpreter.prototype.Object=} proto Prototype object or null.
*/
intrp.WeakMap = function(owner, proto) {
intrp.Object.call(/** @type {?} */ (this), owner,
(proto === undefined ? intrp.WEAKMAP : proto));
/** @type {!IterableWeakMap} */
this.weakMap = new IterableWeakMap;
};
intrp.WeakMap.prototype = Object.create(intrp.Object.prototype);
intrp.WeakMap.prototype.constructor = intrp.WeakMap;
intrp.WeakMap.prototype.class = 'WeakMap';
/**
* Class for the user-visible representation of an Interpreter.Thread.
*
* Note that there should be at most one of these wrappers for each
* Interpreter.Thread, and this constructor enforces this.
* @constructor
* @struct
* @extends {Interpreter.prototype.Thread}
* @param {!Interpreter.Thread} thread Thread represented by this object.
* @param {!Interpreter.Owner} owner Owner of this thread.
* @param {?Interpreter.prototype.Object=} proto Prototype object or null.
*/
intrp.Thread = function(thread, owner, proto) {
if (!thread) return; // Deserializing
if (thread.wrapper) {
throw new Error('Duplicate Thread wrapper??');
}
intrp.Object.call(/** @type {?} */ (this), owner,
(proto === undefined ? intrp.THREAD : proto));
/** @type {!Interpreter.Thread} */
this.thread = thread;
this.thread.wrapper = this;
this.defineProperty('id', Descriptor.none.withValue(thread.id), owner);
};
intrp.Thread.prototype = Object.create(intrp.Object.prototype);
intrp.Thread.prototype.constructor = intrp.Thread;
intrp.Thread.prototype.class = 'Thread';
/////////////////////////////////////////////////////////////////////////////
// Other types, not representing JS objects.
/**
* Class for a boxed primitive. Does not @extend
* Interpreter.prototype.Object, because we do not want to expose
* these to the users. They're just used internally to simplify the
* implementation of various bits of code that are specified by
* ES5.1 or ES6 to do ToObject().
*
* @constructor
* @struct
* @extends {Interpreter.prototype.Box}
* @param {(boolean|number|string)} prim Primitive to box
*/
intrp.Box = function(prim) {
/** @private @type {(undefined|null|boolean|number|string)} */
this.primitive_ = prim;
if (typeof prim === 'boolean') {
/** @type {!Interpreter.prototype.Object} */
this.proto = intrp.BOOLEAN;
} else if (typeof prim === 'number') {
this.proto = intrp.NUMBER;
} else if (typeof prim === 'string') {
this.proto = intrp.STRING;
} else {
throw new Error('Invalid type in Box');
}
};
/**
* The [[GetOwnOwnProperty]] internal method from ES5.1 §8.12.1, as
* applied to temporary Boolean, Number and String class objects.
* @param {string} key Key (name) of property to get.
* @param {!Interpreter.Owner} perms Who is trying to get it?
* @return {!Interpreter.Descriptor|undefined} The property
* descriptor, or undefined if no such property exists.
* @override
*/
intrp.Box.prototype.getOwnPropertyDescriptor = function(key, perms) {
var pd = Object.getOwnPropertyDescriptor(this.primitive_, key);
// TODO(cpcallen): can we eliminate this pointless busywork while
// still maintaining type safety?
return pd && new Descriptor(pd.writable, pd.enumerable, pd.configurable)
.withValue(/** @type {?Interpreter.Value} */ (pd.value));
};
/**
* The [[DefineOwnProperty]] internal method from ES5.1 §8.12.9, as
* applied to temporary Boolean, Number and String class objects.
* @param {string} key Key (name) of property to set.
* @param {!Interpreter.Descriptor} desc The property descriptor.
* @param {!Interpreter.Owner} perms Who is trying to set it?
* @override
*/
intrp.Box.prototype.defineProperty = function(key, desc, perms) {
throw new intrp.Error(perms, intrp.TYPE_ERROR, "Cannot create property '" +
key + "' on " + typeof this.primitive_ + " '" + this.primitive_ + "'");
};
/**
* The [[HasProperty]] internal method from ES5.1 §8.12.6, as
* applied to temporary Boolean, Number and String class objects.
* @param {string} key Key (name) of property to get.
* @param {!Interpreter.Owner} perms Who is trying to get it?
* @return {boolean} The value of the property, or undefined.
* @override
*/
intrp.Box.prototype.has = function(key, perms) {
// Important: we want to ignore any extra properties on (e.g.) the
// native String.prototype, but be sure to find ones on
// intrp.String.prototype.
if (Object.getOwnPropertyDescriptor(this.primitive_, key)) {
return true;
}
// Defer to prototype.
return this.proto.has(key, perms);
};
/**
* The [[Get]] internal method from ES5.1 §8.12.3, as applied to
* temporary Boolean, Number and String class objects.
* @param {string} key Key (name) of property to get.
* @param {!Interpreter.Owner} perms Who is trying to get it?
* @return {?Interpreter.Value} The value of the property, or undefined.
* @override
*/
intrp.Box.prototype.get = function(key, perms) {
// Important: we want to ignore any extra properties on (e.g.) the
// native String.prototype, but be sure to find ones on
// intrp.String.prototype.
var pd = Object.getOwnPropertyDescriptor(this.primitive_, key);
if (pd) {
return /** @type {string|number} */(pd.value);
}
// Defer to prototype.
return this.proto.get(key, perms);
};
/**
* The [[Set]] internal method from ES5.1 §8.12.5, as
* applied to temporary Boolean, Number and String class objects.
* @param {string} key Key (name) of property to set.
* @param {!Interpreter.Owner} perms Who is trying to set it?
* @param {?Interpreter.Value} value The new value of the property.
* @override
*/
intrp.Box.prototype.set = function(key, value, perms) {
throw new intrp.Error(perms, intrp.TYPE_ERROR, "Cannot set property '" +
key + "' on " + typeof this.primitive_ + " '" + this.primitive_ + "'");
};
/**
* The [[Delete]] internal method from ES5.1 §8.12.7, as applied to
* temporary Boolean, Number and String class objects.
* @param {string} key Key (name) of property to get.
* @param {!Interpreter.Owner} perms Who is trying to get it?
* @return {boolean} True iff successful.
*/
intrp.Box.prototype.deleteProperty = function(key, perms) {
// Attempting to delete property from primitive value. Succeeds
// only if property doesn't exist.
if (Object.getOwnPropertyDescriptor(this.primitive_, key)) {
throw new intrp.Error(perms, intrp.TYPE_ERROR,
"Cannot delete property '" + key + "' on " + typeof this.primitive_ +
" '" + this.primitive_ + "'");
}
return true;
};
/**
* The [[OwnPropertyKeys]] internal method from ES6 §9.1.12, as
* applied to temporary Boolean, Number and String class objects.
* @param {!Interpreter.Owner} perms Who is trying to get it?
* @return {!Array} An array of own property keys.
*/
intrp.Box.prototype.ownKeys = function(perms) {
// Cast necessitated by compiler bug:
// https://github.com/google/closure-compiler/issues/2878
return Object.getOwnPropertyNames(/** @type {?} */(this.primitive_));
};
/**
* Convert this boxed primitive into a string.
* @return {string} String value.
* @override
*/
intrp.Box.prototype.toString = function() {
return String(this.primitive_);
};
/**
* Return the boxed primitive value.
* @return {?Interpreter.Value} Value.
* @override
*/
intrp.Box.prototype.valueOf = function() {
return this.primitive_;
};
/**
* Server is an (owner, port, proto, (extra info)) tuple representing a
* listening server. It encapsulates node's net.Server type, with
* some additional info needed to implement the connectionListen()
* API. In its present form it is not suitable for exposure as a
* userland pseduoObject, but it is intended to be easily adaptable
* for that if desired.
* @constructor
* @struct
* @extends {Interpreter.prototype.Server}
* @param {!Interpreter.Owner} owner Owner object or null.
* @param {number} port Port to listen on.
* @param {!Interpreter.prototype.Object} proto Prototype object for
* new connections.
* @param {number=} timeLimit Maximum runtime without suspending (in ms).
*/
intrp.Server = function(owner, port, proto, timeLimit) {
// Special excepetion: port === undefined when deserializing, in
// violation of usual type rules.
if ((port !== (port >>> 0) || port > 0xffff) && port !== undefined) {
throw new RangeError('invalid port ' + port);
}
/** @type {!Interpreter.Owner} */
this.owner = owner;
/** @type {number} */
this.port = port;
/** @type {!Interpreter.prototype.Object} */
this.proto = proto;
/** @type {number} */
this.timeLimit = timeLimit || 0;
/** @type {!net.Server} */
this.server_ = new net.Server({allowHalfOpen: true});
// Create the net.Server instance and set up event handlers but
// don't yet start it listening.
var server = this; // So we can refer to it in handlers below.
this.server_.on('connection', function(socket) {
intrp.log('net', 'Connection on :%s from %s:%s',
server.port, socket.remoteAddress, socket.remotePort);
// TODO(cpcallen): Add localhost test here, like this - only
// also allow IPV6 connections:
// if (socket.remoteAddress != '127.0.0.1') {
// // Reject connections other than from localhost.
// intrp.log('net', 'Rejecting connection from ' +
// socket.remoteAddress);
// socket.end('Connection rejected.');
// return;
// }
// Create new object from proto and call onConnect.
var obj = new intrp.Object(server.owner, server.proto);
obj.socket = socket;
var func = obj.get('onConnect', server.owner);
if (func instanceof intrp.Function && server.owner !== null) {
// TODO(cpcallen:perms): Is server.owner the correct owner for
// the thread? Note that this will typically be root, and
// .onConnect will therefore get caller perms === root, which
// is probably dangerous. Here and several places below.
intrp.createThreadForFuncCall(
server.owner, func, obj, [], undefined, server.timeLimit);
}
// Handle socket closing completely.
socket.on('close', function() {
intrp.log('net', 'Connection on :%s from %s:%s closed',
server.port, socket.remoteAddress, socket.remotePort);
var func = obj.get('onClose', server.owner);
if (func instanceof intrp.Function && server.owner !== null) {
intrp.createThreadForFuncCall(
server.owner, func, obj, [], undefined, server.timeLimit);
}
});
// Handle incoming data from clients. N.B. that data is a
// node buffer object, so we must convert it to a string
// before passing it to user code.
socket.on('data', function(data) {
var func = obj.get('onReceive', server.owner);
if (func instanceof intrp.Function && server.owner !== null) {
intrp.createThreadForFuncCall(
server.owner, func, obj, [String(data)],
undefined, server.timeLimit);
}
});
// Handle far end closing connection.
socket.on('end', function() {
intrp.log('net', 'Connection on :%s from %s:%s ended',
server.port, socket.remoteAddress, socket.remotePort);
var func = obj.get('onEnd', server.owner);
if (func instanceof intrp.Function && server.owner !== null) {
intrp.createThreadForFuncCall(
server.owner, func, obj, [], undefined, server.timeLimit);
}
});
// Handle errors.
socket.on('error', function(error) {
intrp.log('net', 'Socket error on :%s from %s:%s: %s: %s',
server.port, socket.remoteAddress, socket.remotePort,
error.name, error.message);
var func = obj.get('onError', server.owner);
if (func instanceof intrp.Function && server.owner !== null) {
var userError = intrp.errorNativeToPseudo(error, server.owner);
intrp.createThreadForFuncCall(
server.owner, func, obj, [userError],
undefined, server.timeLimit);
}
});
// TODO(cpcallen): save new object somewhere we can find it
// later (when we want to obtain list of connected objects).
});
this.server_.on('listening', function() {
var addr = this.address();
intrp.log('net', 'Listening on %s %s:%s',
addr.family, addr.address, addr.port);
});
this.server_.on('error', function(error) {
intrp.log('net', 'Error on :%s: %s: %s',
server.port, error.name, error.message);
});
this.server_.on('close', function() {
intrp.log('net', 'Stopped listening on :%s', server.port);
});
};
/**
* Start a Server object listening on its assigned port.
* @param {!function(!Error=)=} callback
* Callback that will be called once listening has begun, or with
* an Error argument if listening fails.
*/
intrp.Server.prototype.listen = function(callback) {
// Invariant checks.
if (this.port === undefined ||
!(this.proto instanceof intrp.Object) ||
!(this.server_ instanceof net.Server)) {
throw new Error('invalid Server state');
}
if (intrp.listeners_[this.port] !== this) {
throw new Error('Listening on server not listed in .listeners_??');
}
// Set up callbacks. Fiddly, because we want to temporarily hook
// the error handler but be sure to unhook it whether the listen
// call succeeds or fails.
var /** boolean */ done = false;
/** @type {function(this:net.Server, !Error=)} */
function hook(error) {
if (done) throw new Error('unexpected multiple callbacks');
done = true;
this.removeListener(events.errorMonitor, hook);
if (callback) callback(error);
};
this.server_.on(events.errorMonitor, hook);
this.server_.listen(this.port, hook);
};
/**
* Stop a Server object listening on its assigned port.
* @param {!function()=} callback Callback that will be called after
* listening has ceased.
*/
intrp.Server.prototype.unlisten = function(callback) {
// Invariant checks.
if (this.port === undefined ||
!(this.proto instanceof intrp.Object) ||
!(this.server_ instanceof net.Server)) {
throw new Error('invalid Server state');
}
this.server_.close(callback);
};
};
///////////////////////////////////////////////////////////////////////////////
// Miscellaneous internal classes not used for storing state and not exported
///////////////////////////////////////////////////////////////////////////////
/**
* Type for options object for constructing a NativeFunction.
* @typedef {{name: (string|undefined),
* length: (number|undefined),
* id: (string|undefined),
* call: (Interpreter.NativeCallImpl|undefined),
* construct: (Interpreter.NativeConstructImpl|undefined),
* owner: (!Interpreter.Owner|undefined),
* proto: (?Interpreter.prototype.Object|undefined)}}
*/
var NativeFunctionOptions;
/**
* Type for property descriptors, as used by
* Interpreter.prototype.Object.prototype.defineProperty and
* ...getOwnPropertyDescriptor.
* @record
*/
Interpreter.Descriptor = function() {};
/** @type {(?Interpreter.Value|undefined)} */
Interpreter.Descriptor.prototype.value;
/** @type {boolean|undefined} */
Interpreter.Descriptor.prototype.writable;
/** @type {boolean|undefined} */
Interpreter.Descriptor.prototype.enumerable;
/** @type {boolean|undefined} */
Interpreter.Descriptor.prototype.configurable;
/**
* Convenience class for creating Interpreter.Descriptors, with
* commonly-used examples and a function to easily create new
* descriptors from a prototype.
* @constructor
* @struct
* @implements {Interpreter.Descriptor}
* @param {boolean=} writable Is the property writable?
* @param {boolean=} enumerable Is the property enumerable?
* @param {boolean=} configurable Is the property configurable?
*/
var Descriptor = function(writable, enumerable, configurable) {
if (writable !== undefined) this.writable = writable;
if (enumerable !== undefined) this.enumerable = enumerable;
if (configurable !== undefined) this.configurable = configurable;
};
/* Type declaration for the properties that
* intrp.Object.prototype.defineProperty expects to see on a
* descriptor. We use "|undefined)", but what we really mean is "|not
* defined)" because unfortunately Closure Compiler's type system has
* no way to represent the latter.
*/
/** @type {(?Interpreter.Value|undefined)} */
Descriptor.prototype.value;
/** @type {boolean|undefined} */
Descriptor.prototype.writable;
/** @type {boolean|undefined} */
Descriptor.prototype.enumerable;
/** @type {boolean|undefined} */
Descriptor.prototype.configurable;
/**
* Returns a new descriptor with the same properties as this one, with
* the addition of a value: member with the given value.
* @param {?Interpreter.Value} value Value for the new descriptor.
* @return {!Descriptor}
*/
Descriptor.prototype.withValue = function(value) {
var desc = /** @type{!Descriptor} */(Object.create(this));
desc.value = value;
return desc;
};
/** @const */ Descriptor.wec = new Descriptor(true, true, true);
/** @const */ Descriptor.ec = new Descriptor(false, true, true);
/** @const */ Descriptor.wc = new Descriptor(true, false, true);
/** @const */ Descriptor.we = new Descriptor(true, true, false);
/** @const */ Descriptor.w = new Descriptor(true, false, false);
/** @const */ Descriptor.e = new Descriptor(false, true, false);
/** @const */ Descriptor.c = new Descriptor(false, false, true);
/** @const */ Descriptor.none = new Descriptor(false, false, false);
///////////////////////////////////////////////////////////////////////////////
// Static Analysis Functions
///////////////////////////////////////////////////////////////////////////////
/**
* Get the list of BoundNames for an AST sub-tree.
* @param {!Node} node AST node (program or function).
* @return {!Object} A map of
* bound names. The keys are var and function declarations
* appearing in the subtree rooted at node; the values are
* undefined for VariableDeclarations or a FunctionDeclaration
* node for FunctionDeclarations.
*/
var getBoundNames = function(node) {
if (!node['boundNames']) {
performStaticAnalysis(node);
}
return node['boundNames'];
};
/**
* Check if an AST contains Identifiers named "arguments" or "eval".
* @param {!Node} node AST node (program or function).
* @return boolean True iff tree rooted at node contains an Identifier
* named "arguments" or "eval", not including any
* FunctionDeclaration or FunctionExpression subtrees.
*/
var hasArgumentsOrEval = function(node) {
if (node['hasArgumentsOrEval'] === undefined) {
performStaticAnalysis(node);
}
return node['hasArgumentsOrEval'];
};
/**
* The IsAnonymousFunctionDefinition specification method from ES6 §14.1.9
* @param {!Node} node The node to be tested.
* @return {boolean} True if node is an anonymous function expression.
*/
var isAnonymousFunctionDefinition = function(node) {
return node['type'] === 'FunctionExpression' && !node['id'];
};
/**
* The IsIdentifierRef specification method from ES6 §12.2.1.4 and §12.3.1.4
* @param {!Node} node The node to be tested.
* @return {boolean} True if node is an identifier.
*/
var isIdentifierRef = function(node) {
return node['type'] === 'Identifier';
};
/**
* Returns true iff node is a MemberExpression.
* @param {!Node} node The node to be tested.
* @return {boolean} True if node is an identifier.
*/
var isMemberRef = function(node) {
return node['type'] === 'MemberExpression';
};
/**
* Walk an AST (or sub-tree), collecting bound names by looking for
* VariableDeclaration and FunctionDeclaration nodes, and checking for
* Identifiers named "arguments" or "eval".
*
* The BoundNames will be stored on node['boundNames'] as an
* !Object, where the keys are
* the names of VariableDeclaration and FunctionDeclarations, and the
* values are undefined for VariableDeclarations or a
* FunctionDeclaration node for FunctionDeclarations.
*
* If any Identifier named "arguments" or "eval" is seen, and
* node['hasArgumentsOrEval'] will be set to true; otherwise it will
* be set to false.
*
* @param {!Node} node AST node (program or function).
* @return {void}
*/
var performStaticAnalysis = function(node) {
/** !Object */
var boundNames = node['boundNames'] = Object.create(null);
var hasArgumentsOrEval = false;
walk(node);
node['hasArgumentsOrEval'] = hasArgumentsOrEval;
/**
* Recursively Walk an AST sub-tree, populating boundNames as we go.
* @param {!Node} node AST node (program or function).
* Nested function writes to boundNames and hasArgumentsOrEval.
* @return {void}
* TODO(cpcallen): Limit recursion to only AST nodes that can
* contain declarations (e.g. no ExpressionStatements?)
*/
function walk(node) {
if (node['type'] === 'VariableDeclaration') {
for (var i = 0; i < node['declarations'].length; i++) {
// VariableDeclarations can't overwrite previous
// FunctionDeclarations (but initializer might at run time).
var name = node['declarations'][i]['id']['name'];
if (!(name in boundNames)) {
boundNames[name] = undefined;
}
}
} else if (node['type'] === 'Identifier') {
name = node['name'];
if (name === 'arguments' || name === 'eval') {
hasArgumentsOrEval = true;
}
} else if (node['type'] === 'FunctionDeclaration') {
// FunctionDeclarations overwrite any previous decl of the same name.
name = node['id']['name'];
boundNames[name] = node;
return; // Do not recurse into function.
} else if (node['type'] === 'FunctionExpression') {
return; // Do not recurse into function.
}
// Visit node's children.
for (var key in node) {
var prop = node[key];
if (prop && typeof prop === 'object') {
if (Array.isArray(prop)) {
for (var i = 0; i < prop.length; i++) {
if (prop[i] && prop[i] instanceof Node) {
walk(prop[i]);
}
}
} else {
if (prop instanceof Node) {
walk(prop);
}
}
}
}
}
};
///////////////////////////////////////////////////////////////////////////////
// Step Functions: one to handle each node type.
///////////////////////////////////////////////////////////////////////////////
/**
* Typedef for step functions.
*
* TODO(cpcallen): It should be possible to declare individual
* functions below using this typedef (instead of listing full type
* details for each once
* https://github.com/google/closure-compiler/issues/2857 is fixed.
* @typedef {function(this: Interpreter,
* !Interpreter.Thread,
* !Array,
* !Interpreter.State,
* !Node)
* : (!Interpreter.State|undefined)}
*/
Interpreter.StepFunction;
/**
* 'Map' of node types to their corresponding step functions. Note
* that a Map is much slower than a null-parent object (v8 in 2017).
* @const {!Object}
*/
var stepFuncs_ = Object.create(null);
/**
* @this {!Interpreter}
* @param {!Interpreter.Thread} thread
* @param {!Array} stack
* @param {!Interpreter.State} state
* @param {!Node} node
* @return {!Interpreter.State|undefined}
*/
stepFuncs_['ArrayExpression'] = function(thread, stack, state, node) {
var n = state.n_;
if (!state.tmp_) { // Create Array object
state.tmp_ = new this.Array(state.scope.perms);
} else { // Save most recently-evaluated element.
state.tmp_.set(String(n), state.value, state.scope.perms);
n++;
}
var /** !Array */ elements = node['elements'];
// Skip any elided elements - they're not defined, not undefined.
while (n < elements.length && ! elements[n]) {
n++;
}
// Evaluate next element, if we've not run past end.
if (n < elements.length) {
state.n_ = n;
return new Interpreter.State(elements[n], state.scope);
}
state.tmp_.set('length', elements.length, state.scope.perms);
stack.pop();
stack[stack.length - 1].value = state.tmp_;
};
/**
* @this {!Interpreter}
* @param {!Interpreter.Thread} thread
* @param {!Array} stack
* @param {!Interpreter.State} state
* @param {!Node} node
* @return {!Interpreter.State|undefined}
*/
stepFuncs_['AssignmentExpression'] = function(thread, stack, state, node) {
if (state.step_ === 0) { // Get Reference to left.
state.step_ = 1;
// Get Reference for left subexpression.
return new Interpreter.State(node['left'], state.scope, true);
}
if (!state.ref) throw new TypeError('left subexpression not an LVALUE??');
if (state.step_ === 1) { // Evaluate right.
if (node['operator'] !== '=') {
state.tmp_ = this.getValue(state.ref, state.scope.perms);
}
state.step_ = 2;
return new Interpreter.State(node['right'], state.scope);
}
// state.step_ === 2: Got operand(s); do assignment.
var rightValue = state.value;
var value = state.tmp_;
switch (node['operator']) {
// Regular assignment is special due to function naming & destructuring.
case '=':
value = rightValue;
// Set name if anonymous function expression.
if (isAnonymousFunctionDefinition(node['right']) &&
(isIdentifierRef(node['left']) ||
(this.options.methodNames && isMemberRef(node['left'])))) {
var func = /** @type {!Interpreter.prototype.Function} */(value);
// TODO(ES6): Check that func does not already have a 'name'
// own property before calling setName? (Spec requires, but
// unclear why since we know RHS is anonymous. Proxies?)
func.setName(state.ref[1]);
}
break;
// All the rest are simple and similar.
case '+=': value += rightValue; break;
case '-=': value -= rightValue; break;
case '*=': value *= rightValue; break;
case '/=': value /= rightValue; break;
case '%=': value %= rightValue; break;
case '<<=': value <<= rightValue; break;
case '>>=': value >>= rightValue; break;
case '>>>=': value >>>= rightValue; break;
case '&=': value &= rightValue; break;
case '^=': value ^= rightValue; break;
case '|=': value |= rightValue; break;
default:
throw new SyntaxError(
'Unknown assignment expression: ' + node['operator']);
}
this.setValue(state.ref, value, state.scope.perms);
stack.pop();
stack[stack.length - 1].value = value;
};
/**
* @this {!Interpreter}
* @param {!Interpreter.Thread} thread
* @param {!Array} stack
* @param {!Interpreter.State} state
* @param {!Node} node
* @return {!Interpreter.State|undefined}
*/
stepFuncs_['BinaryExpression'] = function(thread, stack, state, node) {
if (state.step_ === 0) { // Evaluate left.
state.step_ = 1;
return new Interpreter.State(node['left'], state.scope);
}
if (state.step_ === 1) { // Save left; evaluate right.
state.step_ = 2;
state.tmp_ = state.value;
return new Interpreter.State(node['right'], state.scope);
}
// state.step_ === 2: Got operands; do binary operation.
var leftValue = state.tmp_;
var rightValue = state.value;
var /** ?Interpreter.Value */ value;
switch (node['operator']) {
case '==': value = leftValue == rightValue; break;
case '!=': value = leftValue != rightValue; break;
case '===': value = leftValue === rightValue; break;
case '!==': value = leftValue !== rightValue; break;
case '>': value = leftValue > rightValue; break;
case '>=': value = leftValue >= rightValue; break;
case '<': value = leftValue < rightValue; break;
case '<=': value = leftValue <= rightValue; break;
case '+': value = leftValue + rightValue; break;
case '-': value = leftValue - rightValue; break;
case '*': value = leftValue * rightValue; break;
case '/': value = leftValue / rightValue; break;
case '%': value = leftValue % rightValue; break;
case '&': value = leftValue & rightValue; break;
case '|': value = leftValue | rightValue; break;
case '^': value = leftValue ^ rightValue; break;
case '<<': value = leftValue << rightValue; break;
case '>>': value = leftValue >> rightValue; break;
case '>>>': value = leftValue >>> rightValue; break;
case 'in':
if (!(rightValue instanceof this.Object)) {
throw new this.Error(state.scope.perms, this.TYPE_ERROR,
"'in' expects an object, not '" + rightValue + "'");
}
value = rightValue.has(String(leftValue), state.scope.perms);
break;
case 'instanceof':
if (!(rightValue instanceof this.Function)) {
throw new this.Error(state.scope.perms, this.TYPE_ERROR,
'Right-hand side of instanceof is not a function');
}
value = rightValue.hasInstance(leftValue, state.scope.perms);
break;
default:
throw new SyntaxError('Unknown binary operator: ' + node['operator']);
}
stack.pop();
stack[stack.length - 1].value = value;
};
/**
* @this {!Interpreter}
* @param {!Interpreter.Thread} thread
* @param {!Array} stack
* @param {!Interpreter.State} state
* @param {!Node} node
* @return {!Interpreter.State|undefined}
*/
stepFuncs_['BlockStatement'] = function(thread, stack, state, node) {
var n = state.n_;
var /** ?Node */ statement = node['body'][n];
if (statement) {
state.n_ = n + 1;
return new Interpreter.State(statement, state.scope);
}
stack.pop();
};
/**
* @this {!Interpreter}
* @param {!Interpreter.Thread} thread
* @param {!Array} stack
* @param {!Interpreter.State} state
* @param {!Node} node
* @return {!Interpreter.State|undefined}
*/
stepFuncs_['BreakStatement'] = function(thread, stack, state, node) {
if (!thread) throw new Error('No thread in BreakStatement??');
this.unwind_(thread, Interpreter.CompletionType.BREAK, undefined,
node['label'] ? node['label']['name'] : undefined
);
};
/**
* Extra info used by CallExpression, NewExpression and Call step
* functions:
* - func: the function to be called or constructed.
* - this: the value of 'this' for the call.
* - arguments: (evaluated) arguments to the call.
* - directEval: is this a direct call to the global eval function?
* - construct: is this a [[Construct]] call (rather than default [[Call]])?
* - funcState: place for NativeFunction impls to save additional state info.
* TODO(cpcallen): give funcState a narrower type.
* @typedef {{func: ?Interpreter.prototype.Function,
* this: ?Interpreter.Value,
* arguments: !Array,
* directEval: boolean,
* construct: boolean,
* funcState: *}}
*/
Interpreter.CallInfo;
/**
* CallExpression AND NewExpression: the initial part that evaluates
* the arguments etc.
* @this {!Interpreter}
* @param {!Interpreter.Thread} thread
* @param {!Array} stack
* @param {!Interpreter.State} state
* @param {!Node} node
* @return {!Interpreter.State|undefined}
*/
stepFuncs_['CallExpression'] = function(thread, stack, state, node) {
if (state.step_ === 0) { // Evaluate callee.
// Special hack for Code City's "new 'foo'" syntax.
if (node['type'] === 'NewExpression' &&
node['callee']['type'] === 'Literal' &&
typeof node['callee']['value'] === 'string' &&
node['arguments'].length === 0) {
var builtin = node['callee']['value'];
if (!this.builtins.has(builtin)) {
throw new this.Error(state.scope.perms, this.REFERENCE_ERROR,
builtin + ' is not a builtin');
}
stack.pop();
stack[stack.length - 1].value = this.builtins.get(builtin);
return;
}
state.step_ = 1;
// Get reference for callee, because we need to get value of 'this'.
return new Interpreter.State(node['callee'], state.scope, true);
}
if (state.step_ === 1) { // Evaluated callee, possibly got a reference.
// Determine value of the function.
state.step_ = 2;
var info = {func: null,
this: undefined, // Since we have no global object.
arguments: [],
directEval: false,
construct: state.node['type'] === 'NewExpression',
funcState: undefined};
if (state.ref) { // Callee was MemberExpression or Identifier.
state.tmp_ = this.getValue(state.ref, state.scope.perms);
if (state.ref[0] instanceof Interpreter.Scope) {
// (Globally or locally) named function - maybe named 'eval'?
info.directEval = (state.ref[1] === 'eval');
} else {
// Method call; save 'this' value.
info.this = state.ref[0];
}
} else { // Callee already fully evaluated.
state.tmp_ = state.value;
}
state.info_ = info;
state.n_ = 0;
}
if (state.step_ === 2) { // Evaluating arguments.
if (state.n_ !== 0) { // Save previous arg.
state.info_.arguments[state.info_.arguments.length] = state.value;
}
if (node['arguments'][state.n_]) { // Evaluate next arg.
return new Interpreter.State(node['arguments'][state.n_++], state.scope);
}
// All args evaluated. Check info_.func is actually a function.
state.step_ = 3; // N.B: SEE NOTE 1 ABOVE!
if (!(state.tmp_ instanceof this.Function)) {
throw new this.Error(state.scope.perms, this.TYPE_ERROR,
state.tmp_ + ' is not a function');
}
state.info_.func = state.tmp_;
}
// state.step_ === 3: Done evaluating arguments; do function call.
// Dummy Node (used only for type and position).
var callNode = new Node;
callNode['type'] = 'Call';
callNode['stepFunc'] = stepFuncs_['Call'];
callNode['start'] = node['start'];
// New State for Call (or Construct).
var callState = new Interpreter.State(callNode, state.scope);
callState.info_ = state.info_;
// Replace this CallExpression State with the new Call State.
stack[stack.length - 1] = callState;
// We know exactly which step function will get called next, so go
// straight there:
return stepFuncs_['Call'].call(this, thread, stack, callState, callNode);
};
/**
* Call: the latter part of CallExpression / NewExpression, when the
* actual call/construct takes place.
* @this {!Interpreter}
* @param {!Interpreter.Thread} thread
* @param {!Array} stack
* @param {!Interpreter.State} state
* @param {!Node} node
* @return {!Interpreter.State|undefined}
*/
stepFuncs_['Call'] = function(thread, stack, state, node) {
/* NOTE: Beware that, because
*
* - an async function might not *actually* be async, and thus
* - its .call function might call its reject before returning, and
* - reject will unwind the stack, and
* - Interpreter#step and Interpreter#run will push any State
* returned by a step function such as this one,
*
* this Call step function MUST NOT return a State after
* calling .call (or .construct), or the thread might end up in some
* nonsensical, corrupt configuration.
*
* (It's fine to return a State if it *hasn't* called .call or
* .construct - for example, on a subsequent invocation - though
* there is no obvious reason to do so.)
*/
if (state.step_ === 0) { // Done evaluating arguments; do function call.
state.step_ = 1;
if (this.options.stackLimit && stack.length > this.options.stackLimit) {
throw new this.Error(state.scope.perms, this.RANGE_ERROR,
'Maximum call stack size exceeded');
}
var func = state.info_.func;
var args = state.info_.arguments;
// Abort call if out of time, unless it's a call to Thread.suspend().
if (func !== this.builtins.get('Thread.suspend')) {
try {
this.checkTimeLimit_(state.scope.perms);
} catch (e) {
stack.pop(); // Remove not-called function from stack trace.
throw e;
}
}
var r =
state.info_.construct ?
func.construct(this, thread, state, args) :
func.call(this, thread, state, state.info_.this, args);
if (r instanceof Interpreter.FunctionResult) {
switch (r) {
case Interpreter.FunctionResult.AwaitValue:
return;
case Interpreter.FunctionResult.Block:
thread.status = Interpreter.Thread.Status.BLOCKED;
return;
case Interpreter.FunctionResult.CallAgain:
state.step_ = 0;
return;
case Interpreter.FunctionResult.Sleep:
thread.status = Interpreter.Thread.Status.SLEEPING;
return;
default:
throw new Error('Unknown FunctionResult??');
}
}
state.value = r;
}
// state.step_ === 1: Execution done; handle return value.
stack.pop();
// Previous stack frame may not exist if this is a setTimeout function.
if (stack.length > 0) {
stack[stack.length - 1].value = state.value;
}
};
/**
* ConditionalExpression AND IfStatement. The only difference is the
* latter does not return a value to the parent state.
* @this {!Interpreter}
* @param {!Interpreter.Thread} thread
* @param {!Array} stack
* @param {!Interpreter.State} state
* @param {!Node} node
* @return {!Interpreter.State|undefined}
*/
stepFuncs_['ConditionalExpression'] = function(thread, stack, state, node) {
if (state.step_ === 0) { // Evaluate test.
state.step_ = 1;
return new Interpreter.State(node['test'], state.scope);
}
// state.step_ === 1: Test evaluated; result is in .value
var value = Boolean(state.value);
stack.pop();
if (value && node['consequent']) {
// Execute 'if' block.
return new Interpreter.State(node['consequent'], state.scope);
}
if (!value && node['alternate']) {
// Execute 'else' block.
return new Interpreter.State(node['alternate'], state.scope);
}
// eval('1;if(false){2}') -> undefined
thread.value = undefined;
};
/**
* @this {!Interpreter}
* @param {!Interpreter.Thread} thread
* @param {!Array} stack
* @param {!Interpreter.State} state
* @param {!Node} node
* @return {!Interpreter.State|undefined}
*/
stepFuncs_['ContinueStatement'] = function(thread, stack, state, node) {
this.unwind_(thread, Interpreter.CompletionType.CONTINUE, undefined,
node['label'] ? node['label']['name'] : undefined);
};
/**
* @this {!Interpreter}
* @param {!Interpreter.Thread} thread
* @param {!Array} stack
* @param {!Interpreter.State} state
* @param {!Node} node
* @return {!Interpreter.State|undefined}
*/
stepFuncs_['DebuggerStatement'] = function(thread, stack, state, node) {
// Do nothing. May be overridden by developers.
stack.pop();
};
/**
* DoWhileStatement AND WhileStatement. The only difference is the
* former skips evaluating the test expression the first time through.
* @this {!Interpreter}
* @param {!Interpreter.Thread} thread
* @param {!Array} stack
* @param {!Interpreter.State} state
* @param {!Node} node
* @return {!Interpreter.State|undefined}
*/
stepFuncs_['DoWhileStatement'] = function(thread, stack, state, node) {
if (state.step_ === 0) { // Decide whether to skip first test.
state.step_ = 1;
if (node['type'] === 'DoWhileStatement') {
// First iteration of do/while executes without checking test.
state.value = true;
state.step_ = 2;
}
}
if (state.step_ === 1) { // Evaluate condition.
// Terminate loop if out of time.
this.checkTimeLimit_(state.scope.perms);
state.step_ = 2;
return new Interpreter.State(node['test'], state.scope);
}
// state.step_ === 2: Check result of evaluation.
if (!state.value) { // Done, exit loop.
stack.pop();
} else if (node['body']) { // Execute the body.
state.step_ = 1;
state.isLoop = true;
return new Interpreter.State(node['body'], state.scope);
}
};
/**
* @this {!Interpreter}
* @param {!Interpreter.Thread} thread
* @param {!Array} stack
* @param {!Interpreter.State} state
* @param {!Node} node
* @return {!Interpreter.State|undefined}
*/
stepFuncs_['EmptyStatement'] = function(thread, stack, state, node) {
stack.pop();
};
/**
* @this {!Interpreter}
* @param {!Interpreter.Thread} thread
* @param {!Array} stack
* @param {!Interpreter.State} state
* @param {!Node} node
* @return {!Interpreter.State|undefined}
*/
stepFuncs_['EvalProgram_'] = function(thread, stack, state, node) {
var n = state.n_;
var /** ?Node */ expression = node['body'][n];
if (expression) {
state.n_ = n + 1;
return new Interpreter.State(expression, state.scope);
}
stack.pop();
stack[stack.length - 1].value = thread.value;
};
/**
* @this {!Interpreter}
* @param {!Interpreter.Thread} thread
* @param {!Array} stack
* @param {!Interpreter.State} state
* @param {!Node} node
* @return {!Interpreter.State|undefined}
*/
stepFuncs_['ExpressionStatement'] = function(thread, stack, state, node) {
if (state.step_ === 0) { // Evaluate expression.
state.step_ = 1;
return new Interpreter.State(node['expression'], state.scope);
}
// state.step_ === 1: Handle completion value.
stack.pop();
// Save this value to interpreter.value for use as a return value if
// this code is inside an eval function.
//
// TODO(cpcallen): This is suspected to not be strictly correct
// compared to how the ES5.1 spec defines completion values. Add
// tests to prove it one way or the other.
thread.value = state.value;
};
/**
* Extra info used by ForInStatement step function.
* @typedef {{iter: !Interpreter.PropertyIterator,
key: string}}
*/
Interpreter.ForInInfo;
/**
* @this {!Interpreter}
* @param {!Interpreter.Thread} thread
* @param {!Array} stack
* @param {!Interpreter.State} state
* @param {!Node} node
* @return {!Interpreter.State|undefined}
*/
stepFuncs_['ForInStatement'] = function(thread, stack, state, node) {
while (true) {
switch (state.step_) {
case 0: // Initial set-up.
// First, variable initialization is illegal in strict mode.
if (node['left']['declarations'] &&
node['left']['declarations'][0]['init']) {
throw new this.Error(state.scope.perms, this.SYNTAX_ERROR,
'for-in loop variable declaration may not have an initializer.');
}
state.step_ = 1;
state.isLoop = true; // TODO(cpcallen): remove or declare.
// Second, look up the object. Only do so once, ever.
return new Interpreter.State(node['right'], state.scope);
case 1: // Check right, create PropertyIterator.
if (state.value === null || state.value === undefined) {
// No iterations to do; exit loop.
stack.pop();
return;
}
var obj = this.toObject(state.value, state.scope.perms);
var iter = new Interpreter.PropertyIterator(obj, state.scope.perms);
state.info_ = {iter: iter, key: ''};
// FALL THROUGH
case 2: // Find the property name for this iteration; do node.left.
// Terminate loop if out of time.
this.checkTimeLimit_(state.scope.perms);
var key = state.info_.iter.next();
if (key === undefined) {
// Done; exit loop.
stack.pop();
return;
}
state.info_.key = key;
// Get (or create) a Reference to node.left:
var /** ?Node */ left = node['left'];
if (left['type'] !== 'VariableDeclaration') {
state.step_ = 3;
// Arbitrary left side, e.g.: for (foo().bar in y).
// Get Reference to whatever left side turns out to be.
return new Interpreter.State(left, state.scope, true);
}
// Inline variable declaration: for (var x in y)
var lhsName = left['declarations'][0]['id']['name'];
state.ref = [state.scope.resolve(lhsName), lhsName];
// FALL THROUGH
case 3: // Got .ref to variable to set. Set it next key.
if (!state.ref) throw new TypeError('loop variable not an LVALUE??');
this.setValue(state.ref, state.info_.key, state.scope.perms);
// Execute the body if there is one, followed by next iteration.
state.step_ = 2;
if (node['body']) {
return new Interpreter.State(node['body'], state.scope);
}
}
}
};
/**
* @this {!Interpreter}
* @param {!Interpreter.Thread} thread
* @param {!Array} stack
* @param {!Interpreter.State} state
* @param {!Node} node
* @return {!Interpreter.State|undefined}
*/
stepFuncs_['ForStatement'] = function(thread, stack, state, node) {
// If we've just evaluated node.test, and result was false, terminate loop.
if (state.step_ === 2 && !state.value) {
stack.pop();
return;
}
while (true) {
switch (state.step_) {
case 0: // Eval init expression.
state.step_ = 1;
state.isLoop = true; // TODO(cpcallen): remove or declare.
if (node['init']) {
return new Interpreter.State(node['init'], state.scope);
}
// FALL THROUGH
case 1: // Eval test expression.
// Terminate loop if out of time.
this.checkTimeLimit_(state.scope.perms);
state.step_ = 2;
if (node['test']) {
return new Interpreter.State(node['test'], state.scope);
}
// FALL THROUGH
case 2: // Eval body.
state.step_ = 3;
return new Interpreter.State(node['body'], state.scope);
case 3: // Eval update expression.
state.step_ = 1;
if (node['update']) {
return new Interpreter.State(node['update'], state.scope);
}
}
}
};
/**
* @this {!Interpreter}
* @param {!Interpreter.Thread} thread
* @param {!Array} stack
* @param {!Interpreter.State} state
* @param {!Node} node
* @return {!Interpreter.State|undefined}
*/
stepFuncs_['FunctionDeclaration'] = function(thread, stack, state, node) {
// This was found and handled when the scope was populated.
stack.pop();
};
/**
* @this {!Interpreter}
* @param {!Interpreter.Thread} thread
* @param {!Array} stack
* @param {!Interpreter.State} state
* @param {!Node} node
* @return {!Interpreter.State|undefined}
*/
stepFuncs_['FunctionExpression'] = function(thread, stack, state, node) {
var source = thread.getSource();
if (!source) {
throw new Error("No source found when evaluating function expression??");
}
var scope = state.scope;
var perms = scope.perms;
// If the function expression has a name, create an outer scope to
// bind that name. See ES5.1 §13 / ES6 §14.1.20.
var name = node['id'] && node['id']['name'];
if (name) {
scope = new Interpreter.Scope(Interpreter.Scope.Type.FUNEXP, perms, scope);
}
var func = new this.UserFunction(node, scope, source, perms);
if (name) scope.createImmutableBinding(name, func);
stack.pop();
stack[stack.length - 1].value = func;
};
/**
* @this {!Interpreter}
* @param {!Interpreter.Thread} thread
* @param {!Array} stack
* @param {!Interpreter.State} state
* @param {!Node} node
* @return {!Interpreter.State|undefined}
*/
stepFuncs_['Identifier'] = function(thread, stack, state, node) {
var /** string */ name = node['name'];
if (state.wantRef_) {
stack.pop();
stack[stack.length - 1].ref = [state.scope.resolve(name), name];
} else {
var value = this.getValueFromScope(state.scope, name);
stack.pop(); // Must be after call to getValueFromScope, which might throw.
stack[stack.length - 1].value = value;
}
};
stepFuncs_['IfStatement'] = stepFuncs_['ConditionalExpression'];
/**
* @this {!Interpreter}
* @param {!Interpreter.Thread} thread
* @param {!Array} stack
* @param {!Interpreter.State} state
* @param {!Node} node
* @return {!Interpreter.State|undefined}
*/
stepFuncs_['LabeledStatement'] = function(thread, stack, state, node) {
// Note that a statement might have multiple labels.
var /** !Array */ labels = state.labels || [];
labels[labels.length] = node['label']['name'];
var nextState = new Interpreter.State(node['body'], state.scope);
nextState.labels = labels;
// No need to hit LabelStatement node again on the way back up the stack.
stack.pop();
return nextState;
};
/**
* @this {!Interpreter}
* @param {!Interpreter.Thread} thread
* @param {!Array} stack
* @param {!Interpreter.State} state
* @param {!Node} node
* @return {!Interpreter.State|undefined}
*/
stepFuncs_['Literal'] = function(thread, stack, state, node) {
var /** (null|boolean|number|string|!RegExp) */ literal = node['value'];
var /** ?Interpreter.Value */ value;
if (literal instanceof RegExp) {
value = new this.RegExp(literal, state.scope.perms);
} else {
value = literal;
}
stack.pop();
stack[stack.length - 1].value = value;
};
/**
* @this {!Interpreter}
* @param {!Interpreter.Thread} thread
* @param {!Array} stack
* @param {!Interpreter.State} state
* @param {!Node} node
* @return {!Interpreter.State|undefined}
*/
stepFuncs_['LogicalExpression'] = function(thread, stack, state, node) {
if (state.step_ === 0) { // Eval left.
state.step_ = 1;
return new Interpreter.State(node['left'], state.scope);
}
// state.step_ == 1: Check for short-circuit; optionally eval right.
stack.pop();
var /** string */ op = node['operator'];
if (op !== '&&' && op !== '||') {
throw new SyntaxError("Unknown logical operator '" + op + "'");
} else if ((op === '&&' && !state.value) || (op === '||' && state.value)) {
// Short circuit. Return left value.
stack[stack.length - 1].value = state.value;
} else {
// Tail-eval right.
return new Interpreter.State(node['right'], state.scope);
}
};
/**
* @this {!Interpreter}
* @param {!Interpreter.Thread} thread
* @param {!Array} stack
* @param {!Interpreter.State} state
* @param {!Node} node
* @return {!Interpreter.State|undefined}
*/
stepFuncs_['MemberExpression'] = function(thread, stack, state, node) {
if (state.step_ === 0) { // Evaluate LHS (object).
state.step_ = 1;
return new Interpreter.State(node['object'], state.scope);
} else if (state.step_ === 1) { // Evaluate RHS (property key) if necessary.
state.tmp_ = state.value;
if (node['computed']) { // obj[foo] -- Compute value of 'foo'.
state.step_ = 2;
return new Interpreter.State(node['property'], state.scope);
}
}
// TODO(cpcallen): add test for order of following two specification
// method calls from the algorithm in ES6 §2.3.2.1.
// Step 7: bv = RequireObjectCoercible(baseValue).
var /** ?Interpreter.Value */ base = state.tmp_;
var /** !Interpreter.Owner */ perms = state.scope.perms;
if (base === null || base === undefined) {
throw new this.Error(perms, this.TYPE_ERROR,
"Can't convert " + base + ' to Object');
}
// Step 9: propertyKey = ToPropertyKey(propertyNameValue).
var /** string */ key =
node['computed'] ? String(state.value) : node['property']['name'];
stack.pop(); // Must be after last throw new this.Error...
if (state.wantRef_) {
stack[stack.length - 1].ref = [base, key];
} else {
// toObject guaranteed not to throw because of earlier check.
stack[stack.length - 1].value = this.toObject(base, perms).get(key, perms);
}
};
stepFuncs_['NewExpression'] = stepFuncs_['CallExpression'];
/**
* @this {!Interpreter}
* @param {!Interpreter.Thread} thread
* @param {!Array} stack
* @param {!Interpreter.State} state
* @param {!Node} node
* @return {!Interpreter.State|undefined}
*/
stepFuncs_['ObjectExpression'] = function(thread, stack, state, node) {
var n = state.n_;
if (!state.tmp_) { // First execution. Create object.
state.tmp_ = new this.Object(state.scope.perms);
} else { // Save just-evaluated property value in object.
// Determine property name.
var /** ?Node */ keyNode = node['properties'][n]['key'];
if (keyNode['type'] === 'Identifier') {
var /** string */ key = keyNode['name'];
} else if (keyNode['type'] === 'Literal') {
key = keyNode['value'];
} else {
throw new SyntaxError('Unknown object structure: ' + keyNode['type']);
}
var value = state.value;
var perms = state.scope.perms;
// Set name if anonymous function expression.
if (isAnonymousFunctionDefinition(node['properties'][n]['value'])) {
var func = /** @type {!Interpreter.prototype.Function} */(value);
// TODO(ES6): Check that func does not already have a 'name' own
// property before calling setName? (Spec requires, but unclear
// why since we know RHS is anonymous. Proxies?)
func.setName(key);
}
// Set the property computed in the previous execution.
state.tmp_.defineProperty(key, Descriptor.wec.withValue(value), perms);
state.n_ = ++n;
}
var /** ?Node */ property = node['properties'][n];
if (property) {
if (property['kind'] !== 'init') {
throw new this.Error(state.scope.perms, this.SYNTAX_ERROR,
'Only plain properties are supported - not getters or setters');
}
return new Interpreter.State(property['value'], state.scope);
}
stack.pop();
stack[stack.length - 1].value = state.tmp_;
};
/**
* @this {!Interpreter}
* @param {!Interpreter.Thread} thread
* @param {!Array} stack
* @param {!Interpreter.State} state
* @param {!Node} node
* @return {!Interpreter.State|undefined}
*/
stepFuncs_['Program'] = function(thread, stack, state, node) {
var n = state.n_;
var /** ?Node */ expression = node['body'][n];
if (expression) {
state.n_ = n + 1;
return new Interpreter.State(expression, state.scope);
}
stack.pop();
};
/**
* @this {!Interpreter}
* @param {!Interpreter.Thread} thread
* @param {!Array} stack
* @param {!Interpreter.State} state
* @param {!Node} node
* @return {!Interpreter.State|undefined}
*/
stepFuncs_['ReturnStatement'] = function(thread, stack, state, node) {
if (node['argument'] && state.step_ === 0) {
state.step_ = 1;
return new Interpreter.State(node['argument'], state.scope);
}
this.unwind_(
thread, Interpreter.CompletionType.RETURN, state.value, undefined);
};
/**
* @this {!Interpreter}
* @param {!Interpreter.Thread} thread
* @param {!Array} stack
* @param {!Interpreter.State} state
* @param {!Node} node
* @return {!Interpreter.State|undefined}
*/
stepFuncs_['SequenceExpression'] = function(thread, stack, state, node) {
var n = state.n_;
var /** !Node */ expression = node['expressions'][n++];
if (n >= node['expressions'].length) {
stack.pop();
}
state.n_ = n;
return new Interpreter.State(expression, state.scope);
};
/**
* Extra info used by SwitchStatement step function.
* @typedef {{default: number}}
*/
Interpreter.SwitchInfo;
/**
* @this {!Interpreter}
* @param {!Interpreter.Thread} thread
* @param {!Array} stack
* @param {!Interpreter.State} state
* @param {!Node} node
* @return {!Interpreter.State|undefined}
*/
stepFuncs_['SwitchStatement'] = function(thread, stack, state, node) {
// First check return value to see if case test succeeded.
if (state.step_ === 2 && state.value === state.tmp_) {
state.step_ = 3;
}
switch (state.step_) {
case 0: // Start by evaluating discriminant.
state.step_ = 1;
return new Interpreter.State(node['discriminant'], state.scope);
case 1: // Got evaluated discriminant. Save it.
state.tmp_ = state.value;
state.isSwitch = true;
state.info_ = {default: -1};
state.n_ = -1;
state.step_ = 2;
// FALL THROUGH
case 2: // Find case with non-empty test and evaluate test expression.
var /** Array */ cases = node['cases'];
var /** number */ len = cases.length;
var n = state.n_ + 1;
if (n < len && !cases[n]['test']) { // Found default case. Record & skip.
state.info_.default = n++;
}
if (n < len) { // Found non-empty test expression. Evaluate.
state.n_ = n;
return new Interpreter.State(cases[n]['test'], state.scope);
}
// Ran out of cases to test.
if (state.info_.default === -1) { // And there's no default. Terminate.
stack.pop();
return;
}
// Use default case.
state.n_ = state.info_.default;
// FALL THROUGH
case 3: // Found correct case. Prep for executing consequents.
state.tmp_ = 0; // Begin with the 0th consequent of current case.
state.step_ = 4;
// FALL THROUGH
case 4: // Execute case[n_].consequent[tmp_] (or next available).
cases = node['cases'];
len = cases.length;
for (n = state.n_; n < len; n++) {
var /** ?Node */ conseq = cases[n]['consequent'];
if (conseq && conseq[state.tmp_]) {
state.n_ = n;
return new Interpreter.State(conseq[state.tmp_++], state.scope);
}
state.tmp_ = 0; // Done this case; fall through 0th statement of next.
}
stack.pop(); // All done.
}
};
/**
* @this {!Interpreter}
* @param {!Interpreter.Thread} thread
* @param {!Array} stack
* @param {!Interpreter.State} state
* @param {!Node} node
* @return {!Interpreter.State|undefined}
*/
stepFuncs_['ThisExpression'] = function(thread, stack, state, node) {
stack.pop();
stack[stack.length - 1].value = state.scope.this;
};
/**
* @this {!Interpreter}
* @param {!Interpreter.Thread} thread
* @param {!Array} stack
* @param {!Interpreter.State} state
* @param {!Node} node
* @return {!Interpreter.State|undefined}
*/
stepFuncs_['ThrowStatement'] = function(thread, stack, state, node) {
if (state.step_ === 0) { // Evaluate value to throw.
state.step_ = 1;
return new Interpreter.State(node['argument'], state.scope);
}
throw state.value;
};
/**
* @this {!Interpreter}
* @param {!Interpreter.Thread} thread
* @param {!Array} stack
* @param {!Interpreter.State} state
* @param {!Node} node
* @return {!Interpreter.State|undefined}
*/
stepFuncs_['TryStatement'] = function(thread, stack, state, node) {
switch (state.step_) {
case 0: // Evaluate 'try' block.
state.step_ = 1;
return new Interpreter.State(node['block'], state.scope);
case 1: // Back from 'try' block. Run catch?
state.step_ = 2;
var /** ?Node */ handler = node['handler'];
var cv = /** ?Interpreter.Completion */ (state.info_);
if (handler && cv && cv.type === Interpreter.CompletionType.THROW) {
state.info_ = null; // This error is being handled, don't rethrow.
// Execute catch clause with varible bound to exception value.
var scope = new Interpreter.Scope(
Interpreter.Scope.Type.CATCH, state.scope.perms, state.scope);
scope.createMutableBinding(handler['param']['name'], cv.value);
return new Interpreter.State(handler['body'], scope);
}
// FALL THROUGH
case 2: // Done 'try' and 'catch'. Do 'finally'?
if (node['finalizer']) {
state.step_ = 3;
return new Interpreter.State(node['finalizer'], state.scope);
}
// FALL TRHOUGH
case 3:
// Regardless of whether we are exiting normally or about to
// resume unwinding the stack, we are done with this
// TryStatement and do not want to examine it again.
stack.pop();
if (state.info_) {
// There was no catch handler, or the catch/finally threw an
// error. Resume unwinding the stack in search of
// TryStatement / Call / target of break or continue.
this.unwind_(
thread, state.info_.type, state.info_.value, state.info_.label);
}
}
};
/**
* @this {!Interpreter}
* @param {!Interpreter.Thread} thread
* @param {!Array} stack
* @param {!Interpreter.State} state
* @param {!Node} node
* @return {!Interpreter.State|undefined}
*/
stepFuncs_['UnaryExpression'] = function(thread, stack, state, node) {
if (state.step_ === 0) { // Evaluate (or get reference) to argument.
state.step_ = 1;
// Get argument - need Reference if operator is 'delete' or 'typeof:
var wr = (node['operator'] === 'delete') || (node['operator'] === 'typeof');
return new Interpreter.State(node['argument'], state.scope, wr);
}
var value = state.value;
if (node['operator'] === '-') {
value = -value;
} else if (node['operator'] === '+') {
value = +value;
} else if (node['operator'] === '!') {
value = !value;
} else if (node['operator'] === '~') {
value = ~value;
} else if (node['operator'] === 'delete') {
if (state.ref) {
if (state.ref[0] instanceof Interpreter.Scope) {
// Whoops; this should have been caught by Acorn (because strict).
throw new Error('Uncaught illegal deletion of unqualified identifier');
}
var obj = this.toObject(state.ref[0], state.scope.perms);
value = obj.deleteProperty(state.ref[1], state.scope.perms);
} else {
// Attempted to deleted some expression that wasn't a reference
// to a variable or property. Skip delete; return true.
value = true;
}
} else if (node['operator'] === 'typeof') {
if (state.ref) {
var perms = state.scope.perms;
if (this.isUnresolvableReference(state.scope, state.ref, perms)) {
value = undefined;
} else {
value = this.getValue(state.ref, perms);
}
}
value = (value instanceof this.Function) ? 'function' : typeof value;
} else if (node['operator'] === 'void') {
value = undefined;
} else {
throw new SyntaxError('Unknown unary operator: ' + node['operator']);
}
stack.pop();
stack[stack.length - 1].value = value;
};
/**
* @this {!Interpreter}
* @param {!Interpreter.Thread} thread
* @param {!Array} stack
* @param {!Interpreter.State} state
* @param {!Node} node
* @return {!Interpreter.State|undefined}
*/
stepFuncs_['UpdateExpression'] = function(thread, stack, state, node) {
if (state.step_ === 0) { // Get Reference to argument.
state.step_ = 1;
return new Interpreter.State(node['argument'], state.scope, true);
}
if (!state.ref) throw new TypeError('argument not an LVALUE??');
var value = Number(this.getValue(state.ref, state.scope.perms));
var prefix = Boolean(node['prefix']);
var /** ?Interpreter.Value */ rval;
if (node['operator'] === '++') {
rval = (prefix ? ++value : value++);
} else if (node['operator'] === '--') {
rval = (prefix ? --value : value--);
} else {
throw new SyntaxError('Unknown update expression: ' + node['operator']);
}
this.setValue(state.ref, value, state.scope.perms);
stack.pop();
stack[stack.length - 1].value = rval;
};
/**
* @this {!Interpreter}
* @param {!Interpreter.Thread} thread
* @param {!Array} stack
* @param {!Interpreter.State} state
* @param {!Node} node
* @return {!Interpreter.State|undefined}
*/
stepFuncs_['VariableDeclaration'] = function(thread, stack, state, node) {
var declarations = node['declarations'];
var n = state.n_;
var decl = declarations[n];
if (state.step_ === 1) { // Initialise variable with evaluated init value.
var name = decl['id']['name'];
var value = state.value;
if (isAnonymousFunctionDefinition(decl['init'])) {
var func = /** @type {!Interpreter.prototype.Function} */(value);
// TODO(ES6): Check that func does not already have a 'name' own
// property before calling setName? (Spec requires, but unclear
// why since we know RHS is anonymous. Proxies?)
func.setName(name);
}
// Note that this is setting the value, not defining the variable.
// Variable definition is done when scope is populated.
this.setValueToScope(state.scope, name, value);
decl = declarations[++n];
}
while (decl) {
// Skip any declarations that are not initialized. They have already
// been defined as undefined in populateScope_.
if (decl['init']) {
state.n_ = n;
state.step_ = 1;
return new Interpreter.State(decl['init'], state.scope);
}
decl = declarations[++n];
}
stack.pop();
};
/**
* @this {!Interpreter}
* @param {!Interpreter.Thread} thread
* @param {!Array} stack
* @param {!Interpreter.State} state
* @param {!Node} node
* @return {!Interpreter.State|undefined}
*/
stepFuncs_['WithStatement'] = function(thread, stack, state, node) {
throw new this.Error(state.scope.perms, this.SYNTAX_ERROR,
'Strict mode code may not include a with statement');
};
stepFuncs_['WhileStatement'] = stepFuncs_['DoWhileStatement'];
// Give each step function a serialisation id.
for (var name in stepFuncs_) {
stepFuncs_[name].id = 'Step Function: ' + name;
}
///////////////////////////////////////////////////////////////////////////////
// Exports
///////////////////////////////////////////////////////////////////////////////
exports = module.exports = Interpreter;
exports.testOnly = {
getBoundNames: getBoundNames,
hasArgumentsOrEval: hasArgumentsOrEval,
};
================================================
FILE: server/iterable_weakmap.js
================================================
/**
* @license
* Copyright 2018 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview A WeakMap that's iterable.
* @author cpcallen@google.com (Christopher Allen)
*/
'use strict';
/**
* A (WeakRef, value) tuple in an IterableWeakMap.
* @template KEY, VALUE
*/
class Cell {
/**
* @param {!WeakRef} ref A WeakRef to the key for this cell.
* @param {VALUE} value The value for this cell.
*/
constructor(ref, value) {
/** @type {!WeakRef} */
this.ref = ref;
/** @type {VALUE} */
this.value = value;
}
}
/**
* A WeakMap implementing the full Map interface, including iterability.
* @struct
* @implements {Iterable>}
* @template KEY, VALUE
*/
// TODO(cpcallen): Make KEY a bounded to {!Object} once
// Closure Compiler supports bounded generic types
class IterableWeakMap extends WeakMap {
/**
* @param {!Iterable>|!Array>=} iterable
*/
constructor(iterable = undefined) {
super();
/** @private @const @type {!Set>} */
this.refs_ = new Set();
/**
* @private @const
* @type {!FinalizationRegistry, !WeakRef>}
*/
this.finalisers_ = new FinalizationRegistry(ref => {
this.refs_.delete(ref);
});
if (iterable === null || iterable === undefined) {
return;
}
const adder = this.set;
if (typeof adder !== 'function') {
throw new TypeError("'" + this.set + "' returned for property 'set' " +
'of object ' + this + ' is not a function');
}
for (const /** ?Array> */ entry of iterable) {
if (typeof entry !== 'object' && typeof entry !== 'function' ||
entry === null) {
throw new TypeError(
'Iterator value ' + entry + ' is not an entry object');
}
adder.call(this, entry[0], entry[1]);
}
}
/**
* Remove all entries from the map.
* @return {void}
* @override
*/
clear() {
for (const ref of this.refs_) {
const key = ref.deref();
if (key !== undefined) this.delete(key);
}
this.refs_.clear(); // Remove anything GCed but not finalised.
}
/**
* Remove a single entry from the map.
* @param {KEY} key The key to be deleted.
* @return {boolean} Was anything deleted?
* @override
*/
delete(key) {
const cell = super.get(key);
if (cell) {
this.refs_.delete(cell.ref);
this.finalisers_.unregister(cell.ref);
}
return super.delete(key);
}
/**
* Return a iterator over [key, value] pairs of the map.
* @return {!IteratorIterable>}
*/
*entries() {
for (const ref of this.refs_) {
const key = ref.deref();
if (key === undefined) { // key was garbage collected. Remove ref.
this.refs_.delete(ref);
} else {
yield [key, super.get(key).value];
}
}
}
/**
* Execute the provided callback for each entry in the map, calling
* it with thisArg as its this value and arguments key, value and
* this map.
* @this {MAP}
* @param {function(this:THIS, VALUE, KEY, IterableWeakMap)}
* callback
* @param {THIS=} thisArg
* @return {void}
* @template MAP, THIS
*/
forEach(callback, thisArg = undefined) {
for (const [key, value] of this) {
callback.call(thisArg, value, key, this);
}
}
/**
* Return the value corresponding to a given key.
* @param {KEY} key The key whose corresponding value is desired.
* @return {VALUE} The value corresponging to key, or undefined if not found.
* @override
*/
get(key) {
const cell = super.get(key);
return cell && cell.value;
}
/**
* Return an iterator over the keys of the map.
* @return {!IteratorIterable}
*/
*keys() {
for (const [key, value] of this) {
yield key;
}
}
/**
* Add or update the value associated with key in the map.
* @this {THIS}
* @param {KEY} key The key to add or update.
* @param {VALUE} value The new value to associate with key.
* @return {THIS}
* @override
* @template THIS
*/
set(key, value) {
if (super.has(key)) {
super.get(key).value = value;
} else {
const ref = new WeakRef(key);
const cell = new Cell(ref, value);
super.set(key, cell);
this.refs_.add(ref);
this.finalisers_.register(key, ref, ref);
}
return this;
}
/**
* @return {number}
*/
get size() {
return this.refs_.size;
}
/**
* Return an iterator over the value of the map.
* @return {!IteratorIterable}
*/
*values() {
for (const [key, value] of this) {
yield value;
}
}
}
IterableWeakMap.prototype[Symbol.iterator] = IterableWeakMap.prototype.entries;
module.exports = IterableWeakMap;
================================================
FILE: server/iterable_weakset.js
================================================
/**
* @license
* Copyright 2018 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview A WeakSet that's iterable.
* @author cpcallen@google.com (Christopher Allen)
*/
'use strict';
/**
* A WeakSet implementing the full Set interface, including iterability.
* @struct
* @extends {WeakSet}
* @implements {Iterable>}
* @template VALUE
*/
// TODO(cpcallen): Make VALUE bounded to {!Object} once
// Closure Compiler supports bounded generic types.
class IterableWeakSet {
/**
* @param {!Iterable>|!Array>=} iterable
*/
constructor(iterable = undefined) {
/** @private @const @type {!Set>} */
this.refs_ = new Set();
/** @private @const @type {!WeakMap>}} */
this.map_ = new WeakMap();
/**
* @private @const
* @type {!FinalizationRegistry, !WeakRef>}
*/
this.finalisers_ = new FinalizationRegistry(ref => {
this.refs_.delete(ref);
});
if (iterable === null || iterable === undefined) {
return;
}
const adder = this.add;
if (typeof adder !== 'function') {
throw new TypeError("'" + this.add + "' returned for property 'add' " +
'of object ' + this + ' is not a function');
}
for (const /** !VALUE */ value of iterable) {
if (typeof value !== 'object' && typeof value !== 'function' ||
value === null) {
throw new TypeError('Iterator value ' + value + ' is not an object');
}
adder.call(this, value);
}
}
/**
* Add the value to the set.
* @this {THIS}
* @param {VALUE} value The value to add.
* @return {THIS}
* @override
* @template THIS
*/
add(value) {
if (!this.map_.has(value)) {
const ref = new WeakRef(value);
this.map_.set(value, ref);
this.refs_.add(ref);
this.finalisers_.register(value, ref, ref);
}
return this;
}
/**
* Remove all entries from the set.
* @return {void}
* @override
*/
clear() {
for (const ref of this.refs_) {
const key = ref.deref();
if (key !== undefined) this.delete(key);
}
this.refs_.clear(); // Remove anything GCed but not finalised.
}
/**
* Remove a single entry from the set.
* @param {VALUE} value The value to be deleted.
* @return {boolean} Was anything deleted?
* @override
*/
delete(value) {
const ref = this.map_.get(value);
if (ref) {
this.refs_.delete(ref);
this.finalisers_.unregister(ref);
}
return this.map_.delete(value);
}
/**
* Return a iterator over [value, value] pairs of the set.
* @return {!IteratorIterable>}
*/
*entries() {
for (const value of this) {
yield [value, value];
}
}
/**
* Execute the provided callback for each entry in the set, calling
* it with thisArg as its this value and argument value (twice) and
* this set.
* @this {SET}
* @param {function(this:THIS, VALUE, VALUE, SET)} callback
* @param {THIS=} thisArg
* @return {void}
* @template SET, THIS
*/
forEach(callback, thisArg = undefined) {
for (const value of this) {
callback.call(thisArg, value, value, this);
}
}
/**
* Return true iff value is a member of this set.
* @param {VALUE} value
* @return {boolean}
*/
has(value) {
return this.map_.has(value);
}
/**
* @return {number}
*/
get size() {
return this.refs_.size;
}
/**
* Return an iterator over the value of the set.
* @return {!IteratorIterable}
*/
*values() {
for (const ref of this.refs_) {
const value = ref.deref();
if (value === undefined) { // value was garbage collected. Remove ref.
this.refs_.delete(ref);
} else {
yield value;
}
}
}
}
IterableWeakSet.prototype[Symbol.iterator] = IterableWeakSet.prototype.values;
IterableWeakSet.prototype.keys = IterableWeakSet.prototype.values;
module.exports = IterableWeakSet;
================================================
FILE: server/package.json
================================================
{
"name": "codecity-server",
"version": "0.0.0",
"description": "Server for the Code City project",
"main": "codecity.js",
"dependencies": {
"acorn": "^8.1.1"
},
"devDependencies": {
"google-closure-compiler": "^20210406.0.0"
},
"scripts": {
"compile": "./compile",
"test": "tests/run"
},
"repository": {
"type": "git",
"url": "git+https://github.com/google/CodeCity.git"
},
"author": "Google",
"license": "Apache-2.0",
"bugs": {
"url": "https://github.com/google/CodeCity/issues"
},
"homepage": "https://github.com/google/CodeCity#readme"
}
================================================
FILE: server/parser.js
================================================
/**
* @license
* Copyright 2020 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Parser for Code City interpreter.
* @author cpcallen@google.com (Christopher Allen)
*/
var acorn = require('acorn');
///////////////////////////////////////////////////////////////////////////////
// Externs for Acorn.
///////////////////////////////////////////////////////////////////////////////
// These are supplied here because Closure Compiler doesn't appear to
// provide any good way to specify externs for a Node module, and the
// mechanisms used to provide separate externs for Node's built-in
// modules don't work with NPMs.
//
// Trivial 'initialisers' are provided for acorn.Node and acorn.Parser
// to satisfy the compiler's requirement that constructors be
// initialised at declaration.
/**
* @constructor
* @param {!acorn.Parser} parser
* @param {?} pos
* @param {?} loc
*/
acorn.Node = acorn.Node;
/**
* @constructor
* @param {!Object} options Parse options.
* @param {string} input The text to be parsed.
* @param {number=} startPos Character offset to start parsing at.
*/
acorn.Parser = acorn.Parser;
/**
* @return {!Node}
*/
acorn.Parser.prototype.startNode;
/**
* @param {?} pos
* @param {?} loc
* @return {!Node}
*/
acorn.Parser.prototype.startNodeAt;
/**
* @param {string} input
* @param {!Object=} options
*/
acorn.Parser.parse;
/**
* @param {string} input
* @param {number} pos
* @param {!Object=} options
*/
acorn.Parser.parseExpressionAt;
///////////////////////////////////////////////////////////////////////////////
// Custom Parser subclass for Code City.
///////////////////////////////////////////////////////////////////////////////
/** @const {!Object} Default options for Parser. */
var PARSE_OPTIONS = {ecmaVersion: 5, strict: true};
/**
* A subclass of acorn.Node, which has a constructor that can be
* called without arguments (and in particular without the Parser
* argument).
*
* This is mainly to facilitate deserialisation, but is also used
* directly to create a fake (but but correctly typed) AST node for
* 'eval'.
*
* @constructor
* @extends {acorn.Node}
* @param {!acorn.Parser=} parser
* @param {?=} pos
* @param {?=} loc
*/
var Node = function(parser, pos, loc) {
acorn.Node.call(this, parser || {options: PARSE_OPTIONS}, pos, loc);
};
Object.setPrototypeOf(Node, acorn.Node);
Object.setPrototypeOf(Node.prototype, acorn.Node.prototype);
/**
* A subclass of acorn.Parser that:
*
* - Supports a strict option which, if true, forces strict mode.
* - Defaults to using Interpreter.PARSE_OPTIONS if no options are
* supplied.
* - Uses the overridden Node constructor above to create nodes.
*
* See https://github.com/acornjs/acorn/tree/master/acorn#interface
* for details on how to use it, valid option values, etc.
*
* @constructor
* @extends {acorn.Parser}
* @param {!Object|undefined} options Parse options. Defaults to
* Interpreter.PARSE_OPTIONS
* @param {string} input The text to be parsed.
* @param {number=} startPos Character offset to start parsing at.
*/
var Parser = function(options, input, startPos) {
if (!options) options = PARSE_OPTIONS;
acorn.Parser.call(this, options, input, startPos);
if (options.strict) this.strict = true;
};
Object.setPrototypeOf(Parser, acorn.Parser);
Object.setPrototypeOf(Parser.prototype, acorn.Parser.prototype);
/** @override */
Parser.prototype.startNode = function() {
return new Node(this, this.start, this.startLoc);
};
/** @overide */
Parser.prototype.startNodeAt = function(pos, loc) {
return new Node(this, pos, loc);
};
// Redeclare static methods because Closure Compiler isn't too smart
// about static method inheritance in ES5.
/** @override */ Parser.parse;
/** @override */ Parser.parseExpressionAt;
///////////////////////////////////////////////////////////////////////////////
// Exports
///////////////////////////////////////////////////////////////////////////////
exports.Parser = Parser;
exports.PARSE_OPTIONS = PARSE_OPTIONS;
exports.Node = Node;
================================================
FILE: server/priorityqueue.js
================================================
/**
* @license
* Copyright 2020 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview A priority queue implemented using a heap.
* @author cpcallen@google.com (Christopher Allen)
*/
'use strict';
// Rant: I can't believe I have to write this myself, but a fairly
// extensive search of GitHub and NPM did not turn up an existing
// package that:
//
// - Allowed arbitrary JS values (including objects) in the queue,
// - Does comparison by ===, SameValueZero or SameValue (Object.is)
// rather than using deepEquals or something equally foolish,
// - Provided a decreasePriority method.
/**
* Returns the parent index of a given index in a heap.
* @private
* @param {number} i Index to get parent of.
* @return {number} Index of parent, or -1 if i is 0.
*/
function parent(i) {
if (i <= 0) return -1;
return Math.floor((i - 1) / 2);
}
/**
* Returns the child indices of a given index in a heap.
* @private
* @param {number} i Index to get children of.
* @return !Array Two-element array of indicies of the chilren.
*/
function children(i) {
return [(i * 2) + 1, (i * 2) + 2];
}
/**
* A priority queue.
* @stuct
* @template T
*/
class PriorityQueue {
constructor() {
/** @private @const {!Array<{value: T, priority: number}>} */
this.heap_ = [];
/** @private @const {!Map} */
this.indices_ = new Map();
}
/**
* Remove the minimum
* @return {T} The minimum-priority item just removed.
*/
deleteMin() {
if (this.heap_.length === 0) {
throw RangeError('queue is empty');
}
const value = this.heap_[0].value;
this.indices_.delete(value);
if (this.heap_.length > 1) {
this.heap_[0] = this.heap_.pop();
// percolateDown_ will update indices_.
this.percolateDown_(0);
} else {
this.heap_.pop();
}
return value;
}
/**
* Insert an item in the queue.
* @param {T} value The item to be inserted.
* @param {number} priority The priority value to insert it with.
* @return {void}
*/
insert(value, priority) {
this.set.call(this, value, priority);
}
/** @return {number} */
get length() {
return this.heap_.length;
}
/**
* Move the entry at .heap_[i] towards the leaves of the heap as
* required to retain heap ordering.
* @private
* @param {number} i Index of node to percolate up.
*/
percolateDown_(i) {
const entry = this.heap_[i];
while (true) {
const [l, r] = children(i);
if (l >= this.heap_.length) break; // No children.
let c = l;
if (r < this.heap_.length && // Two children. Pick smallest.
this.heap_[r].priority < this.heap_[l].priority) {
c = r;
}
if (entry.priority <= this.heap_[c].priority) break;
this.heap_[i] = this.heap_[c];
this.indices_.set(this.heap_[c].value, i);
i = c;
}
this.heap_[i] = entry;
this.indices_.set(entry.value, i);
}
/**
* Move the entry at .heap_[i] towards the root of the heap as
* required to retain heap ordering.
* @private
* @param {number} i Index of node to percolate up.
*/
percolateUp_(i) {
const entry = this.heap_[i];
while (i > 0) {
const p = parent(i);
if (this.heap_[p].priority <= entry.priority) break;
this.heap_[i] = this.heap_[p];
this.indices_.set(this.heap_[p].value, i);
i = p;
}
this.heap_[i] = entry;
this.indices_.set(entry.value, i);
}
/**
* Reduce the priority of a given value.
* @param {T} value The item to be modified.
* @param {number} priority The new priority value. Must not be
* greater than the existing value.
* @return {void}
*/
reducePriority(value, priority) {
return this.set.call(this, value, priority);
}
/**
* Insert an item into the queue or update its priority. If the
* value is already in the queue then priority must not be greater
* than the previous priority or RangeError will be thrown.
* @param {T} value The item to be inserted/updated.
* @param {number} priority The (new) priority for value.
* @return {void}
*/
set(value, priority) {
let i = this.indices_.get(value);
if (i === undefined) {
i = this.heap_.length;
this.heap_.push({value, priority});
} else if (this.heap_[i].priority < priority) {
throw new RangeError('attempting to increase priority');
} else {
this.heap_[i].priority = priority;
}
// percolateUp will set/update this.indices_ entry for value.
this.percolateUp_(i);
}
}
exports.PriorityQueue = PriorityQueue;
exports.testOnly = {parent, children};
================================================
FILE: server/registry.js
================================================
/**
* @license
* Copyright 2018 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview The Registry class, for e.g. registering built-ins.
* @author cpcallen@google.com (Christopher Allen)
*/
'use strict';
const util = require('util');
/**
* Class for a registry providing a bijective[1] mapping between
* string-valued keys and arbitrary values.
*
* N.B.: a Map is used for reverse lookups; as Maps use the
* sameValueZero algorithm to compare keys[2] it is not possible to
* register both 0 and -0, but NaN will work correctly.
*
* [1] This means no key may have more than one value, and no value
* may have more than one key.
* [2] https://developer.mozilla.org/en-US/docs/Web/JavaScript/Equality_comparisons_and_sameness#Same-value-zero_equality
*
* @constructor
* @template T
*/
class Registry {
constructor() {
/** @private @const @type {!Object} */
this.values_ = Object.create(null);
/** @private @const @type {!Map} */
this.keys_ = new Map();
}
/**
* Return an array of [key, value] pairs of the registry.
* @return {!Array>}
*/
entries() {
return Object.entries(this.values_);
}
/**
* Look up a registered value. Throws an error if the given key has
* not been registered.
* @param {string} key The key to get the registered value for.
* @return {T} The registered value.
*/
get(key) {
if (!this.has(key)) {
throw new Error('Key "' + key + '" not registered');
}
return this.values_[key];
}
/**
* Look up the key for a registered value. Returns undefined if the
* given value has not been registered.
* @param {T} value The value to get the key for.
* @return {string|undefined} The key for value, or undefined if
* value never registered.
*/
getKey(value) {
return this.keys_.get(value);
}
/**
* Check if a key exists in the registry.
* @param {string} key The key to check.
* @return {boolean} True iff key has previously been registered.
*/
has(key) {
return key in this.values_;
}
/**
* Return an array of keys of the registry.
* @return {!Array}
*/
keys() {
return Object.keys(this.values_);
}
/**
* Register a value. Throws an error if the given key has already
* been used for a previous registration.
* @param {string} key The key to register value with.
* @param {T} value The value to be registered.
*/
set(key, value) {
if (key in this.values_) {
throw new Error('Key "' + key + '" already in use');
}
if (this.keys_.has(value)) {
throw new Error(util.format('Value %O already registered', value));
}
this.values_[key] = value;
this.keys_.set(value, key);
}
/**
* Return an array of values of the registry.
* @return {!Array}
*/
values() {
return Object.values(this.values_);
}
}
module.exports = Registry;
================================================
FILE: server/repl
================================================
#!/usr/bin/env node
/**
* @license
* Copyright 2018 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Read Eval Print Loop (REPL) for JavaScript Interpreter.
* @author cpcallen@google.com (Christopher Allen)
*/
'use strict';
const readline = require('readline');
const Interpreter = require('./interpreter');
const fs = require('fs');
const intrp = new Interpreter;
intrp.createThreadForSrc(fs.readFileSync('startup/es5.js', 'utf8'));
intrp.run();
intrp.createThreadForSrc(fs.readFileSync('startup/es6.js', 'utf8'));
intrp.run();
intrp.createThreadForSrc(fs.readFileSync('startup/es7.js', 'utf8'));
intrp.run();
intrp.createThreadForSrc(fs.readFileSync('startup/esx.js', 'utf8'));
intrp.run();
intrp.createThreadForSrc(fs.readFileSync('startup/cc.js', 'utf8'));
intrp.run();
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout,
removeHistoryDuplicates: true,
});
rl.prompt();
rl.on('line', function(line) {
try {
let thread;
try {
thread = intrp.createThreadForSrc(line).thread;
} catch (e) {
console.log('%s: %s', e.name, e.message);
return;
}
intrp.run();
const value = thread.value;
if (value instanceof intrp.Function) {
console.log(value.toString());
} else {
console.log('%o', intrp.pseudoToNative(thread.value));
}
} finally {
rl.prompt();
}
}).on('close', function() {
process.exit(0);
});
================================================
FILE: server/selector.js
================================================
/**
* @license
* Copyright 2018 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview CSS-style selectors for JS objects.
* @author cpcallen@google.com (Christopher Allen)
*/
'use strict';
var code = require('./code');
/**
* Type for all "special" selector parts (ones which do not represent
* named variables / properties).
* @constructor
* @struct
*/
var SpecialPart = function(type) {
this.type = type;
};
/** @override */
SpecialPart.prototype.toString = function() {
return '{' + this.type + '}';
};
/**
* A Selector is just an array of Parts, which happens to have
* Selector.prototype (with various useful convenience methods) in its
* prototype chain.
* @constructor
* @extends {Array}
* @param {string|!Array|!Selector} s A Selector, parts
* array or selector string.
*/
var Selector = function(s) {
var /** !Array */ parts;
if (typeof s === 'string') {
// Parse selector text.
parts = parse(s);
} else if (Array.isArray(s)) {
parts = [];
// Validate & copy parts array.
if (typeof s.length < 1) throw new RangeError('Zero-length parts array??');
if (s.length < 1) throw new RangeError('Zero-length parts array??');
if (typeof s[0] !== 'string' || !code.regexps.identifierExact.test(s[0])) {
throw new TypeError('Parts array must begin with an identifier');
}
parts[0] = s[0];
for (var i = 1; i < s.length; i++) {
if (typeof s[i] !== 'string' && !(s[i] instanceof SpecialPart)) {
throw new TypeError('Invalid part in parts array');
} else if ((s[i] instanceof SpecialPart) &&
s[i] !== Selector.PROTOTYPE && s[i] !== Selector.OWNER) {
throw new TypeError('Invalid SpecialPart in parts array');
}
parts[i] = s[i];
}
} else {
throw new TypeError('Not a selector or parts array');
}
Object.setPrototypeOf(parts, Selector.prototype);
return parts;
};
Object.setPrototypeOf(Selector.prototype, Array.prototype);
/**
* Return a "badness" score, inversely proportional to how desirable a
* particular selector is amongst other selectors referring to the
* same binding. In general, longer selectors are more bad, but
* selectors containing special parts are especially bad.
* TODO(cpcallen): reintroduce penalty for non-builtins?
* @return {number};
*/
Selector.prototype.badness = function() {
var penalties = 0;
for (var i = 0; i < this.length; i++) {
penalties += Selector.partBadness(this[i]);
}
return penalties;
};
/**
* Returns true iff the selector represents an object owner
* binding.
* @return {boolean} Is selector for owner?
*/
Selector.prototype.isOwner = function() {
return this.length > 1 && this[this.length - 1] === Selector.OWNER;
};
/**
* Returns true iff the selector represents an object property
* binding.
* @return {boolean} Is selector for a property?
*/
Selector.prototype.isProp = function() {
return this.length > 1 && typeof this[this.length - 1] === 'string';
};
/**
* Returns true iff the selector represents an object prototype
* binding.
* @return {boolean} Is selector for prototype?
*/
Selector.prototype.isProto = function() {
return this.length > 1 && this[this.length - 1] === Selector.PROTOTYPE;
};
/**
* Returns true iff the selector represents a top-level variable
* binding.
* @return {boolean} Is selector for a variable?
*/
Selector.prototype.isVar = function() {
return this.length === 1 && typeof this[0] === 'string';
};
/**
* Return the selector as an evaluable expression yeilding the
* selected value.
* @return {string} The selector as a string.
*/
Selector.prototype.toExpr = function() {
return this.toString(function(part, out) {
if (part === Selector.PROTOTYPE) {
out.unshift('Object.getPrototypeOf(');
out.push(')');
} else if (part === Selector.OWNER) {
out.unshift('Object.getOwnerOf(');
out.push(')');
} else {
throw new TypeError('Invalid part in parts array');
}
});
};
/**
* Return an expression setting the selected value to the value of the
* supplied expression.
* @param {string} valueExpr A JS expression that evaluates to the new
* value to be assigned to the selected location. It must not
* contain any non-parenthesized operators with lower precedence
* than '=' - specifically, the yield and comma operators.
* @return {string} The selector as a string.
*/
Selector.prototype.toSetExpr = function(valueExpr) {
var lastPart = this[this.length - 1];
if (!(lastPart instanceof SpecialPart)) {
return this.toExpr() + ' = ' + valueExpr;
}
var objExpr = new Selector(this.slice(0, -1)).toExpr();
if (lastPart === Selector.PROTOTYPE) {
return 'Object.setPrototypeOf(' + objExpr + ', ' + valueExpr + ')';
} else if (lastPart === Selector.OWNER) {
return 'Object.setOwnerOf(' + objExpr + ', ' + valueExpr + ')';
} else {
throw new TypeError('Invalid part in parts array');
}
};
/**
* Return the selector string corresponding to this selector.
* @param {function(!SpecialPart, !Array)=} specialHandler
* Optional function to handle stringifying SpecialParts.
* @return {string} The selector as a string.
*/
Selector.prototype.toString = function(specialHandler) {
var /** !Array */ out = [this[0]];
for (var i = 1; i < this.length; i++) {
var part = this[i];
if (part instanceof SpecialPart) {
if (specialHandler) {
specialHandler(part, out);
} else {
out.push(String(part));
}
} else if (code.regexps.identifierExact.test(part)) {
out.push('.', part);
} else if (String(Number(part)) === part) {
// String represents a number with same string representation.
out.push('[', part, ']');
} else {
out.push('[', code.quote(part), ']');
}
}
return out.join('');
};
/**
* Return a "badness" score for a single Selector.Part, inversely
* proportional to how desirable the part is as part of selector
* amongst other selectors referring to the same binding.
* @return {number};
*/
Selector.partBadness = function(part) {
if (part instanceof SpecialPart) {
return 100; // We don't like SpecialParts.
} else if (code.regexps.identifierExact.test(part)) {
return 10 + part.length; // We like identifiers.
} else if (String(Number(part)) === part) {
return 25 + part.length; // Numbers are OK.
} else {
return 30 + part.length; // Quoted strings are less desirable.
}
};
/**
* Special singleton Part for refering to an object's prototype.
*/
Selector.PROTOTYPE = new SpecialPart('proto');
/**
* Special singleton Part for refering to an object's owner.
*/
Selector.OWNER = new SpecialPart('owner');
/**
* A Selector fundamentally an array of Parts, and Parts are either
* strings (representing variable or property names) or SpecialParts
* (representing everything else, like {proto} or {owner}).
* @typedef {string|!SpecialPart}
*/
Selector.Part;
/**
* Parse a selector into an array of Parts.
* @return !Array
*/
var parse = function(selector) {
var tokens = tokenize(selector);
var parts = [];
/** @enum {number} */
var State = {
START: 0, GOOD: 1, DOT: 2, BRACKET: 3, BRACKET_DONE: 4,
BRACE: 5, BRACE_DONE: 6
};
var state = State.START;
for (var i = 0; i < tokens.length; i++) {
var token = tokens[i];
if (token.type === 'whitespace') continue;
switch (state) {
case State.START:
if (token.type !== 'id') {
throw new SyntaxError('Selector must start with an identifier');
}
parts.push(token.raw);
state = State.GOOD;
break;
case State.GOOD:
if (token.type === '.') {
state = State.DOT;
} else if (token.type === '[') {
state = State.BRACKET;
} else if (token.type === '{') {
state = State.BRACE;
} else if (token.type === '^') {
// state remains unchanged.
parts.push(Selector.PROTOTYPE);
} else {
throw new SyntaxError(
'Invalid token ' + code.quote(token.raw) + ' in selector');
}
break;
case State.DOT:
if (token.type !== 'id') {
throw new SyntaxError(
'"." must be followed by identifier in selector');
}
parts.push(token.raw);
state = State.GOOD;
break;
case State.BRACKET:
if (token.type === 'number') {
parts.push(String(token.raw));
} else if (token.type === 'str') {
parts.push(String(token.value));
} else {
throw new SyntaxError('"[" must be followed by numeric or string ' +
'literal in selector');
}
state = State.BRACKET_DONE;
break;
case State.BRACKET_DONE:
if (token.type !== ']') {
throw new SyntaxError(
'Invalid token ' + code.quote(token.raw) + ' after subscript');
}
state = State.GOOD;
break;
case State.BRACE:
if (token.type === 'id' && token.raw === 'proto') {
parts.push(Selector.PROTOTYPE);
} else if (token.type === 'id' && token.raw === 'owner') {
parts.push(Selector.OWNER);
} else {
throw new SyntaxError('"{" must be followed by "proto" or "owner"');
}
state = State.BRACE_DONE;
break;
case State.BRACE_DONE:
if (token.type !== '}') {
throw new SyntaxError(
'Invalid token ' + code.quote(token.raw) + ' after special');
}
state = State.GOOD;
break;
default:
throw new Error('Invalid State in parse??');
}
}
if (state !== State.GOOD) {
throw new SyntaxError('Incomplete selector ' + selector);
}
return parts;
};
/** @typedef {{type: string,
* raw: string,
* valid: boolean,
* index: number,
* value: (string|number|undefined)}}
*/
var Token;
/**
* Tokenizes a selector string. Throws a SyntaxError if any text is
* found which does not form a valid token.
* @param {string} selector A selector string.
* @return {!Array} An array of tokens.
*/
var tokenize = function(selector) {
var REs = {
whitespace: /\s+/y,
'.': /\./y,
id: new RegExp(code.regexps.identifier, 'y'),
number: /\d+/y,
'[': /\[/y,
']': /\]/y,
'{': /\{/y,
'}': /\}/y,
'^': /\^/y,
str: new RegExp(code.regexps.string, 'y'),
};
var tokens = [];
NEXT_TOKEN: for (var index = 0; index < selector.length; ) {
for (var tokenType in REs) {
if (!REs.hasOwnProperty(tokenType)) continue;
var re = REs[tokenType];
re.lastIndex = index;
var m = re.exec(selector);
if (!m) continue; // No match. Try next regexp.
tokens.push({
type: tokenType,
raw: m[0],
valid: true,
index: index,
});
index = re.lastIndex;
continue NEXT_TOKEN;
}
// No token matched.
throw new SyntaxError('invalid selector ' + selector);
}
// Postprocess token list to get values.
for(var i = 0; i < tokens.length; i++) {
var token = tokens[i];
if (token.type === 'number') {
token.value = Number(token.raw);
} else if (token.type === 'str') {
token.value = code.parseString(token.raw);
}
}
return tokens;
};
module.exports = Selector;
================================================
FILE: server/serialize.js
================================================
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Saving and restoring the state of the interpreter.
* @author fraser@google.com (Neil Fraser)
*/
'use strict';
var Interpreter = require('./interpreter');
var IterableWeakMap = require('./iterable_weakmap');
var IterableWeakSet = require('./iterable_weakset');
var net = require('net');
var Node = require('./parser').Node;
var Registry = require('./registry');
var Serializer = {};
/**
* A record of a single serializalbe type, including a type tag, a
* constructor function to call when deserializing an instance, and an
* optional list of properties to exclude when serializing.
*
* @typedef {{
* tag: string,
* constructor: !Function,
* prune: (!Array|undefined),
* }}
*/
var TypeInfo;
/**
* A configuration object containing an array of TypeInfo objects and
* indexes by tag an prototype object.
*
* @typedef {{
* types: !Array,
* byTag: !Object,
* byProto: !Map,
* }}
*/
var Config;
/**
* Create a configuration object for serializing or desieralizing a
* particular Interpreter instance.
*
* @param {!Interpreter} intrp The interpreter instance being serialized
* (needed for inner classes).
* @return {!Config} The configuration object.
*/
Serializer.getConfig_ = function(intrp) {
var /** !Array */ types = [
// Generic JavaScript types, not including those requring special
// construction (like Functions, Dates, RegExps, etc.)
{tag: 'Object', constructor: Object},
{tag: 'Array', constructor: Array},
{tag: 'Map', constructor: Map},
{tag: 'Set', constructor: Set},
// Custom types, not Interpreter-specific.
{tag: 'IterableWeakMap', constructor: IterableWeakMap,
prune: ['refs_', 'finalisers_']},
{tag: 'IterableWeakSet', constructor: IterableWeakSet,
prune: ['refs_', 'map_', 'finalisers_']},
{tag: 'Registry', constructor: Registry},
// Interpreter-specific types.
{tag: 'Interpreter', constructor: Interpreter, prune: [
'hrStartTime_',
'previousTime_',
'runner_',
'Object',
'Function',
'UserFunction',
'BoundFunction',
'NativeFunction',
'OldNativeFunction',
'Array',
'Date',
'RegExp',
'Error',
'Arguments',
'WeakMap',
'Thread',
'Box',
'Server',
]},
{tag: 'Scope', constructor: Interpreter.Scope},
{tag: 'State', constructor: Interpreter.State},
{tag: 'Thread', constructor: Interpreter.Thread},
{tag: 'PropertyIterator', constructor: Interpreter.PropertyIterator},
{tag: 'Source', constructor: Interpreter.Source},
{tag: 'PseudoObject', constructor: intrp.Object, prune: ['socket']},
{tag: 'PseudoFunction', constructor: intrp.Function},
{tag: 'PseudoUserFunction', constructor: intrp.UserFunction},
{tag: 'PseudoBoundFunction', constructor: intrp.BoundFunction},
{tag: 'PseudoNativeFunction', constructor: intrp.NativeFunction},
{tag: 'PseudoOldNativeFunction', constructor: intrp.OldNativeFunction},
{tag: 'PseudoArray', constructor: intrp.Array},
{tag: 'PseudoDate', constructor: intrp.Date},
{tag: 'PseudoRegExp', constructor: intrp.RegExp},
{tag: 'PseudoError', constructor: intrp.Error},
{tag: 'PseudoArguments', constructor: intrp.Arguments},
{tag: 'PseudoWeakMap', constructor: intrp.WeakMap},
{tag: 'PseudoThread', constructor: intrp.Thread},
{tag: 'Box', constructor: intrp.Box},
{tag: 'Server', constructor: intrp.Server, prune: ['server_']},
{tag: 'Node', constructor: Node},
];
var /** !Object */ byTag = Object.create(null);
var /** !Map */ byProto = new Map();
for (var type, i = 0; type = types[i]; i++) {
byTag[type.tag] = type;
byProto.set(type.constructor.prototype, type);
}
return {types: types, byTag: byTag, byProto: byProto};
};
/**
* Deserialize the provided JSON-compatible object into an interpreter.
* @param {!Object} JSON-compatible object.
* @param {!Interpreter} intrp JS-Interpreter instance.
*/
Serializer.deserialize = function(json, intrp) {
function decodeValue(value) {
if (value && typeof value === 'object') {
var data;
if ((data = value['#'])) {
// Object reference: {'#': 42}
value = objectList[data];
if (!value) {
throw new ReferenceError('Object reference not found: ' + data);
}
return value;
}
if ((data = value['Number'])) {
// Special number: {'Number': 'Infinity'}
return Number(data);
}
if ((data = value['Value'])) {
// Special value: {'Value': 'undefined'}
if (value['Value'] === 'undefined') {
return undefined;
}
}
}
return value;
}
// Get configuration.
var config = Serializer.getConfig_(intrp);
if (!Array.isArray(json)) {
throw new TypeError('Top-level JSON is not a list.');
}
// Require native functions to be present. Can't just create fresh
// new interpreter instance because client code may want to add
// custom builtins.
if (!intrp.global) {
throw new Error(
'Interpreter must be initialized prior to deserialization.');
}
// Find all native functions to get id => func mappings.
var functionHash = Object.create(null);
// Builtins.
var builtins = Array.from(intrp.builtins.values());
var implProps = ['impl', 'call', 'construct'];
for (var i = 0; i < builtins.length; i++) {
var builtin = builtins[i];
for (var j = 0; j < implProps.length; j++) {
var func = builtin[implProps[j]];
if (func) functionHash[func.id] = func;
}
}
// Step functions.
for (var stepName in intrp.stepFuncs) {
var stepFunc = intrp.stepFuncs[stepName];
functionHash[stepFunc.id] = stepFunc;
}
// First pass: Create object stubs for every object. We don't need
// to (re)create object #0, because that's the interpreter proper.
var objectList = [intrp];
for (var i = 1; i < json.length; i++) {
var jsonObj = json[i];
var obj;
var tag = jsonObj['type'];
// Default case handles most types; sepcial cases handle only
// those that can't be correctly created by an unparameterized
// construction "new Constructor()".
switch (tag) {
case 'Function':
obj = functionHash[jsonObj['id']];
if (!obj) {
throw new RangeError('Function ID not found: ' + jsonObj['id']);
}
break;
case 'Date':
obj = new Date(jsonObj['data']);
if (isNaN(obj)) {
throw new TypeError('Invalid date: ' + jsonObj['data']);
}
break;
case 'RegExp':
obj = RegExp(jsonObj['source'], jsonObj['flags']);
break;
case 'State':
// TODO(cpcallen): this is just a little performance kludge so
// that the State constructor doesn't need a conditional in it.
// Find a more general solution to constructors requiring args.
obj = new Interpreter.State(/** @type {?} */({}),
/** @type {?} */(undefined));
break;
default:
if (config.byTag[tag]) {
obj = new config.byTag[tag].constructor();
} else {
throw new TypeError('Unknown type tag "' + tag + '"');
}
}
objectList[i] = obj;
}
// Second pass: Populate properties for every object.
for (var i = 0; i < json.length; i++) {
var jsonObj = json[i];
var tag = jsonObj['type'];
var typeInfo = config.byTag[tag];
var obj = objectList[i];
// Set prototype, if specified.
if (jsonObj['proto']) {
Object.setPrototypeOf(obj, decodeValue(jsonObj['proto']));
}
// Repopulate properties.
var prune = (typeInfo && typeInfo.prune) || [];
var props = jsonObj['props'];
if (props) {
var nonConfigurable = jsonObj['nonConfigurable'] || [];
var nonEnumerable = jsonObj['nonEnumerable'] || [];
var nonWritable = jsonObj['nonWritable'] || [];
var keys = Object.getOwnPropertyNames(props);
for (var j = 0; j < keys.length; j++) {
var key = keys[j];
if (prune.includes(key)) continue;
Object.defineProperty(obj, key,
{configurable: !nonConfigurable.includes(key),
enumerable: !nonEnumerable.includes(key),
writable: !nonWritable.includes(key),
value: decodeValue(props[key])});
}
}
// Repopulate sets.
if (obj instanceof Set || obj instanceof IterableWeakSet) {
var data = jsonObj['data'];
if (data) {
for (var j = 0; j < data.length; j++) {
obj.add(decodeValue(data[j]));
}
}
}
// Repopulate maps.
if (obj instanceof Map || obj instanceof IterableWeakMap) {
var entries = jsonObj['entries'];
if (entries) {
for (var j = 0; j < entries.length; j++) {
var key = decodeValue(entries[j][0]);
var value = decodeValue(entries[j][1]);
obj.set(key, value);
}
}
}
if (jsonObj['isExtensible'] === false) { // N.B. normally omitted if true.
Object.preventExtensions(obj);
}
}
// Finally: fixup interpreter state, post-deserialization.
intrp.postDeserialize();
};
/**
* Serialize the provided interpreter.
* @param {!Interpreter} intrp JS-Interpreter instance.
* @return {!Object} JSON-compatible object.
*/
Serializer.serialize = function(intrp) {
// First: prepare interpreter for serialization.
intrp.preSerialize();
function encodeValue(value) {
if (value && (typeof value === 'object' || typeof value === 'function')) {
var ref = objectRefs.get(value);
if (ref === undefined) {
throw new RangeError('object not found in table');
}
return {'#': ref};
}
if (value === undefined) {
return {'Value': 'undefined'};
}
if (typeof value === 'number') {
if (value === Infinity) {
return {'Number': 'Infinity'};
} else if (value === -Infinity) {
return {'Number': '-Infinity'};
} else if (Number.isNaN(value)) {
return {'Number': 'NaN'};
} else if (Object.is(value, -0)) {
return {'Number': '-0'};
}
}
return value;
}
// Get configuration.
var config = Serializer.getConfig_(intrp);
// Find all objects.
var objectList = Serializer.getObjectList_(intrp, config);
// Build reverse-lookup cache.
var /** !Map */ objectRefs = new Map();
for (var i = 0; i < objectList.length; i++) {
objectRefs.set(objectList[i], i);
}
// Serialize every object.
var json = [];
for (var i = 0; i < objectList.length; i++) {
var jsonObj = Object.create(null);
json.push(jsonObj);
var obj = objectList[i];
// TODO: Add a flag on the '#' prop. On for debugging, off for production.
if (true) {
jsonObj['#'] = i;
}
var proto = Object.getPrototypeOf(obj);
var typeInfo = config.byProto.get(proto);
// Default case handles most types; sepcial cases handle only
// those that have extra intenal slots.
switch (proto) {
case Function.prototype:
jsonObj['type'] = 'Function';
jsonObj['id'] = obj.id;
if (!obj.id) {
throw new Error('Native function has no ID: ' + obj);
}
continue; // No need to index properties.
case Date.prototype:
jsonObj['type'] = 'Date';
jsonObj['data'] = obj.toJSON();
continue; // No need to index properties.
case RegExp.prototype:
jsonObj['type'] = 'RegExp';
jsonObj['source'] = obj.source;
jsonObj['flags'] = obj.flags;
continue; // No need to index properties.
case Map.prototype:
jsonObj['type'] = 'Map';
if (obj.size) {
jsonObj['entries'] =
Array.from(/** @type {?} */(obj),function(entry) {
var key = encodeValue(entry[0]);
var value = encodeValue(entry[1]);
return [key, value];
});
}
break;
case Set.prototype:
jsonObj['type'] = 'Set';
if (obj.size) {
jsonObj['data'] = Array.from(obj.values(), encodeValue);
}
break;
case IterableWeakMap.prototype:
jsonObj['type'] = 'IterableWeakMap';
if (obj.size) {
jsonObj['entries'] =
Array.from(/** @type {?} */(obj), function(entry) {
var key = encodeValue(entry[0]);
var value = encodeValue(entry[1]);
return [key, value];
});
}
continue; // Mustn't index internal properties for IterableWeakMap
case IterableWeakSet.prototype:
jsonObj['type'] = 'IterableWeakSet';
if (obj.size) {
jsonObj['data'] = Array.from(obj.values(), encodeValue);
}
continue; // Mustn't index internal properties for IterableWeakSet
case Registry.prototype:
jsonObj['type'] = 'Registry';
break;
default:
if (typeInfo) {
jsonObj['type'] = typeInfo.tag;
} else {
jsonObj['type'] = Array.isArray(obj) ? 'Array' : 'Object';
jsonObj['proto'] = encodeValue(proto);
}
}
var props = Object.create(null);
var nonConfigurable = [];
var nonEnumerable = [];
var nonWritable = [];
var prune = (typeInfo && typeInfo.prune) || [];
var keys = Object.getOwnPropertyNames(obj);
for (var j = 0; j < keys.length; j++) {
var key = keys[j];
if (prune.includes(key)) continue;
// Skip [[Socket]] slot on connected objects.
// TODO(cpcallen): this is pretty kludgy. Try to find a better way.
if (obj instanceof intrp.Object && key === 'socket') continue;
props[key] = encodeValue(obj[key]);
var descriptor = Object.getOwnPropertyDescriptor(obj, key);
if (!descriptor.configurable) {
nonConfigurable.push(key);
}
if (!descriptor.enumerable) {
nonEnumerable.push(key);
}
if (!descriptor.writable) {
nonWritable.push(key);
}
}
if (Object.getOwnPropertyNames(keys).length) {
jsonObj['props'] = props;
}
if (nonConfigurable.length) {
jsonObj['nonConfigurable'] = nonConfigurable;
}
if (nonEnumerable.length) {
jsonObj['nonEnumerable'] = nonEnumerable;
}
if (nonWritable.length) {
jsonObj['nonWritable'] = nonWritable;
}
if (!Object.isExtensible(obj)) {
jsonObj['isExtensible'] = false;
}
}
return json;
};
/**
* Recursively search node to find all non-primitives.
*
* TODO(cpcallen): use a Registry instead of Array for objectList;
* this would allow more readable references by using paths
* instead of numerical indices.
* @param {*} node JavaScript value to search.
* @param {!Config} config Configuation object.
* @return {!Array} objectList Array of all objects found via node.
*/
Serializer.getObjectList_ = function(node, config) {
var seen = new Set();
Serializer.objectHunt_(node, config, seen);
return Array.from(seen.keys());
};
/**
* Recursively search node find all non-primitives.
*
* @param {*} node JavaScript value to search.
* @param {!Config} config Configuation object.
* @param {!Set} seen Set of objects found so far.
*/
Serializer.objectHunt_ = function(node, config, seen) {
if (!node || (typeof node !== 'object' && typeof node !== 'function')) {
// node is primitive. Nothing to do.
return;
}
var obj = /** @type {!Object} */(node);
if (seen.has(obj)) return;
var proto = Object.getPrototypeOf(obj);
seen.add(obj);
if (typeof obj === 'object') { // Recurse.
var typeInfo = config.byProto.get(proto);
var prune = (typeInfo && typeInfo.prune) || [];
// Properties.
var keys = Object.getOwnPropertyNames(obj);
for (var i = 0; i < keys.length; i++) {
var key = keys[i];
if (prune.includes(key)) continue;
Serializer.objectHunt_(obj[key], config, seen);
}
// Set members.
if (obj instanceof Set || obj instanceof IterableWeakSet) {
obj.forEach(function(value) {
Serializer.objectHunt_(value, config, seen);
});
}
// Map entries.
if (obj instanceof Map || obj instanceof IterableWeakMap) {
obj.forEach(function(value, key) {
Serializer.objectHunt_(key, config, seen);
Serializer.objectHunt_(value, config, seen);
});
}
}
};
module.exports = Serializer;
================================================
FILE: server/startup/cc.js
================================================
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Initialisation code to expose CC-specific extensions
* not exposed by server/startup/esx.js for testing.
* @author cpcallen@google.com (Christopher Allen)
*/
///////////////////////////////////////////////////////////////////////////////
// Namespace for CodeCity-specific extensions.
//
var CC = {};
///////////////////////////////////////////////////////////////////////////////
// Permissions API.
//
CC.root = new 'CC.root';
var perms = new 'perms';
var setPerms = new 'setPerms';
///////////////////////////////////////////////////////////////////////////////
// Networking API.
//
CC.connectionListen = new 'CC.connectionListen';
CC.connectionUnlisten = new 'CC.connectionUnlisten';
CC.connectionWrite = new 'CC.connectionWrite';
CC.connectionClose = new 'CC.connectionClose';
CC.xhr = new 'CC.xhr';
================================================
FILE: server/startup/es5.js
================================================
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Polyfills to bring the server's partial JavaScript
* implementation up to ECMAScript 5.1 (or close to it).
* @author fraser@google.com (Neil Fraser)
*/
// Global functions.
var parseInt = new 'parseInt';
var parseFloat = new 'parseFloat';
var isNaN = new 'isNaN';
var isFinite = new 'isFinite';
var escape = new 'escape';
var unescape = new 'unescape';
var decodeURI = new 'decodeURI';
var decodeURIComponent = new 'decodeURIComponent';
var encodeURI = new 'encodeURI';
var encodeURIComponent = new 'encodeURIComponent';
// As a special case, eval is not included in this list: it must be
// set in the global scope by the interpreter because binding eval in
// strict mode is illegal.
// Global objects.
var Object = new 'Object';
var Function = new 'Function';
var Array = new 'Array';
var String = new 'String';
var Boolean = new 'Boolean';
var Number = new 'Number';
var Date = new 'Date';
var RegExp = new 'RegExp';
var Error = new 'Error';
var EvalError = new 'EvalError';
var RangeError = new 'RangeError';
var ReferenceError = new 'ReferenceError';
var SyntaxError = new 'SyntaxError';
var TypeError = new 'TypeError';
var URIError = new 'URIError';
var Math = {};
var JSON = {};
// Bootstrap the defineProperty function in two steps.
Object.defineProperty = new 'Object.defineProperty';
Object.defineProperty(Object, 'defineProperty', {enumerable: false});
(function() {
// Hack to work around restriction that the 'new hack' only works on
// literal strings. Note name must not contain any double quotes or
// backslashes, because we have no easy way to escape them yet!
var builtin = function(name) {
return eval('new "' + name + '"');
};
var classes = ['Object', 'Function', 'Array', 'String', 'Boolean', 'Number',
'Date', 'RegExp', 'Error', 'EvalError', 'RangeError',
'ReferenceError', 'SyntaxError', 'TypeError', 'URIError'];
// Prototypes of global constructors.
for (var i = 0; i < classes.length; i++) {
var constructor = builtin(classes[i]);
Object.defineProperty(constructor, 'prototype', {
configurable: false,
enumerable: false,
writable: false,
value: builtin(classes[i] + '.prototype')
});
Object.defineProperty(constructor.prototype, 'constructor', {
configurable: true,
enumerable: false,
writable: true,
value: constructor
});
}
// Configure Error and its subclasses.
var errors = ['Error', 'EvalError', 'RangeError', 'ReferenceError',
'SyntaxError', 'TypeError', 'URIError'];
for (var i = 0; i < errors.length; i++) {
var constructor = builtin(errors[i]);
Object.defineProperty(constructor.prototype, 'name', {
configurable: true,
enumerable: false,
writable: true,
value: errors[i]
});
}
Object.defineProperty(Error.prototype, 'message', {
configurable: true,
enumerable: false,
writable: true,
value: ''
});
// Struct is a list of tuples:
// [Object, 'Object', [static methods], [instance methods]]
var struct = [
[Object, 'Object',
['getOwnPropertyNames', 'keys', 'getOwnPropertyDescriptor',
'getPrototypeOf', 'isExtensible', 'preventExtensions'],
['toString', 'toLocaleString', 'valueOf', 'hasOwnProperty',
'propertyIsEnumerable', 'isPrototypeOf']],
[Function, 'Function',
[],
['apply', 'bind', 'call', 'toString']],
[Array, 'Array',
['isArray'],
['toString', 'pop', 'push', 'shift', 'unshift', 'reverse', 'splice',
'slice', 'concat', 'indexOf', 'lastIndexOf']],
[String, 'String',
['fromCharCode'],
['trim', 'toLowerCase', 'toUpperCase', 'toLocaleLowerCase',
'toLocaleUpperCase', 'charAt', 'charCodeAt', 'substring', 'slice',
'substr', 'indexOf', 'lastIndexOf', 'concat', 'localeCompare', 'split',
'match', 'search', 'replace', 'toString', 'valueOf']],
[Boolean, 'Boolean',
[],
['toString', 'valueOf']],
[Number, 'Number',
[],
['toExponential', 'toFixed', 'toLocaleString', 'toPrecision', 'toString',
'valueOf']],
[Date, 'Date',
['now', 'parse', 'UTC'],
['toString', 'getDate', 'getDay', 'getFullYear', 'getHours',
'getMilliseconds', 'getMinutes', 'getMonth', 'getSeconds', 'getTime',
'getTimezoneOffset', 'getUTCDate', 'getUTCDay', 'getUTCFullYear',
'getUTCHours', 'getUTCMilliseconds', 'getUTCMinutes', 'getUTCMonth',
'getUTCSeconds', 'getYear', 'setDate', 'setFullYear', 'setHours',
'setMilliseconds', 'setMinutes', 'setMonth', 'setSeconds', 'setTime',
'setUTCDate', 'setUTCFullYear', 'setUTCHours', 'setUTCMilliseconds',
'setUTCMinutes', 'setUTCMonth', 'setUTCSeconds', 'setYear',
'toDateString', 'toISOString', 'toJSON', 'toGMTString', 'toTimeString',
'toUTCString', 'toLocaleDateString', 'toLocaleString',
'toLocaleTimeString']],
[RegExp, 'RegExp',
[],
['toString', 'test', 'exec']],
[Error, 'Error',
[],
['toString']],
[Math, 'Math',
['abs', 'acos', 'asin', 'atan', 'atan2', 'ceil', 'cos', 'exp', 'floor',
'log', 'max', 'min', 'pow', 'random', 'round', 'sin', 'sqrt', 'tan'],
[]],
[JSON, 'JSON',
['parse', 'stringify'],
[]]
];
for (var i = 0; i < struct.length; i++) {
var obj = struct[i][0];
var objName = struct[i][1];
var staticMethods = struct[i][2];
var instanceMethods = struct[i][3];
for (var j = 0; j < staticMethods.length; j++) {
var member = staticMethods[j];
Object.defineProperty(obj, member,
{configurable: true,
enumerable: false,
writable: true,
value: builtin(objName + '.' + member)});
}
for (var j = 0; j < instanceMethods.length; j++) {
var member = instanceMethods[j];
Object.defineProperty(obj.prototype, member,
{configurable: true,
enumerable: false,
writable: true,
value: builtin(objName + '.prototype.' + member)});
}
}
})();
Object.defineProperty(Number, 'MAX_VALUE', {
configurable: false,
enumerable: false,
writable: false,
value: 1.7976931348623157e+308
});
Object.defineProperty(Number, 'MIN_VALUE', {
configurable: false,
enumerable: false,
writable: false,
value: 5e-324
});
Object.defineProperty(Number, 'NaN', {
configurable: false,
enumerable: false,
writable: false,
value: NaN
});
Object.defineProperty(Number, 'NEGATIVE_INFINITY', {
configurable: false,
enumerable: false,
writable: false,
value: -Infinity
});
Object.defineProperty(Number, 'POSITIVE_INFINITY', {
configurable: false,
enumerable: false,
writable: false,
value: Infinity
});
Object.defineProperty(Math, 'E', {
configurable: false,
enumerable: false,
writable: false,
value: 2.718281828459045
});
Object.defineProperty(Math, 'LN2', {
configurable: false,
enumerable: false,
writable: false,
value: 0.6931471805599453
});
Object.defineProperty(Math, 'LN10', {
configurable: false,
enumerable: false,
writable: false,
value: 2.302585092994046
});
Object.defineProperty(Math, 'LOG2E', {
configurable: false,
enumerable: false,
writable: false,
value: 1.4426950408889634
});
Object.defineProperty(Math, 'LOG10E', {
configurable: false,
enumerable: false,
writable: false,
value: 0.4342944819032518
});
Object.defineProperty(Math, 'PI', {
configurable: false,
enumerable: false,
writable: false,
value: 3.141592653589793
});
Object.defineProperty(Math, 'SQRT1_2', {
configurable: false,
enumerable: false,
writable: false,
value: 0.7071067811865476
});
Object.defineProperty(Math, 'SQRT2', {
configurable: false,
enumerable: false,
writable: false,
value: 1.4142135623730951
});
Object.defineProperty(RegExp.prototype, 'global', {
configurable: false,
enumerable: false,
writable: false,
value: undefined
});
Object.defineProperty(RegExp.prototype, 'ignoreCase', {
configurable: false,
enumerable: false,
writable: false,
value: undefined
});
Object.defineProperty(RegExp.prototype, 'multiline', {
configurable: false,
enumerable: false,
writable: false,
value: undefined
});
Object.defineProperty(RegExp.prototype, 'source', {
configurable: false,
enumerable: false,
writable: false,
value: '(?:)'
});
///////////////////////////////////////////////////////////////////////////////
// Object polyfills
///////////////////////////////////////////////////////////////////////////////
// Add a polyfill to handle create's second argument.
Object.create = function create(proto, props) {
var obj = (new 'Object.create')(proto);
props && Object.defineProperties(obj, props);
return obj;
};
Object.defineProperty(Object, 'create', {enumerable: false});
Object.defineProperties = function defineProperties(obj, props) {
if (!obj || (typeof obj !== 'object' && typeof obj !== 'function')) {
throw new TypeError('Object.defineProperties called on type ' + typeof obj +
', not type object or function');
}
var keys = Object.keys(props);
for (var i = 0; i < keys.length; i++) {
Object.defineProperty(obj, keys[i], props[keys[i]]);
}
return obj;
};
Object.defineProperty(Object, 'defineProperties', {enumerable: false});
Object.isFrozen = function isFrozen(obj) {
// TODO: replace this with builtin version.
// Per ES5.1, §15.2.3.12
if (obj === null || !(typeof obj === 'object' || typeof obj === 'function')) {
throw new TypeError('Primitive is already immutable');
}
var keys = Object.getOwnPropertyNames(obj);
for (var i = 0; i < keys.length; i++) {
var key = keys[i];
var pd = Object.getOwnPropertyDescriptor(obj, key);
// Assume no accessor properties.
if (pd.configurable || pd.writable) return false;
}
if (Object.isExtensible) return false;
return true;
};
Object.defineProperty(Object, 'isFrozen', {enumerable: false});
Object.isSealed = function isSealed(obj) {
// TODO: replace this with builtin version.
// Per ES5.1, §15.2.3.12
if (obj === null || !(typeof obj === 'object' || typeof obj === 'function')) {
throw new TypeError('Primitive is already immutable');
}
var keys = Object.getOwnPropertyNames(obj);
for (var i = 0; i < keys.length; i++) {
var key = keys[i];
var pd = Object.getOwnPropertyDescriptor(obj, key);
if (pd.configurable) return false;
}
if (Object.isExtensible) return false;
return true;
};
Object.defineProperty(Object, 'isSealed', {enumerable: false});
Object.freeze = function freeze(obj) {
// TODO: replace this with builtin version.
// Per ES5.1, §15.2.3.9
if (obj === null || !(typeof obj === 'object' || typeof obj === 'function')) {
throw new TypeError('Primitive is already immutable');
}
var keys = Object.getOwnPropertyNames(obj);
for (var i = 0; i < keys.length; i++) {
var key = keys[i];
// Assume no accessor properties.
Object.defineProperty(obj, key, {writable: false, configurable: false});
}
Object.preventExtensions(obj);
};
Object.defineProperty(Object, 'freeze', {enumerable: false});
Object.seal = function seal(obj) {
// TODO: replace this with builtin version.
// Per ES5.1, §15.2.3.8
if (obj === null || !(typeof obj === 'object' || typeof obj === 'function')) {
throw new TypeError('Primitive is already immutable');
}
var keys = Object.getOwnPropertyNames(obj);
for (var i = 0; i < keys.length; i++) {
var key = keys[i];
// Assume no accessor properties.
Object.defineProperty(obj, key, {configurable: false});
}
Object.preventExtensions(obj);
};
Object.defineProperty(Object, 'seal', {enumerable: false});
///////////////////////////////////////////////////////////////////////////////
// Array.prototype polyfills
///////////////////////////////////////////////////////////////////////////////
Array.prototype.every = function every(callback/*, thisArg*/) {
// Polyfill copied from:
// developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/ever
if (this === null || this === undefined) {
throw new TypeError('Array.prototype.every called on ' + this);
} else if (typeof callback !== 'function') {
throw new TypeError('callback is type ' + typeof callback +
', not type function');
}
var o = Object(this);
var len = o.length >>> 0;
var thisArg = arguments[1];
for (var k = 0; k < len; k++) {
if (k in o && !callback.call(thisArg, o[k], k, o)) return false;
}
return true;
};
Object.defineProperty(Array.prototype, 'every', {enumerable: false});
Array.prototype.filter = function filter(callback/*, thisArg*/) {
// Polyfill copied from:
// developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/filter
if (this === null || this === undefined) {
throw new TypeError('Array.prototype.filter called on ' + this);
} else if (typeof callback !== 'function') {
throw new TypeError('callback is type ' + typeof callback +
', not type function');
}
var o = Object(this);
var len = o.length >>> 0;
var res = [];
var thisArg = arguments[1];
for (var i = 0; i < len; i++) {
if (i in o) {
var val = o[i];
if (callback.call(thisArg, val, i, o)) res.push(val);
}
}
return res;
};
Object.defineProperty(Array.prototype, 'filter', {enumerable: false});
Array.prototype.forEach = function forEach(callback/*, thisArg*/) {
// Polyfill copied from:
// developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach
if (this === null || this === undefined) {
throw new TypeError('Array.prototype.forEach called on ' + this);
} else if (typeof callback !== 'function') {
throw new TypeError('callback is type ' + typeof callback +
', not type function');
}
var o = Object(this);
var len = o.length >>> 0;
var thisArg = arguments[1];
for (var k = 0; k < len; k++) {
if (k in o) callback.call(thisArg, o[k], k, o);
}
};
Object.defineProperty(Array.prototype, 'forEach', {enumerable: false});
(function() {
// For cycle detection in array to string and error conversion; see
// spec bug github.com/tc39/ecma262/issues/289.
var visited = [];
Array.prototype.join = function join(separator) {
// This implements Array.prototype.join from ES5 §15.4.4.5, with
// the addition of cycle detection as discussed in
// https://github.com/tc39/ecma262/issues/289.
//
// Variable names reflect those in the spec.
//
// N.B. This function is defined in a closure!
var isObj = (typeof this === 'object' || typeof this === 'function') &&
this !== null;
if (isObj) {
if (visited.indexOf(this) !== -1) {
return '';
}
visited.push(this);
}
try {
// TODO(cpcallen): setPerms(callerPerms());
var len = this.length >>> 0;
var sep = (separator === undefined) ? ',' : String(separator);
if (!len) {
return '';
}
var r = '';
for (var k = 0; k < len; k++) {
if (k > 0) r += sep;
var element = this[k];
if (element !== undefined && element !== null) {
r += String(element);
}
}
return r;
} finally {
if (isObj) visited.pop();
}
};
})();
Object.defineProperty(Array.prototype, 'join', {enumerable: false});
Array.prototype.map = function map(callback/*, thisArg*/) {
// Polyfill copied from:
// developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/map
if (this === null || this === undefined) {
throw new TypeError('Array.prototype.map called on ' + this);
} else if (typeof callback !== 'function') {
throw new TypeError('callback is type ' + typeof callback +
', not type function');
}
var o = Object(this);
var len = o.length >>> 0;
var A = new Array(len);
var thisArg = arguments[1];
for (var k = 0; k < len; k++) {
if (k in o) A[k] = callback.call(thisArg, o[k], k, o);
}
return A;
};
Object.defineProperty(Array.prototype, 'map', {enumerable: false});
Array.prototype.reduce = function reduce(callback /*, initialValue*/) {
// Polyfill copied from:
// developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce
if (this === null || this === undefined) {
throw new TypeError('Array.prototype.reduce called on ' + this);
} else if (typeof callback !== 'function') {
throw new TypeError('callback is type ' + typeof callback +
', not type function');
}
var o = Object(this);
var len = o.length >>> 0;
var k = 0;
var value;
if (arguments.length > 1) {
value = arguments[1];
} else {
while (k < len && !(k in o)) k++;
if (k >= len) {
throw new TypeError('Reduce of empty array with no initial value');
}
value = o[k++];
}
for (; k < len; k++) {
if (k in o) value = callback(value, o[k], k, o);
}
return value;
};
Object.defineProperty(Array.prototype, 'reduce', {enumerable: false});
Array.prototype.reduceRight = function reduceRight(callback /*, initialValue*/) {
// Polyfill copied from:
// developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/ReduceRight
if (this === null || this === undefined) {
throw new TypeError('Array.prototype.reduceRight called on ' + this);
} else if (typeof callback !== 'function') {
throw new TypeError('callback is type ' + typeof callback +
', not type function');
}
var o = Object(this);
var len = o.length >>> 0;
var k = len - 1;
var value;
if (arguments.length > 1) {
value = arguments[1];
} else {
while (k >= 0 && !(k in o)) k--;
if (k < 0) {
throw new TypeError('Reduce of empty array with no initial value');
}
value = o[k--];
}
for (; k >= 0; k--) {
if (k in o) value = callback(value, o[k], k, o);
}
return value;
};
Object.defineProperty(Array.prototype, 'reduceRight', {enumerable: false});
Array.prototype.some = function some(callback/*, thisArg*/) {
// Polyfill copied from:
// developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/some
if (this === null || this === undefined) {
throw new TypeError('Array.prototype.some called on ' + this);
} else if (typeof callback !== 'function') {
throw new TypeError('callback is type ' + typeof callback +
', not type function');
}
var o = Object(this);
var len = o.length >>> 0;
var thisArg = arguments[1];
for (var i = 0; i < len; i++) {
if (i in o && callback.call(thisArg, o[i], i, o)) {
return true;
}
}
return false;
};
Object.defineProperty(Array.prototype, 'some', {enumerable: false});
Array.prototype.sort = function sort(comparefn) {
// Polylfill adapted from:
// https://github.com/v8/v8/blob/8e43b9c01d60ddb5e58ec8de9d34616ea1bb905f/src/js/array.js
// TODO(cpcallen): as of ES2020, Array.prototype.sort must be stable.
var obj = this;
// Let obj = ToObject(this)
if (typeof(obj) !== 'object' && typeof(obj) !== 'function' || obj === null) {
throw new TypeError("Can't convert " + obj + ' to Object');
}
// Let len = ToLength(obj.length)
var len = Number(obj.length);
if (isNaN(len) || len < 0) len = 0;
if (len !== 0 && isFinite(len)) len = Math.trunc(len);
len = Math.min(len, Number.MAX_SAFE_INTEGER);
// Make sure comparefn is usable.
if (comparefn === undefined) {
comparefn = function (x, y) {
x = String(x);
y = String(y);
if (x === y) return 0;
else return x < y ? -1 : 1;
};
} else if(typeof(comparefn) !== 'function') {
throw new TypeError(
'The comparison function must be either a function or undefined');
}
if (len < 2) return obj;
// The ES spec says that the sort order is implementation-defined if
// the array (or array-like) being sorted is sparse and prototype
// properties can be seen through the holes.
//
// Previously V8 (for compatibility with JSC) also sorted properties
// inherited from the prototype chain on non-Array objects. It did
// this by copying them to this object and sorting only own
// properties. Newer versions of V8 don't seem to do this any more,
// so for simplicity we sort only own properties.
//
// We do this by first moving all non-undefined properties to the
// front of the array and move the undefineds after that. This
// moves holes to the end.
//
// TODO(cpcallen): this is slow. Do it (as V8 did, before moving to
// a torque-based implementation) using a native function.
var undefCount = 0;
for (var i = 0, j = 0; j < len; j++) {
if (Object.prototype.hasOwnProperty.call(obj, j)) {
if (obj[j] === undefined) {
undefCount++;
} else {
obj[i++] = obj[j];
}
}
}
var definedCount = i;
for (; undefCount; undefCount--) {
obj[i++] = undefined;
}
for (; i < len; i++) {
delete obj[i];
}
Array.prototype.sort.quicksort_(obj, 0, definedCount, comparefn);
return obj;
};
Object.defineProperty(Array.prototype, 'sort', {enumerable: false});
// Helper functions.
Array.prototype.sort.insertionSort_ = function insertionSort_(
a, from, to, comparefn) {
// For short (length <= 10) arrays, insertion sort is used for efficiency.
for (var i = from + 1; i < to; i++) {
var element = a[i];
for (var j = i - 1; j >= from; j--) {
var tmp = a[j];
var order = comparefn(tmp, element);
if (order > 0) {
a[j + 1] = tmp;
} else {
break;
}
}
a[j + 1] = element;
}
};
Object.defineProperty(Array.prototype.sort, 'insertionSort_',
{enumerable: false});
Array.prototype.sort.getThirdIndex_ = function getThirdIndex_(
a, from, to, comparefn) {
var t_array = [];
// Use both 'from' and 'to' to determine the pivot candidates.
var increment = 200 + ((to - from) & 15);
var j = 0;
from += 1;
to -= 1;
for (var i = from; i < to; i += increment) {
t_array[j] = [i, a[i]];
j++;
}
t_array.sort(function(a, b) {
return comparefn(a[1], b[1]);
});
var third_index = t_array[t_array.length >> 1][0];
return third_index;
};
Object.defineProperty(Array.prototype.sort, 'getThirdIndex_',
{enumerable: false});
Array.prototype.sort.quicksort_ = function quicksort_(a, from, to, comparefn) {
/* In-place QuickSort algorithm.
*/
var third_index = 0;
while (true) {
// Insertion sort is faster for short arrays.
if (to - from <= 10) {
Array.prototype.sort.insertionSort_(a, from, to, comparefn);
return;
}
if (to - from > 1000) {
third_index = Array.prototype.sort.getThirdIndex_(a, from, to, comparefn);
} else {
third_index = from + ((to - from) >> 1);
}
// Find a pivot as the median of first, last and middle element.
var v0 = a[from];
var v1 = a[to - 1];
var v2 = a[third_index];
var c01 = comparefn(v0, v1);
if (c01 > 0) {
// v1 < v0, so swap them.
var tmp = v0;
v0 = v1;
v1 = tmp;
} // v0 <= v1.
var c02 = comparefn(v0, v2);
if (c02 >= 0) {
// v2 <= v0 <= v1.
var tmp = v0;
v0 = v2;
v2 = v1;
v1 = tmp;
} else {
// v0 <= v1 && v0 < v2
var c12 = comparefn(v1, v2);
if (c12 > 0) {
// v0 <= v2 < v1
var tmp = v1;
v1 = v2;
v2 = tmp;
}
}
// v0 <= v1 <= v2
a[from] = v0;
a[to - 1] = v2;
var pivot = v1;
var low_end = from + 1; // Upper bound of elements lower than pivot.
var high_start = to - 1; // Lower bound of elements greater than pivot.
a[third_index] = a[low_end];
a[low_end] = pivot;
// From low_end to i are elements equal to pivot.
// From i to high_start are elements that haven't been compared yet.
partition: for (var i = low_end + 1; i < high_start; i++) {
var element = a[i];
var order = comparefn(element, pivot);
if (order < 0) {
a[i] = a[low_end];
a[low_end] = element;
low_end++;
} else if (order > 0) {
do {
high_start--;
if (high_start == i) break partition;
var top_elem = a[high_start];
order = comparefn(top_elem, pivot);
} while (order > 0);
a[i] = a[high_start];
a[high_start] = element;
if (order < 0) {
element = a[i];
a[i] = a[low_end];
a[low_end] = element;
low_end++;
}
}
}
if (to - high_start < low_end - from) {
quicksort_(a, high_start, to, comparefn);
to = low_end;
} else {
quicksort_(a, from, low_end, comparefn);
from = high_start;
}
}
};
Object.defineProperty(Array.prototype.sort, 'quicksort_', {enumerable: false});
Array.prototype.toLocaleString = function toLocaleString() {
var out = [];
for (var i = 0; i < this.length; i++) {
out[i] = (this[i] === null || this[i] === undefined) ?
'' : this[i].toLocaleString();
}
return out.join(',');
};
Object.defineProperty(Array.prototype, 'toLocaleString', {enumerable: false});
///////////////////////////////////////////////////////////////////////////////
// String.prototype polyfills
///////////////////////////////////////////////////////////////////////////////
// String.prototype.length is always 0.
Object.defineProperty(String.prototype, 'length', {value: 0});
String.prototype.replace = function replace(substr, newSubstr) {
// Polyfill to handle String.prototype.replace's second argument being
// a function.
if (typeof newSubstr !== 'function') {
// string.replace(string|regexp, string)
return (new 'String.prototype.replace').call(this, substr, newSubstr);
}
var str = this;
if (substr instanceof RegExp) { // string.replace(regexp, function)
var subs = [];
var m = substr.exec(str);
while (m) {
m.push(m.index, str);
var inject = newSubstr.apply(undefined, m);
subs.push([m.index, m[0].length, inject]);
m = substr.global ? substr.exec(str) : null;
}
for (var i = subs.length - 1; i >= 0; i--) {
str = str.substring(0, subs[i][0]) + subs[i][2] +
str.substring(subs[i][0] + subs[i][1]);
}
} else { // string.replace(string, function)
var i = str.indexOf(substr);
if (i !== -1) {
var inject = newSubstr(str.substr(i, substr.length), i, str);
str = str.substring(0, i) + inject +
str.substring(i + substr.length);
}
}
return str;
};
Object.defineProperty(String.prototype, 'replace', {enumerable: false});
================================================
FILE: server/startup/es6.js
================================================
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Polyfills to bring the server's partial JavaScript
* implementation to include some features of ECMAScript 2015 (ES6).
* @author fraser@google.com (Neil Fraser)
*/
// Global objects.
var WeakMap = new 'WeakMap';
(function() {
// Hack to work around restriction that the 'new hack' only works on
// literal strings. Note name must not contain any double quotes or
// backslashes, because we have no easy way to escape them yet!
var builtin = function(name) {
return eval('new "' + name + '"');
};
var classes = ['WeakMap'];
// Prototypes of global constructors.
for (var i = 0; i < classes.length; i++) {
var constructor = builtin(classes[i]);
Object.defineProperty(constructor, 'prototype', {
configurable: false,
enumerable: false,
writable: false,
value: builtin(classes[i] + '.prototype')
});
Object.defineProperty(constructor.prototype, 'constructor', {
configurable: true,
enumerable: false,
writable: true,
value: constructor
});
}
// Struct is a list of tuples:
// [Object, 'Object', [static methods], [instance methods]]
var struct = [
[Object, 'Object', ['is', 'setPrototypeOf'], []],
[String, 'String', [], ['endsWith', 'includes', 'repeat', 'startsWith']],
[Number, 'Number', ['isFinite', 'isInteger', 'isNaN', 'isSafeInteger'], []],
[Math, 'Math', ['acosh', 'asinh', 'atanh', 'cbrt', 'clz32', 'cosh', 'expm1',
'fround', 'hypot', 'imul', 'log10', 'log1p', 'log2', 'sign',
'sinh', 'tanh', 'trunc'], []],
[WeakMap, 'WeakMap', [], ['delete', 'get', 'has', 'set']],
];
for (var i = 0; i < struct.length; i++) {
var obj = struct[i][0];
var objName = struct[i][1];
var staticMethods = struct[i][2];
var instanceMethods = struct[i][3];
for (var j = 0; j < staticMethods.length; j++) {
var member = staticMethods[j];
Object.defineProperty(obj, member,
{configurable: true,
enumerable: false,
writable: true,
value: builtin(objName + '.' + member)});
}
for (var j = 0; j < instanceMethods.length; j++) {
var member = instanceMethods[j];
Object.defineProperty(obj.prototype, member,
{configurable: true,
enumerable: false,
writable: true,
value: builtin(objName + '.prototype.' + member)});
}
}
})();
///////////////////////////////////////////////////////////////////////////////
// Object constructor polyfills
///////////////////////////////////////////////////////////////////////////////
Object.assign = function assign(target, varArgs) {
// The length property of the assign method is 2.
if (target === null || target === undefined) {
throw new TypeError('Cannot convert undefined or null to object');
}
target = Object(target);
for (var i = 1; i < arguments.length; i++) {
var src = arguments[i];
if (src !== null && src !== undefined) {
var keys = Object.keys(src);
for (var j = 0; j < keys.length; j++) {
var key = keys[j];
target[key] = src[key];
}
}
}
return target;
};
Object.defineProperty(Array, 'assign', {enumerable: false});
///////////////////////////////////////////////////////////////////////////////
// Array constructor polyfills
///////////////////////////////////////////////////////////////////////////////
Array.from = function(arrayLike/*, mapFn, thisArg */) {
// Polyfill adapted from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from
// The length property of the from method is 1.
var isCallable = function (fn) {
return typeof fn === 'function' || Object.prototype.toString.call(fn) === '[object Function]';
};
var toInteger = function (value) {
var number = Number(value);
if (isNaN(number)) { return 0; }
if (number === 0 || !isFinite(number)) { return number; }
return (number > 0 ? 1 : -1) * Math.floor(Math.abs(number));
};
var toLength = function (value) {
var len = toInteger(value);
return Math.min(Math.max(len, 0), Number.MAX_SAFE_INTEGER);
};
// 1. Let C be the this value.
var C = this;
// 2. Let items be ToObject(arrayLike).
var items = Object(arrayLike);
// 3. ReturnIfAbrupt(items).
if (arrayLike == null) {
throw new TypeError('Array.from requires an array-like object - not null or undefined');
}
// 4. If mapfn is undefined, then let mapping be false.
var mapFn = arguments.length > 1 ? arguments[1] : void undefined;
var T;
if (typeof mapFn !== 'undefined') {
// 5. else
// 5. a If IsCallable(mapfn) is false, throw a TypeError exception.
if (!isCallable(mapFn)) {
throw new TypeError('Array.from: when provided, the second argument must be a function');
}
// 5. b. If thisArg was supplied, let T be thisArg; else let T be undefined.
if (arguments.length > 2) {
T = arguments[2];
}
}
// 10. Let lenValue be Get(items, "length").
// 11. Let len be ToLength(lenValue).
var len = toLength(items.length);
// 13. If IsConstructor(C) is true, then
// 13. a. Let A be the result of calling the [[Construct]] internal method
// of C with an argument list containing the single item len.
// 14. a. Else, Let A be ArrayCreate(len).
var A = isCallable(C) ? Object(new C(len)) : new Array(len);
// 16. Let k be 0.
var k = 0;
// 17. Repeat, while k < len… (also steps a - h)
var kValue;
while (k < len) {
kValue = items[k];
if (mapFn) {
A[k] = typeof T === 'undefined' ? mapFn(kValue, k) : mapFn.call(T, kValue, k);
} else {
A[k] = kValue;
}
k += 1;
}
// 18. Let putStatus be Put(A, "length", len, true).
A.length = len;
// 20. Return A.
return A;
};
Object.defineProperty(Array, 'from', {enumerable: false});
///////////////////////////////////////////////////////////////////////////////
// Array.prototype polyfills
///////////////////////////////////////////////////////////////////////////////
Array.prototype.find = function find(callback/*, thisArg*/) {
// Polyfill copied from:
// developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/find
if (this === null || this === undefined) {
throw new TypeError('Array.prototype.find called on ' + this);
} else if (typeof callback !== 'function') {
throw new TypeError('callback is type ' + typeof callback +
', not type function');
}
var o = Object(this);
var len = o.length >>> 0;
var thisArg = arguments[1];
for (var k = 0; k < len; k++) {
var kValue = o[k];
if (callback.call(thisArg, kValue, k, o)) {
return kValue;
}
}
return undefined;
};
Object.defineProperty(Array.prototype, 'find', {enumerable: false});
Array.prototype.findIndex = function findIndex(callback/*, thisArg*/) {
// Polyfill copied from:
// developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/findIndex
if (this === null || this === undefined) {
throw new TypeError('Array.prototype.findIndex called on ' + this);
} else if (typeof callback !== 'function') {
throw new TypeError('callback is type ' + typeof callback +
', not type function');
}
var o = Object(this);
var len = o.length >>> 0;
var thisArg = arguments[1];
for (var k = 0; k < len; k++) {
var kValue = o[k];
if (callback.call(thisArg, kValue, k, o)) {
return k;
}
}
return -1;
};
Object.defineProperty(Array.prototype, 'findIndex', {enumerable: false});
(function() {
function toInteger(value) {
var number = Number(value);
if (isNaN(number)) {
return 0;
} else if (number === 0 || !isFinite(number)) {
return number;
}
return Math.trunc(number);
}
function toLength(value) {
var len = toInteger(value);
if (len <= 0) {
return 0;
}
return Math.min(len, Number.MAX_SAFE_INTEGER); // Handles len === Infinity.
}
// For cycle detection in array to string and error conversion; see
// spec bug github.com/tc39/ecma262/issues/289.
var visited = [];
Array.prototype.join = function join(separator) {
// This implements Array.prototype.join from ES6 §22.1.3.12, with
// the addition of cycle detection as discussed in
// https://github.com/tc39/ecma262/issues/289.
//
// The only difference from the ES5 version of the spec is that
// .length is normalised using the specification function
// ToLength rather than ToUint32.
//
// Variable names reflect those in the spec.
//
// N.B. This function is defined in a closure!
var isObj = (typeof this === 'object' || typeof this === 'function') &&
this !== null;
if (isObj) {
if (visited.indexOf(this) !== -1) {
return '';
}
visited.push(this);
}
try {
// TODO(cpcallen): setPerms(callerPerms());
var len = toLength(this.length);
var sep = (separator === undefined) ? ',' : String(separator);
if (!len) {
return '';
}
var r = '';
for (var k = 0; k < len; k++) {
if (k > 0) {
r += sep;
}
var element = this[k];
if (element !== undefined && element !== null) {
r += String(element);
}
}
return r;
} finally {
if (isObj) {
visited.pop();
}
}
};
})();
Object.defineProperty(Array.prototype, 'join', {enumerable: false});
///////////////////////////////////////////////////////////////////////////////
// Number polyfills
///////////////////////////////////////////////////////////////////////////////
Object.defineProperty(Number, 'EPSILON',
{configurable: false,
enumerable: false,
writable: false,
value: Math.pow(2, -52)});
Object.defineProperty(Number, 'MAX_SAFE_INTEGER',
{configurable: false,
enumerable: false,
writable: false,
// Fortunately 2**53 is also safe as long as you don't increment it!:
value: Math.pow(2, 53) - 1 });
Object.defineProperty(Number, 'MIN_SAFE_INTEGER',
{configurable: false,
enumerable: false,
writable: false,
value: -Number.MAX_SAFE_INTEGER});
================================================
FILE: server/startup/es7.js
================================================
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Polyfills to bring the server's partial JavaScript
* implementation to include some features of ECMAScript 2016 (ES7).
* @author fraser@google.com (Neil Fraser)
*/
///////////////////////////////////////////////////////////////////////////////
// Array.prototype methods
///////////////////////////////////////////////////////////////////////////////
Array.prototype.includes = new 'Array.prototype.includes';
Object.defineProperty(Array.prototype, 'includes', {enumerable: false});
================================================
FILE: server/startup/es8.js
================================================
/**
* @license
* Copyright 2021 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Polyfills to bring the server's partial JavaScript
* implementation to include some features of ECMAScript 2017 (ES8).
* @author cpcallen@google.com (Christopher Allen)
*/
///////////////////////////////////////////////////////////////////////////////
// Object constructor polyfills
///////////////////////////////////////////////////////////////////////////////
Object.getOwnPropertyDescriptors = function getOwnPropertyDescriptors(obj) {
var ownKeys = Object.getOwnPropertyNames(obj);
var descriptors = {};
for (var i = 0; i < ownKeys.length; i++) {
var key = ownKeys[i];
var descriptor = Object.getOwnPropertyDescriptor(obj, key);
if (descriptor !== undefined) {
descriptors[key] = descriptor;
}
}
return descriptors;
};
Object.defineProperty(Object, 'getOwnPropertyDescriptors', {enumerable: false});
================================================
FILE: server/startup/esx.js
================================================
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Initialisation code to set up CodeCity JavaScript
* extensions.
* @author cpcallen@google.com (Christopher Allen)
*/
// Global objects.
var Thread = new 'Thread';
var PermissionError = new 'PermissionError';
(function() {
// Hack to work around restriction that the 'new hack' only works on
// literal strings. Note name must not contain any double quotes or
// backslashes, because we have no easy way to escape them yet!
var builtin = function(name) {
return eval('new "' + name + '"');
};
var classes = ['PermissionError', 'Thread'];
// Prototypes of global constructors.
for (var i = 0; i < classes.length; i++) {
var constructor = builtin(classes[i]);
Object.defineProperty(constructor, 'prototype', {
configurable: false,
enumerable: false,
writable: false,
value: builtin(classes[i] + '.prototype')
});
Object.defineProperty(constructor.prototype, 'constructor', {
configurable: true,
enumerable: false,
writable: true,
value: constructor
});
}
// Configure Error subclasses.
var errors = ['PermissionError'];
for (var i = 0; i < errors.length; i++) {
var constructor = builtin(errors[i]);
Object.defineProperty(constructor.prototype, 'name', {
configurable: true,
enumerable: false,
writable: true,
value: errors[i]
});
}
// Struct is a list of tuples:
// [Object, 'Object', [static methods], [instance methods]]
var struct = [
[Object, 'Object', ['getOwnerOf', 'setOwnerOf'], []],
[Thread, 'Thread',
['current', 'kill', 'suspend', 'callers'],
['getTimeLimit', 'setTimeLimit']],
];
for (var i = 0; i < struct.length; i++) {
var obj = struct[i][0];
var objName = struct[i][1];
var staticMethods = struct[i][2];
var instanceMethods = struct[i][3];
for (var j = 0; j < staticMethods.length; j++) {
var member = staticMethods[j];
Object.defineProperty(obj, member,
{configurable: true,
enumerable: false,
writable: true,
value: builtin(objName + '.' + member)});
}
for (var j = 0; j < instanceMethods.length; j++) {
var member = instanceMethods[j];
Object.defineProperty(obj.prototype, member,
{configurable: true,
enumerable: false,
writable: true,
value: builtin(objName + '.prototype.' + member)});
}
}
})();
///////////////////////////////////////////////////////////////////////////////
// Array.prototype polyfills
///////////////////////////////////////////////////////////////////////////////
(function() {
function toInteger(value) {
var number = Number(value);
if (isNaN(number)) {
return 0;
} else if (number === 0 || !isFinite(number)) {
return number;
}
return Math.trunc(number);
}
function toLength(value) {
var len = toInteger(value);
if (len <= 0) return 0;
return Math.min(len, Number.MAX_SAFE_INTEGER); // Handles len === Infinity.
};
// For cycle detection in array to string and error conversion; see
// spec bug github.com/tc39/ecma262/issues/289.
var visitedByThread = new WeakMap;
Array.prototype.join = function join(separator) {
// This implements Array.prototype.join from ES6 §22.1.3.12,
// with the addition of cycle detection as discussed in
// https://github.com/tc39/ecma262/issues/289.
//
// The only difference from the ES6 version is that the cycle
// detection mechanism is thread-aware, so multiple parallel
// invocations of .join will not interfere with each other.
//
// Variable names reflect those in the spec.
//
// N.B. This function is defined in a closure!
var isObj = (typeof this === 'object' || typeof this === 'function') &&
this !== null;
if (isObj) {
if (visitedByThread.has(Thread.current())) {
var visited = visitedByThread.get(Thread.current());
} else {
visited = [];
visitedByThread.set(Thread.current(), visited);
}
if (visited.includes(this)) {
return '';
}
visited.push(this);
}
try {
// TODO(cpcallen): setPerms(callerPerms());
var len = toLength(this.length);
var sep = (separator === undefined) ? ',' : String(separator);
if (!len) {
return '';
}
var r = '';
for (var k = 0; k < len; k++) {
if (k > 0) r += sep;
var element = this[k];
if (element !== undefined && element !== null) {
r += String(element);
}
}
return r;
} finally {
if (isObj) visited.pop();
if (!visited.length) {
visitedByThread.delete(Thread.current());
}
}
};
})();
Object.defineProperty(Array.prototype, 'join', {enumerable: false});
///////////////////////////////////////////////////////////////////////////////
// Threads API; parts are roughly conformant with HTML Living
// Standard, plus our local extensions.
//
var suspend = new 'Thread.suspend';
var setTimeout = function setTimeout(func, delay) {
/* setTimeout(func, delay[, ...args]) -> thread
*
* Arguments:
* func : A function to call when the timer elapses.
* delay : Time to wait (in ms) before calling the callback.
* ...args : Optional arguments to pass to func.
*
* Returns:
* , which may be passed to clearTimeout() to cancel.
*/
// TODO(cpcallen:perms): setPerms(callerPerms());
var args = Array.prototype.slice.call(arguments, 2);
args = [undefined, func, delay, undefined].concat(args);
return new (Thread.bind.apply(Thread, args));
// The parens around Thread.bind.apply(...) are mandatory: we want to
// "new" the function returned by bind, not apply (which is not a
// constructor).
return new (Thread.bind.apply(Thread, args))();
};
var clearTimeout = function clearTimeout(thread) {
/* clearTimeout(thread)
*
* Arguments:
* thread : The Thread object whose execution to be cancelled.
*
* Note that attempts to cancel the current thread (or any non-Thread
* value) is silently ignored.
*/
// TODO(cpcallen:perms): setPerms(callerPerms());
if (!(thread instanceof Thread) || thread === Thread.current()) {
return;
}
Thread.kill(thread);
};
================================================
FILE: server/tests/code_test.js
================================================
/**
* @license
* Copyright 2018 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Tests for utilities for manipulating JavaScript code.
* @author cpcallen@google.com (Christopher Allen)
*/
'use strict';
const {quote, parseString, testOnly} = require('../code');
const {T} = require('./testing');
const util = require('util');
// Unpack test-only exports:
const {count} = testOnly;
/**
* Unit tests for the count function.
* @param {!T} t The test runner object.
*/
exports.testCount = function(t) {
t.expect("count('bobob', 'b')", count('bobob', 'b'), 3);
t.expect("count('bobob', 'bo')", count('bobob', 'bo'), 2);
t.expect("count('bobob', 'bob')", count('bobob', 'bob'), 1);
t.expect("count('bobobob', 'bob')", count('bobobob', 'bob'), 2);
};
/**
* Unit tests for the quote function.
* @param {!T} t The test runner object.
*/
exports.testQuote = function(t) {
const cases = [
['foo', "'foo'"],
['"Hi", he said.', "'\"Hi\", he said.'"],
["Don't.", '"Don\'t."'],
['\'"', "'\\'\"'"],
['\0\/\b\n\r\t\v\\\x05\u2028\u2029',
"'\\0/\\b\\n\\r\\t\\v\\\\\\x05\\u2028\\u2029'"],
];
for (const tc of cases) {
const r = quote(tc[0]);
t.expect(util.format('quote(%o)', tc[0]), r, tc[1]);
t.expect(util.format('eval(quote(%o))', tc[0]), eval(r), tc[0]);
}
};
/**
* Unit tests for the parseString function.
* @param {!T} t The test runner object.
*/
exports.testParseString = function(t) {
const cases = [
`'foo'`,
`'"Hi", he said.'`,
`"\\"Hi\\", he said."`,
`'Don\\'t.'`,
`"Don't."`,
`'\\0 \\' \\" \\/ \\b \\n \\r \\t \\v \\\\ \\x00 \\xfF \\u09aF'`,
];
for (const tc of cases) {
const r = parseString(tc);
t.expect(util.format('parseString(%o)', tc), r, eval(tc));
}
const badCases = [
`'foo`,
`""Hi", he said."`,
`'Don't.'`,
`'\\j'`,
`'\\x0'`,
`'\\u123'`,
`'\\x1g'`,
`'\\x1G'`,
`'\\u1g00'`,
`'\\u1G00'`,
`'\r'`,
`'\n'`,
`'\u2028'`,
`'\u2029'`,
// Pathological cases that previously caused exponential
// backtracking.
`'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx`,
`"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx`,
];
for (const tc of badCases) {
try {
const r = parseString(tc);
t.fail(util.format('parseString(%o)', tc), "Didn't throw.");
} catch (e) {
t.pass(util.format('parseString(%o)', tc));
}
}
};
================================================
FILE: server/tests/db/core_01_$.js
================================================
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Initialize the $ object in the database.
* @author fraser@google.com (Neil Fraser)
*/
var $ = {};
================================================
FILE: server/tests/db/core_01_$.system.js
================================================
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Initialize the system object in the database.
* @author fraser@google.com (Neil Fraser)
*/
$.system = {};
$.system.log = new 'CC.log';
$.system.checkpoint = new 'CC.checkpoint';
$.system.shutdown = new 'CC.shutdown';
================================================
FILE: server/tests/db/test.cfg
================================================
{
"databaseDirectory": "./",
"checkpointInterval": 0,
"checkpointAtShutdown": true
}
================================================
FILE: server/tests/db/test_00_start.js
================================================
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Mock up a basic console.
* @author fraser@google.com (Neil Fraser)
*/
var console = {};
console.log = $.system.log;
console.assert = function(value, message) {
if (value) {
console.goodCount++;
} else {
$.system.log('FAIL:\t%s', message);
console.badCount++;
}
};
// Counters for unit test results.
console.goodCount = 0;
console.badCount = 0;
var tests = {};
================================================
FILE: server/tests/db/test_01_es5.js
================================================
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Test the ES5 functions of the server.
* @author fraser@google.com (Neil Fraser)
*/
// Run some tests of the various constructors and their associated
// literals and prototype objects.
tests.builtinClasses = function() {
var classes = [
{
constructor: Object,
literal: {},
prototypeProto: null,
classStr: '[object Object]',
},
{
constructor: Function,
literal: function(){},
prototypeType: 'function',
classStr: '[object Function]',
},
{
constructor: Array,
literal: [],
classStr: '[object Array]',
},
{
constructor: RegExp,
literal: /foo/,
classStr: '[object RegExp]',
prototypeClass: '[object Object]' // Was 'RegExp' in ES5.1.
},
{
constructor: Date,
classStr: '[object Date]',
prototypeClass: '[object Object]', // Was 'RegExp' in ES5.1.
functionNotConstructor: true // Date() doesn't construct.
},
{
constructor: Error,
classStr: '[object Error]',
},
{
constructor: EvalError,
prototypeProto: Error.prototype,
classStr: '[object Error]',
},
{
constructor: RangeError,
prototypeProto: Error.prototype,
classStr: '[object Error]',
},
{
constructor: ReferenceError,
prototypeProto: Error.prototype,
classStr: '[object Error]',
},
{
constructor: SyntaxError,
prototypeProto: Error.prototype,
classStr: '[object Error]',
},
{
constructor: TypeError,
prototypeProto: Error.prototype,
classStr: '[object Error]',
},
{
constructor: URIError,
prototypeProto: Error.prototype,
classStr: '[object Error]',
},
{
constructor: Boolean,
literal: true,
literalType: 'boolean',
noInstance: true,
classStr: '[object Boolean]',
},
{
constructor: Number,
literal: 42,
literalType: 'number',
noInstance: true,
classStr: '[object Number]',
},
{
constructor: String,
literal: "hello",
literalType: 'string',
noInstance: true,
classStr: '[object String]',
}
];
for (var i = 0, tc; (tc = classes[i]); i++) {
var c = tc.constructor;
var prototypeType = (tc.prototypeType || 'object');
// Check constructor is a function:
console.assert(typeof c === 'function', c + ' isFunction');
// Check constructor's proto is Function.prototype
console.assert(Object.getPrototypeOf(c) === Function.prototype,
c + ' protoIsFunctionPrototype');
// Check prototype is of correct type:
console.assert(typeof c.prototype === prototypeType,
c + ' prototypeIs');
// Check prototype has correct class:
console.assert(
Object.prototype.toString.apply(c.prototype) ===
tc.prototypeClass || tc.classStr,
c + ' prototypeClassIs');
// Check prototype has correct proto:
console.assert(
Object.getPrototypeOf(c.prototype) ===
(tc.prototypeProto === undefined ? Object.prototype : tc.prototypeProto),
c + ' prototypeProtoIs');
// Check prototype's .constructor is constructor:
console.assert(c.prototype.constructor === c,
c + ' prototypeConstructorIs');
if (!tc.noInstance) {
// Check instance's type:
console.assert(typeof new c === prototypeType, c + ' instanceIs');
// Check instance's proto:
console.assert(Object.getPrototypeOf(new c) === c.prototype,
c + ' instancePrototypeIs');
// Check instance's class:
console.assert(Object.prototype.toString.apply(new c) === tc.classStr,
c + ' instanceClassIs');
// Check instance is instanceof its contructor:
console.assert((new c) instanceof c, c + ' instanceIsInstanceof');
if (!tc.functionNotConstructor) {
// Recheck instances when constructor called as function:
// Recheck instance's type:
console.assert(typeof c() === prototypeType, c + ' returnIs');
// Recheck instance's proto:
console.assert(Object.getPrototypeOf(c()) === c.prototype,
c + ' returnPrototypeIs');
// Recheck instance's class:
console.assert(Object.prototype.toString.apply(c()) === tc.classStr,
c + ' returnClassIs');
// Recheck instance is instanceof its contructor:
console.assert(c() instanceof c, c + ' returnIsInstanceof');
}
}
if (tc.literal) {
var literalType = (tc.literalType || prototypeType);
// Check literal's type:
console.assert(typeof tc.literal === literalType, c + ' literalIs');
// Check literal's proto:
console.assert(Object.getPrototypeOf(tc.literal) === c.prototype,
c + ' literalPrototypeIs');
// Check literal's class:
console.assert(
Object.prototype.toString.apply(tc.literal) === tc.classStr,
c + ' literalClassIs');
// Primitives can never be instances.
if (literalType === 'object' || literalType === 'function') {
// Check literal is instanceof its constructor.
console.assert(tc.literal instanceof c, c + ' literalIsInstanceof');
}
}
}
};
// Run some tests of switch statements with fallthrough.
tests.switchFallthrough = function() {
var expected = [28, 31, 30, 12, 8];
for (var i = 0; i < expected.length; i++) {
var x = 0;
switch (i) {
case 1:
x += 1;
// fall through
case 2:
x += 2;
// fall through
default:
x += 16;
// fall through
case 3:
x += 4;
// fall through
case 4:
x += 8;
// fall through
}
console.assert(x === expected[i], 'switch fallthrough ' + i);
}
};
// Run some tests of switch statements.
tests.switchBreak = function() {
var expected = [30, 20, 20, 30, 40];
for (var i = 0; i < expected.length; i++) {
var x;
foo: {
switch (i) {
case 1:
x = 10;
// fall through
case 2:
x = 20;
break;
default:
x = 50;
// fall through
case 3:
x = 30;
break foo;
case 4:
x = 40;
}
}
console.assert(x === expected[i], 'switch ' + i);
}
};
// Run some tests of evaluation of binary expressions, as defined in
// §11.5--11.11 of the ES5.1 spec.
tests.binary = function() {
var cases = [
// Addition / concatenation:
["1 + 1", 2],
["'1' + 1", '11'],
["1 + '1'", '11'],
// Subtraction:
["'1' - 1", 0],
// Multiplication:
["'5' * '5'", 25],
["-5 * 0", -0],
["-5 * -0", 0],
["1 * NaN", NaN],
["Infinity * NaN", NaN],
["-Infinity * NaN", NaN],
["Infinity * Infinity", Infinity],
["Infinity * -Infinity", -Infinity],
["-Infinity * -Infinity", Infinity],
["-Infinity * Infinity", -Infinity],
// FIXME: add overflow/underflow cases
// Division:
["35 / '7'", 5],
["1 / 1", 1],
["1 / -1", -1],
["-1 / -1", 1],
["-1 / 1", -1],
["1 / NaN", NaN],
["NaN / NaN", NaN],
["NaN / 1", NaN],
["Infinity / Infinity", NaN],
["Infinity / -Infinity", NaN],
["-Infinity / -Infinity", NaN],
["-Infinity / Infinity", NaN],
["Infinity / 0", Infinity],
["Infinity / -0", -Infinity],
["-Infinity / -0", Infinity],
["-Infinity / 0", -Infinity],
["Infinity / 1", Infinity],
["Infinity / -1", -Infinity],
["-Infinity / -1", Infinity],
["-Infinity / 1", -Infinity],
["1 / Infinity", 0],
["1 / -Infinity", -0],
["-1 / -Infinity", 0],
["-1 / Infinity", -0],
["0 / 0", NaN],
["0 / -0", NaN],
["-0 / -0", NaN],
["-0 / 0", NaN],
["1 / 0", Infinity],
["1 / -0", -Infinity],
["-1 / -0", Infinity],
["-1 / 0", -Infinity],
// FIXME: add overflow/underflow cases
// Remainder:
["20 % 5.5", 3.5],
["20 % -5.5", 3.5],
["-20 % -5.5", -3.5],
["-20 % 5.5", -3.5],
["1 % NaN", NaN],
["NaN % NaN", NaN],
["NaN % 1", NaN],
["Infinity % 1", NaN],
["-Infinity % 1", NaN],
["1 % 0", NaN],
["1 % -0", NaN],
["Infinity % 0", NaN],
["Infinity % -0", NaN],
["-Infinity % -0", NaN],
["-Infinity % 0", NaN],
["0 % 1", 0],
["-0 % 1", -0],
// FIXME: add overflow/underflow cases
// Left shift:
["10 << 2", 40],
["10 << 28", -1610612736],
["10 << 33", 20],
["10 << 34", 40],
// Signed right shift:
["10 >> 4", 0],
["10 >> 33", 5],
["10 >> 34", 2],
["-11 >> 1", -6],
["-11 >> 2", -3],
// Signed right shift:
["10 >>> 4", 0],
["10 >>> 33", 5],
["10 >>> 34", 2],
["-11 >>> 0", 0xfffffff5],
["-11 >>> 1", 0x7ffffffa],
["-11 >>> 2", 0x3ffffffd],
["4294967338 >>> 0", 42],
// Bitwise:
["0x3 | 0x5", 0x7],
["0x3 ^ 0x5", 0x6],
["0x3 & 0x5", 0x1],
["NaN | 0", 0],
["-0 | 0", 0],
["Infinity | 0", 0],
["-Infinity | 0", 0],
// Comparisons:
//
// (This is mainly about making sure that the binary operators are
// hooked up to the abstract relational comparison algorithm
// correctly; that algorithm is tested separately to make sure
// details of comparisons are correct.)
["1 < 2", true],
["2 < 2", false],
["3 < 2", false],
["1 <= 2", true],
["2 <= 2", true],
["3 <= 2", false],
["1 > 2", false],
["2 > 2", false],
["3 > 2", true],
["1 >= 2", false],
["2 >= 2", true],
["3 >= 2", true],
// (Ditto for abstract equality comparison algorithm.)
["1 == 1", true],
["2 == 1", false],
["2 == 2", true],
["1 == 2", false],
["1 == '1'", true],
["1 != 1", false],
["2 != 1", true],
["2 != 2", false],
["1 != 2", true],
["1 != '1'", false],
// (Ditto for abstract strict equality comparison algorithm.)
["1 === 1", true],
["2 === 1", false],
["2 === 2", true],
["1 === 2", false],
["1 === '1'", false],
["1 !== 1", false],
["2 !== 1", true],
["2 !== 2", false],
["1 !== 2", true],
["1 !== '1'", true],
];
// Object.is is part of ES6, not ES5, so provide a helper function.
// Copied from:
// developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/is
function is(x, y) {
// SameValue algorithm
if (x === y) { // Steps 1-5, 7-10
// Steps 6.b-6.e: +0 != -0
return x !== 0 || 1 / x === 1 / y;
} else {
// Step 6.a: NaN == NaN
return x !== x && y !== y;
}
}
for (var i = 0, tc; (tc = cases[i]); i++) {
var actual = eval(tc[0]);
var expected = tc[1];
console.assert(is(actual, expected), tc[0] +
' Actual: ' + actual + ' Expected: ' + expected);
}
};
// Run some tests of the Abstract Relational Comparison Algorithm, as defined
// in §11.8.5 of the ES5.1 spec and as embodied by the '<' operator.
tests.arca = function() {
var cases = [
['0, NaN', undefined],
['NaN, NaN', undefined],
['NaN, 0', undefined],
['1, 1', false],
['0, -0', false],
['-0, 0', false],
['Infinity, Number.MAX_VALUE', false],
['Number.MAX_VALUE, Infinity', true],
['-Infinity, -Number.MAX_VALUE', true],
['-Number.MAX_VALUE, -Infinity', false],
['1, 2', true],
['2, 1', false],
// String comparisons:
['"", ""', false],
['"", " "', true],
['" ", ""', false],
['" ", " "', false],
['"foo", "foobar"', true],
['"foo", "bar"', false],
['"foobar", "foo"', false],
['"10", "9"', true],
['"10", 9', false],
// \ufb00 vs. \U0001f019: this test fails if we do simple
// lexicographic comparison of UTF-8 or UTF-32. The latter
// character is a larger code point and sorts later in UTF8,
// but in UTF16 it gets replaced by two surrogates, both of
// which are smaller than \uf000.
['"ff", "🀙"', false],
// Mixed:
['11, "2"', false], // Numeric
['2, "11"', true], // Numeric
['"11", "2"', true], // String
];
function arca(a, b) {
return ((a < b) || (a >= b)) ? (a < b) : undefined;
}
for (var i = 0, tc; (tc = cases[i]); i++) {
console.assert(tc[1] === eval('arca(' + tc[0] + ')'), 'ARCA: ' + tc[0]);
}
};
// Run some tests of the Abstract Equality Comparison Algorithm and
// the Abstract Strict Equality Comparison Algorithm, as defined in
// §11.9.3 and §11.9.6 respectively of the ES5.1 spec and as embodied
// by the '==' and '===' operators.
tests.aeca_aseca = function() {
var cases = [
['false, false', true, true], // Numeric
['false, true', false, false], // Numeric
['true, true', true, true], // Numeric
['true, false', false, false], // Numeric
// Numeric comparisons:
['0, NaN', false, false],
['NaN, NaN', false, false],
['NaN, 0', false, false],
['1, 1', true, true],
['0, -0', true, true],
['-0, 0', true, true],
['Infinity, Number.MAX_VALUE', false, false],
['Number.MAX_VALUE, Infinity', false, false],
['Infinity, -Number.MAX_VALUE', false, false],
['-Number.MAX_VALUE, -Infinity', false, false],
['1, 2', false, false],
['2, 1', false, false],
// String comparisons:
['"", ""', true, true],
['"", " "', false, false],
['" ", ""', false, false],
['" ", " "', true, true],
['"foo", "foobar"', false, false],
['"foo", "bar"', false, false],
['"foobar", "foo"', false, false],
['"10", "9"', false, false],
// Null / undefined:
['undefined, undefined', true, true],
['undefined, null', true, false],
['null, null', true, true],
['null, undefined', true, false],
// Objects:
['Object.prototype, Object.prototype', true, true],
['{}, {}', false, false],
// Mixed:
['"10", 10', true, false], // Numeric
['10, "10"', true, false], // Numeric
['"10", 9', false, false], // Numeric
['"10", "9"', false, false], // String
['"10", "10"', true, true], // String
['false, 0', true, false], // Numeric
['false, 1', false, false], // Numeric
['true, 1', true, false], // Numeric
['true, 0', false, false], // Numeric
['0, false', true, false], // Numeric
['1, false', false, false], // Numeric
['1, true', true, false], // Numeric
['0, true', false, false], // Numeric
['null, false', false, false],
['null, 0', false, false],
['null, ""', false, false],
['false, null', false, false],
['0, null', false, false],
['"", null', false, false],
['{}, false', false, false],
['{}, 0', false, false],
['{}, ""', false, false],
['{}, null', false, false],
['{}, undefined', false, false],
];
function aeca(a, b) {
return a == b;
}
function aseca(a, b) {
return a === b;
}
for (var i = 0, tc; (tc = cases[i]); i++) {
console.assert(tc[1] === eval('aeca(' + tc[0] + ')'), 'AECA: ' + tc[0]);
console.assert(tc[2] === eval('aseca(' + tc[0] + ')'), 'ASECA: ' + tc[0]);
}
};
tests.isFinite = function() {
console.assert(!isFinite(Infinity), 'isFinite Infinity');
console.assert(!isFinite(NaN), 'isFinite NaN');
console.assert(!isFinite(-Infinity), 'isFinite -Infinity');
console.assert(isFinite(0), 'isFinite 0');
console.assert(isFinite(2e64), 'isFinite 2e64');
console.assert(isFinite('0'), 'isFinite "0"');
console.assert(isFinite(null), 'isFinite null');
};
tests.isNaN = function() {
console.assert(isNaN(NaN), 'isNaN NaN');
console.assert(isNaN(0 / 0), 'isNaN 0 / 0');
console.assert(isNaN('NaN'), 'isNaN "NaN"');
console.assert(isNaN(undefined), 'isNaN undefined');
console.assert(isNaN({}), 'isNaN {}');
console.assert(isNaN('blabla'), 'isNaN "blabla"');
console.assert(!isNaN(true), 'isNaN true');
console.assert(!isNaN(null), 'isNaN null');
console.assert(!isNaN(37), 'isNaN 37');
console.assert(!isNaN('37'), 'isNaN "37"');
console.assert(!isNaN('37.37'), 'isNaN "37.37"');
console.assert(!isNaN(''), 'isNaN ""');
console.assert(!isNaN(' '), 'isNaN " "');
};
tests.basicMath = function() {
console.assert(1 + 1 === 2, 'onePlusOne');
console.assert(2 + 2 === 4,'twoPlusTwo');
console.assert(6 * 7 === 42, 'sixTimesSeven');
console.assert((3 + 12 / 4) * (10 - 3) === 42, 'simpleFourFunction');
};
tests.basicVariables = function() {
var x = 43;
console.assert(x === 43, 'variableDecl');
x = 44;
console.assert(x === 44, 'simpleAssignment');
};
tests.ternary = function() {
console.assert((true ? 'then' : 'else') === 'then', 'condTrue');
console.assert((false ? 'then' : 'else') === 'else', 'condFalse');
};
tests.ifElse = function() {
var ifTrue;
if (true) {
ifTrue = 'then';
} else {
ifTrue = 'else';
}
console.assert(ifTrue === 'then', 'ifTrue');
var ifFalse;
if (false) {
ifFalse = 'then';
} else {
ifFalse = 'else';
}
console.assert(ifFalse === 'else', 'ifFalse');
};
tests.propertyAssignment = function() {
var o = {};
o.foo = 45;
console.assert(o.foo == 45, 'propertyAssignment');
};
tests.propertyOnPrimitive = function() {
console.assert('foo'.length === 3, 'propertyOnPrimitiveGet');
try {
'foo'.bar = 42;
console.assert('foo'.length === 3, 'propertyOnPrimitiveSet');
} catch (e) {
console.assert(e.name === 'TypeError', 'propertyOnPrimitiveSetError');
}
};
tests.increment = function() {
var postincrement = 45;
postincrement++;
console.assert(postincrement++ === 46, 'postincrement');
var preincrement = 45;
++preincrement;
console.assert(++preincrement === 47, 'preincrement');
};
tests.concat = function() {
console.assert('foo' + 'bar' === 'foobar', 'concat');
};
tests.plusEquals = function() {
var plusequalsLeft = 40;
var plusequalsRight = 8;
plusequalsLeft += plusequalsRight;
console.assert(plusequalsLeft === 48, 'plusequalsLeft');
console.assert(plusequalsRight === 8, 'plusequalsRight');
};
tests.simpleFunctionExpression = function() {
var value;
var f = function() {
value = 49;
};
f();
console.assert(value === 49, 'simpleFunctionExpression');
};
tests.funExpWithParameter = function() {
var value;
var f = function(x) {
value = x;
};
f(50);
console.assert(value === 50, 'fExpWithParameter');
};
tests.functionReturn = function() {
console.assert('functionWithReturn', (function(x) { return x; })(51), 51);
console.assert('functionWithoutReturn', (function() {})(), undefined);
var multipleReturn = function() {
try {
return true;
} finally {
return false;
}
};
console.assert(multipleReturn() === false, 'multipleReturn');
};
tests.throwCatch = function() {
var f = function() {
throw 26;
};
var result;
try {
f();
} catch (e) {
result = e * 2;
}
console.assert(result === 52, 'throwCatch');
};
tests.throwCatchFalsey = function() {
var result;
try {
throw null;
} catch (e) {
result = 'caught ' + String(e);
}
console.assert(result === 'caught null', 'throwCatchFalsey');
};
tests.seqExpr = function() {
console.assert((51, 52, 53) === 53, 'seqExpr');
};
tests.labeledStatement = function() {
foo: var x = 54;
console.assert(x === 54, 'labeledStatement');
};
tests.whileLoop = function() {
var a = 0;
while (a < 55) {
a++;
}
console.assert(a === 55, 'whileLoop');
};
tests.whileFalse = function() {
var a = 56;
while (false) {
a++;
}
console.assert(a === 56, 'whileFalse');
};
tests.doWhileFalse = function() {
var a = 56;
do {
a++;
} while (false);
console.assert(a === 57, 'doWhileFalse');
};
tests.breakDoWhile = function() {
var a = 57;
do {
a++;
break;
a++;
} while (false);
console.assert(a === 58, 'breakDoWhile');
};
tests.selfBreak = function() {
console.assert(eval('foo: break foo;') === undefined, 'selfBreak');
};
tests.breakWithFinally = function() {
var a = 6;
foo: {
try {
a *= 10;
break foo;
} finally {
a--;
}
}
console.assert(a === 59, 'breakWithFinally');
};
tests.continueWithFinally = function() {
var a = 59;
do {
try {
continue;
} finally {
a++;
}
} while (false);
console.assert(a === 60, 'continueWithFinally');
};
tests.breakWithFinallyContinue = function() {
var a = 0;
while (a++ < 60) {
try {
break;
} finally {
continue;
}
}
console.assert(a === 61, 'breakWithFinallyContinue');
};
tests.returnWithFinallyContinue = function() {
var f = function() {
var i = 0;
while (i++ < 61) {
try {
return 42;
} finally {
continue;
}
}
return i;
};
console.assert(f() === 62, 'returnWithFinallyContinue');
};
tests.or = function() {
console.assert((63 || 'foo') === 63, 'orTrue');
console.assert((false || 64) === 64, 'orFalse');
var r = 0;
true || (r++);
console.assert(r === 0, 'orShortcircuit');
};
tests.and = function() {
console.assert((({}) && 65) === 65, 'andTrue');
console.assert((0 && 65) === 0, 'andFalse');
var r = 0;
false && (r++);
console.assert(r === 0, 'andShortcircuit');
};
tests.forTriangular = function() {
var t = 0;
for (var i = 0; i < 12; i++) {
t += i;
}
console.assert(t === 66, 'forTriangular');
};
tests.forIn = function() {
var x = 0, a = {a: 60, b:3, c:4};
for (var i in a) { x += a[i]; }
console.assert(x === 67, 'forIn');
};
tests.forInMemberExp = function() {
var x = 1, o = {foo: 'bar'}, a = {a:2, b:2, c:17};
for (o.foo in a) { x *= a[o.foo]; }
console.assert(x === 68, 'forInMemberExp');
};
tests.forInMembFunc = function() {
var x = 0, o = {};
var f = function() { x += 20; return o; };
var a = {a:2, b:3, c:4};
for (f().foo in a) { x += a[o.foo]; }
console.assert(x === 69, 'forInMembFunc');
};
tests.forInNullUndefined = function() {
var x = 0, o = {};
var f = function() { x++; return o; };
for (f().foo in null) { x++; }
for (f().foo in undefined) { x++; }
console.assert(x === 0, 'forInNullUndefined');
};
tests.switchDefaultFirst = function() {
var r;
switch ('not found') {
default:
r = 'OK';
break;
case 'decoy':
r = 'fail';
};
console.assert(r === 'OK', 'switchDefaultFirst');
}
tests.switchDefaultOnly = function() {
var r;
switch ('not found') {
default:
r = 'OK';
break;
};
console.assert(r === 'OK', 'switchDefaultOnly');
}
tests.switchEmptyToEnd = function() {
switch ('foo') {
default:
console.assert(false, 'switchEmptyToEnd');
case 'foo':
case 'bar':
}
};
tests.thisInMethod = function() {
var o = {
f: function() { return this.foo; },
foo: 70
};
console.assert(o.f() === 70, 'thisInMethod');
};
tests.thisInFormerMethod = function() {
var o = { f: function() { return this; }};
var g = o.f;
console.assert(g() === undefined, 'thisInFormerMethod');
};
tests.testThis = function() {
console.assert(this === tests, 'testThis');
console.assert(eval('this') === tests, 'evalThis');
console.assert(tests.testThis.globalThis === undefined, 'globalThis');
};
tests.testThis.globalThis = this;
tests.strictBoxedThis = function() {
// Run a test to ensure that 'this' is a primitive in methods invoked on
// primitives. (This also tests that interpreter is running in strict mode;
// in sloppy mode this will be boxed.)
try {
Object.prototype.foo = function() { return typeof this; };
console.assert('foo'.foo() === 'string', 'strictBoxedThis');
} finally {
console.assert(delete Object.prototype.foo, 'strictBoxedThisDelete');
}
};
tests.emptyArrayLength = function() {
console.assert([].length === 0, 'emptyArrayLength');
};
tests.arrayElidedLength = function() {
console.assert([1,,3,,].length === 4, 'arrayElidedLength');
};
tests.arrayElidedNotDefinedNotUndefined = function() {
var a = [,undefined,null,0,false];
console.assert(!(0 in a) && (1 in a) && (2 in a) && (3 in a) && (4 in a),
'arrayElidedNotDefinedNotUndefined');
};
tests.arrayLengthPropertyDescriptor = function() {
var a = [1, 2, 3];
var pd = Object.getOwnPropertyDescriptor(a, 'length');
console.assert((pd.value === 3), 'arrayLengthPropertyDescriptorValue');
console.assert(pd.writable && !pd.enumerable && !pd.configurable,
'arrayLengthPropertyDescriptor');
};
tests.arrayLength = function() {
var a;
function checkLen(exp, desc) {
if (a.length !== exp) {
var msg = 'a.length === ' + a.length + ' (expected: ' + exp + ')';
console.assert(false, desc ? msg + ' ' + desc : msg);
}
}
// Empty array has length == 0
a = [];
checkLen(0, 'on empty array');
// Adding non-numeric properties does not increase length:
a['zero'] = 0;
checkLen(0, 'after setting non-index property on []');
// Adding numeric properties >= length does increase length:
for (var i = 0; i < 5; i++) {
a[i] = i;
checkLen(i + 1, 'after setting a[' + i + ']');
}
// .length works propery even for large, sparse arrays, and even
// if values are undefined:
for (i = 3; i <= 31; i++) {
var idx = (1 << i) >>> 0; // >>> 0 converts int32 to uint32
a[idx] = undefined;
checkLen(idx + 1, 'after setting a[' + idx + ']');
}
// Adding numeric properties < length does not increase length:
a[idx - 1] = 'not the largest';
checkLen(idx + 1, 'after setting non-largest element');
// Verify behaviour around largest possible index:
a[0xfffffffd] = null;
checkLen(0xfffffffe);
a[0xfffffffe] = null;
checkLen(0xffffffff);
a[0xffffffff] = null; // Not an index.
checkLen(0xffffffff); // Unchanged.
a[0x100000000] = null; // Not an index.
checkLen(0xffffffff); // Unchanged.
function checkIdx(idx, exp, desc) {
var r = a.hasOwnProperty(idx);
var msg = 'a.hasOwnProperty(' + idx + ') === ' + r;
console.assert(r === exp, desc ? msg + ' ' + desc : msg);
}
// Setting length to existing value should have no effect:
a.length = 0xffffffff;
checkIdx(0xfffffffd, true);
checkIdx(0xfffffffe, true);
checkIdx(0xffffffff, true);
checkIdx(0x100000000, true);
// Setting length one less than maximum should remove largest
// index, but leave properties with keys too large to be indexes:
a.length = 0xfffffffe;
checkIdx(0xfffffffd, true);
checkIdx(0xfffffffe, false);
checkIdx(0xffffffff, true);
checkIdx(0x100000000, true);
// Setting length to zero should remove all index properties:
a.length = 0;
for (var key in a) {
if (!a.hasOwnProperty(key)) {
continue;
}
console.assert(String(key >>> 0) !== key || (key >>> 0) === 0xffffffff,
'Setting a.length = 0 failed to remove property ' + key);
}
// Make sure we didn't wipe everything!
console.assert(Object.getOwnPropertyNames(a).length === 4,
'Setting .length = 0 removed some non-index properties');
};
tests.arrayLengthWithNonWritableProps = function() {
var a = [];
Object.defineProperty(a, 0,
{value: 'hi', writable: false, configurable: true});
a.length = 0;
console.assert(a[0] === undefined && a.length === 0,
'arrayLengthWithNonWritableProps');
};
tests.arrayLengthWithNonConfigurableProps = function() {
var a = [];
Object.defineProperty(a, 0,
{value: 'hi', writable: false, configurable: false});
try {
a.length = 0;
console.assert(false, 'arrayLengthWithNonConfigurableProps');
} catch (e) {
console.assert(e.name === 'TypeError',
'arrayLengthWithNonConfigurableProps');
}
};
tests.compValEmptyBlock = function() {
console.assert(eval('{}') === undefined, 'compValEmptyBlock');
};
tests.unaryVoid = function() {
var x = 70;
console.assert((undefined === void x++) && x === 71, 'unaryVoid');
};
tests.unaryPlusMinus = function() {
console.assert(+'72' === 72, 'unaryPlus');
console.assert(-73 === -73, 'unaryPlus');
};
tests.unaryComplement = function() {
console.assert(~0xffffffb5 === 74, 'unaryComplement');
};
tests.unaryNot = function() {
console.assert(!false && (!true === false), 'unaryNot');
};
tests.unaryTypeof = function() {
console.assert(typeof undefined === 'undefined', 'unaryTypeofUndefined');
console.assert(typeof null === 'object', 'unaryTypeofNull');
console.assert(typeof false === 'boolean', 'unaryTypeofBoolean');
console.assert(typeof 0 === 'number', 'unaryTypeofNumber');
console.assert(typeof '' === 'string', 'unaryTypeofString');
console.assert(typeof {} === 'object', 'unaryTypeofObject');
console.assert(typeof [] === 'object', 'unaryTypeofArray');
console.assert(typeof function() {} === 'function', 'unaryTypeofFunction');
console.assert(typeof undeclaredVar === 'undefined', 'unaryTypeofUndeclared');
};
tests.binaryIn = function() {
var o = {foo: 'bar'};
console.assert('foo' in o && !('bar' in o), 'binaryIn');
};
tests.binaryInParent = function() {
var p = {foo: 'bar'};
var o = Object.create(p);
console.assert('foo' in o && !('bar' in o), 'binaryInParent');
};
tests.binaryInArrayLength = function() {
console.assert('length' in [], 'binaryInArrayLength');
};
tests.binaryInStringLength = function() {
try {
'length' in '';
console.assert(false, 'binaryInStringLength');
} catch (e) {
console.assert(e.name === 'TypeError', 'binaryInStringLengthError');
}
};
tests.instanceofBasics = function() {
function F(){}
var f = new F;
console.assert(f instanceof F, 'instanceofBasics1');
console.assert(f instanceof Object, 'instanceofBasics2');
console.assert(!(f.prototype instanceof F), 'instanceofBasics3');
};
tests.instanceofNonObjectLHS = function() {
function F() {}
F.prototype = null;
console.assert(!(42 instanceof F), 'instanceofNonObjectLHS');
};
tests.instanceofNonFunctionRHS = function() {
try {
({}) instanceof 0;
console.assert(false, 'instanceofNonFunctionRHS');
} catch (e) {
console.assert(e.name === 'TypeError', 'instanceofNonFunctionRHSError');
}
};
tests.instanceofNonObjectPrototype = function() {
function F() {};
F.prototype = 'hello';
try {
({}) instanceof F;
console.assert(false, 'instanceofNonObjectPrototype');
} catch (e) {
console.assert(e.name === 'TypeError', 'instanceofNonObjectPrototypeError');
}
};
tests.nullUndefinedProps = function() {
try {
undefined.foo;
console.assert(false, "undefined.foo didn't throw");
} catch (e) {
console.assert(e.name === 'TypeError', 'undefined.foo wrong error');
}
try {
var c = 0;
undefined.foo = c++;
console.assert(false, "undefined.foo = ... didn't throw");
} catch (e) {
console.assert(e.name === 'TypeError', 'undefined.foo = ... wrong error');
console.assert(c === 0, 'undefined.foo = ... evaluated RHS');
}
try {
null.foo;
console.assert(false, "null.foo didn't throw");
} catch (e) {
console.assert(e.name === 'TypeError', 'null.foo wrong error');
}
try {
c = 0;
null.foo = c++;
console.assert(false, "null.foo = ... didn't throw");
} catch (e) {
console.assert(e.name === 'TypeError', 'null.foo = ... wrong error');
console.assert(c === 0, 'null.foo = ... evaluated RHS');
}
};
tests.deleteProp = function() {
var o = {foo: 'bar'};
console.assert(delete o.quux, 'deleteProp1');
console.assert('foo' in o, 'deleteProp2');
console.assert(delete o.foo, 'deleteProp3');
console.assert(!('foo' in o), 'deleteProp4');
console.assert(delete o.foo, 'deleteProp5');
};
tests.deleteNonexistentFromPrimitive = function() {
console.assert(delete false.nonexistent, 'deleteNonexistentFromPrimitive');
console.assert(delete (42).toString, 'deleteInheritedFromPrimitive');
};
// This "actually" tries to delete the non-configurable own .length
// property from the auto-boxed String instance created by step 4a of
// algorithm in §11.4.1 of the ES 5.1 spec. We have to use a string
// here, because only String instances have own properties (and yes:
// they are all non-configurable, so delete *always* fails).
tests.deleteOwnFromPrimitive = function() {
try {
delete 'hello'.length;
console.assert(false, 'deleteOwnFromPrimitive');
} catch (e) {
console.assert(e.name === 'TypeError', 'deleteOwnFromPrimitive');
}
};
tests.funcDecl = function() {
var v;
function f() {
v = 75;
}
f();
console.assert(v === 75, 'funcDecl');
};
tests.namedFunctionExpression = function() {
var f = function half(x) {
if (x < 100) {
return x;
}
return half(x / 2);
};
console.assert(f(152) === 76, 'namedFunctionExpression');
f = function foo() {return foo;};
console.assert(f() === f, 'namedFunExpNameBinding');
f = function foo() {};
console.assert(typeof foo === 'undefined', 'namedFunExpBindingNoLeak');
try {
(function foo() {foo = null;})();
console.assert(false, "namedFunExpNameBindingImmutable didn't throw");
} catch (e) {
console.assert(e.name === 'TypeError',
'namedFunExpNameBindingImmutable wrong error');
}
f = function foo(foo) {
foo += 0.1; // Verify mutability.
return foo;
};
console.assert(f(76) === 76.1, 'nameFunExpNameBindingShadowedByParam');
f = function foo() {
var foo;
foo = 76.2; // Verify mutability.
return foo;
};
console.assert(f(76) === 76.2, 'nameFunExpNameBindingShadowedByVar');
};
tests.closureIndependence = function() {
function makeAdder(x) {
return function(y) { return x + y; };
}
var plus3 = makeAdder(3);
var plus4 = makeAdder(4);
console.assert(plus3(plus4(70)) === 77, 'closureIndependence');
};
tests.internalObjectToString = function() {
var o = {};
o[{}] = null;
for(var key in o) {
}
console.assert(key === '[object Object]', 'internalObjectToString');
};
tests.internalFunctionToString = function() {
var o = {}, s, f = function(){};
o[f] = null;
for(var key in o) {
s = key;
}
console.assert(/^function.*\(.*\).*{[^]*}$/.test(s), 'internalFunctionToString');
};
tests.internalNativeFuncToString = function() {
var o = {}, s, f = Object.create;
o[f] = null;
for(var key in o) {
s = key;
}
console.assert(/^function.*\(.*\).*{[^]*}$/.test(s), 'internalNativeFuncToString');
};
tests.internalArrayToString = function() {
var o = {};
o[[1, 2, 3]] = null;
for(var key in o) {
}
console.assert(key === '1,2,3', 'internalArrayToString');
};
tests.internalDateToString = function() {
var o = {};
o[new Date(0)] = null;
for(var key in o) {
}
console.assert(key === (new Date(0)).toString(), 'internalDateToString');
};
tests.internalRegExpToString = function() {
var o = {};
o[/foo/g] = null;
for(var key in o) {
}
console.assert(key === '/foo/g', 'internalRegExpToString');
};
tests.internalErrorToString = function() {
var o = {};
o[Error('oops')] = null;
for(var key in o) {
}
console.assert(key === 'Error: oops', 'internalErrorToString');
};
tests.internalArgumentsToString = function() {
var o = {};
(function() {
o[arguments] = null;
})();
for(var key in o) {
}
console.assert(key === '[object Arguments]', 'internalArgumentsToString');
};
tests.debugger = function() {
console.assert(eval('debugger') === undefined, 'debugger');
};
tests.newExpression = function() {
function T(x, y) { this.sum += x + y; };
T.prototype = { sum: 70 };
var t = new T(7, 0.7);
console.assert(t.sum === 77.7, 'newExpression');
};
tests.newExpressionReturnObj = function() {
function T() { return {}; };
T.prototype = { p: 'the prototype' };
console.assert((new T).p === undefined, 'newExpressionReturnObj');
};
tests.newExpressionReturnObj = function() {
function T() { return 0; };
T.prototype = { p: 'the prototype' };
console.assert((new T).p === 'the prototype', 'newExpressionReturnObj');
};
tests.regexpSimple = function() {
console.assert(/foo/.test('foobar'), 'regexpSimple');
};
tests.evalSeeEnclosing = function() {
var n = 77.77;
console.assert(eval('n') === 77.77, 'evalSeeEnclosing');
};
tests.evalIndirectNoSeeEnclosing = function() {
var n = 77.77, gEval = eval;
try {
gEval('n');
console.assert(false, 'evalIndirectNoSeeEnclosing');
} catch (e) {
console.assert(e.name === 'ReferenceError', 'evalIndirectNoSeeEnclosing');
}
try {
(function() { return eval; })()('n');
console.assert(false, 'evalIndirectNoSeeEnclosing2');
} catch (e) {
console.assert(e.name === 'ReferenceError', 'evalIndirectNoSeeEnclosing2');
}
};
tests.evalIndirectSeeGlobal = function() {
var gEval = eval;
console.assert(gEval('typeof Array') === 'function', 'evalIndirectSeeGlobal');
};
tests.evalModifyEnclosing = function() {
var n = 77.77;
eval('n = 77.88');
console.assert(n === 77.88, 'evalModifyEnclosing');
};
tests.evalNoLeakingDecls = function() {
eval('var n = 88.88');
console.assert(typeof n === 'undefined', 'evalNoLeakingDecls');
};
tests.evalEmptyBlock = function() {
// A bug in eval would cause it to return the value of the
// previously-evaluated ExpressionStatement if the eval program did
// not contain any ExpressionStatements.
'fail';
console.assert(eval('{}') === undefined, 'evalEmptyBlock');
};
tests.callEvalOrder = function() {
var r = "";
function log(x) {
r += x;
return function () {};
};
(log('f'))(log('a'), log('b'), log('c'));
console.assert(r === 'fabc', 'callEvalOrder');
};
tests.callEvalArgsBeforeCallability = function() {
try {
var invalid = undefined;
function t() { throw {name: 'args'}; };
invalid(t());
console.assert(false, 'callEvalArgsBeforeCallability');
} catch(e) {
console.assert(e.name === 'args', 'callEvalArgsBeforeCallability');
}
};
tests.callNonCallable = function() {
function check(v) {
try {
v();
console.assert(false, 'callNonCallable' + v);
} catch(e) {
console.assert(e.name === 'TypeError', 'callNonCallable' + v);
}
}
check(undefined);
check(null);
check(false);
check(42);
check('hello');
check(Object.create(Function.prototype));
};
///////////////////////////////////////////////////////////////////////////////
// Object and Object.prototype
tests.ObjectDefinePropertyNoArgs = function() {
try {
Object.defineProperty();
console.assert(false, "Object.defineProperty() didn't throw");
} catch (e) {
console.assert(
e.name === 'TypeError', 'Object.defineProperty() wrong error');
}
};
tests.ObjectDefinePropertyNonObject = function() {
try {
Object.defineProperty('not an object', 'foo', {});
console.assert(false, "Object.defineProperty non-object didn't throw");
} catch (e) {
console.assert(
e.name === 'TypeError', 'Object.defineProperty non-object wrong error');
}
};
tests.ObjectDefinePropertyBadDescriptor = function() {
var o = {};
try {
Object.defineProperty(o, 'foo', 'not an object');
console.assert(false, "Object.defineProperty bad descriptor didn't throw");
} catch (e) {
console.assert(e.name === 'TypeError',
'Object.defineProperty bad descriptor wrong error');
}
};
tests.ObjectDefineProperty = function() {
// This also tests iteration over (non-)enumerable properties.
var o = { foo: 70 }, r = 0;
Object.defineProperty(o, 'bar', {
writable: true,
enumerable: true,
configurable: true,
value: 8
});
Object.defineProperty(o, 'baz', {
value: 13
});
for (var k in o) {
r += o[k];
}
console.assert(r === 78, 'Object.defineProperty');
};
tests.ObjectGetPrototypeOfNullUndefined = function() {
try {
Object.getPrototypeOf(null);
console.assert(false, "Object.getPrototypeOf null didn't throw");
} catch (e) {
console.assert(
e.name === 'TypeError', 'Object.getPrototypeOf null wrong error');
}
try {
Object.getPrototypeOf(undefined);
console.assert(false, "Object.getPrototypeOf undefined didn't throw");
} catch (e) {
console.assert(
e.name === 'TypeError', 'Object.getPrototypeOf undefined wrong error');
}
};
tests.ObjectGetPrototypeOfPrimitives = function() {
// This tests for ES6 behaviour.
console.assert(Object.getPrototypeOf(true) === Boolean.prototype,
'Object.getPrototypeOf boolean');
console.assert(Object.getPrototypeOf(1337) === Number.prototype,
'Object.getPrototypeOf number');
console.assert(Object.getPrototypeOf('hi') === String.prototype,
'Object.getPrototypeOf string');
};
tests.ObjectCreateNoArgs = function() {
try {
Object.create();
console.assert(false, "Object.create() didn't throw");
} catch (e) {
console.assert(e.name === 'TypeError', 'Object.create() wrong error');
}
};
tests.ObjectCreateNonObject = function() {
try {
Object.create(42);
console.assert(false, "Object.create non-object didn't throw");
} catch (e) {
console.assert(
e.name === 'TypeError', 'Object.create non-object wrong error');
}
};
tests.ObjectCreateNull = function() {
var o = Object.create(null);
console.assert(Object.getPrototypeOf(o) === null, 'Object.create null');
};
tests.ObjectCreate = function() {
var o = Object.create({foo: 79});
delete o.foo;
console.assert(o.foo === 79, 'Object.create');
};
tests.ObjectGetOwnPropertyDescriptorNoArgs = function() {
try {
Object.getOwnPropertyDescriptor();
console.assert(false, "Object.getOwnPropertyDescriptor() didn't throw");
} catch (e) {
console.assert(e.name === 'TypeError',
'Object.getOwnPropertyDescriptor() wrong error');
}
};
tests.ObjectGetOwnPropertyDescriptorNonObject = function() {
try {
Object.getOwnPropertyDescriptor('not an object', 'foo');
console.assert(
false, "Object.getOwnPropertyDescriptor non-object didn't throw");
} catch (e) {
console.assert(e.name === 'TypeError',
'Object.getOwnPropertyDescriptor non-object wrong error');
}
};
tests.ObjectGetOwnPropertyDescriptorBadKey = function() {
var o = {};
console.assert(Object.getOwnPropertyDescriptor(o, 'foo') === undefined,
'Object.getOwnPropertyDescriptor bad key');
};
tests.ObjectGetOwnPropertyDescriptor = function() {
var o = {}, r = 0;
Object.defineProperty(o, 'foo', { value: 'bar' });
var desc = Object.getOwnPropertyDescriptor(o, 'foo');
console.assert(desc.value === o.foo, 'Object.getOwnPropertyDescriptor value');
console.assert(!desc.writable, 'Object.getOwnPropertyDescriptor writable');
console.assert(
!desc.enumerable, 'Object.getOwnPropertyDescriptor enumerable');
console.assert(
!desc.configurable, 'Object.getOwnPropertyDescriptor configurable');
};
tests.ObjectGetOwnPropertyNamesNoArgs = function() {
try {
Object.getOwnPropertyNames();
console.assert(false, "Object.getOwnPropertyNames() didn't throw");
} catch (e) {
console.assert(
e.name === 'TypeError', 'Object.getOwnPropertyNames() wrong error');
}
};
tests.ObjectGetOwnPropertyNamesString = function() {
var i, r = 0, names = Object.getOwnPropertyNames('foo');
for (i = 0; i < names.length; i++) {
if (names[i] === 'length') {
r += 10;
} else {
r += Number(names[i]) + 1;
}
}
console.assert(r === 16, 'Object.getOwnPropertyNames(string)');
};
tests.ObjectGetOwnPropertyNamesNumber = function() {
console.assert( Object.getOwnPropertyNames(42).length === 0,
'Object.getOwnPropertyNames(number)');
};
tests.ObjectGetOwnPropertyNamesBoolean = function() {
console.assert(Object.getOwnPropertyNames(true).length === 0,
'Object.getOwnPropertyNames(boolean)');
};
tests.ObjectGetOwnPropertyNamesNull = function() {
try {
Object.getOwnPropertyNames(null);
console.assert(false, "Object.getOwnPropertyNames(null) didn't throw");
} catch (e) {
console.assert(e.name === 'TypeError',
'Object.getOwnPropertyNames(null) wrong error');
}
};
tests.ObjectGetOwnPropertyNamesUndefined = function() {
try {
Object.getOwnPropertyNames(undefined);
console.assert(false, "Object.getOwnPropertyNames(undefined) didn't throw");
} catch (e) {
console.assert(e.name === 'TypeError',
'Object.getOwnPropertyNames(undefined) wrong error');
}
};
tests.ObjectGetOwnPropertyNames = function() {
var o = Object.create({baz: 999});
o.foo = 42;
Object.defineProperty(o, 'bar', { value: 38 });
var keys = Object.getOwnPropertyNames(o);
var r = 0;
for (var i = 0; i < keys.length; i++) {
r += o[keys[i]];
}
console.assert(r === 80, 'Object.getOwnPropertyNames');
};
tests.ObjectDefinePropertiesNoArgs = function() {
try {
Object.defineProperties();
console.assert(false, "Object.defineProperties() didn't throw");
} catch (e) {
console.assert(
e.name === 'TypeError', 'Object.defineProperties() wrong error');
}
};
tests.ObjectDefinePropertiesNonObject = function() {
try {
Object.defineProperties('not an object', {});
console.assert(false, "Object.defineProperties non-object didn't throw");
} catch (e) {
console.assert(e.name === 'TypeError',
'Object.defineProperties non-object wrong error');
}
};
tests.ObjectDefinePropertiesNonObjectProps = function() {
try {
Object.defineProperties({}, undefined);
console.assert(
false, "Object.defineProperties non-object props didn't throw");
} catch (e) {
console.assert(e.name === 'TypeError',
'Object.defineProperties non-object props wrong error');
}
};
tests.ObjectDefinePropertiesBadDescriptor = function() {
var o = {};
try {
Object.defineProperties(o, { foo: 'not an object' });
console.assert(
false, "Object.defineProperties bad descriptor didn't throw");
} catch (e) {
console.assert(e.name === 'TypeError',
'Object.defineProperties bad descriptor wrong error');
}
};
tests.ObjectDefineProperty = function() {
var o = { foo: 50 }, r = 0;
Object.defineProperty(o, 'bar', {
writable: true,
enumerable: true,
configurable: true,
value: 0
});
o.bar = 20;
console.assert(o.bar === 20, 'Object.defineProperty +WEC');
Object.defineProperty(o, 'baz', {
writable: true,
enumerable: true,
configurable: false
});
console.assert(o.baz === undefined, 'Object.defineProperty +WE-C 1');
Object.defineProperty(o, 'baz', {
value: 8
});
console.assert(o.baz === 8, 'Object.defineProperty +WE-C 2');
Object.defineProperty(o, 'quux', {
enumerable: false,
value: 13
});
console.assert(o.baz === 8, 'Object.defineProperty -WEC');
for (var k in o) {
r += o[k];
}
console.assert(r === 78, 'Object.defineProperty enumerability');
console.assert(Object.getOwnPropertyNames(o).length === 4,
'Object.defineProperty result .length wrong');
};
tests.ObjectCreateWithProperties = function() {
var o = Object.create({ foo: 70 }, {
bar: {
writable: true,
enumerable: true,
configurable: true,
value: 10 },
baz: { value: 999 }});
var r = 0;
for (var k in o) {
r += o[k];
}
r += Object.getOwnPropertyNames(o).length;
console.assert(r === 82, 'Object.create(..., properties)');
};
tests.ObjectPrototypeToString = function() {
console.assert(({}).toString() === '[object Object]',
'Object.prototype.toString');
};
tests.ObjectPrototypeHasOwnProperty = function() {
var o = Object.create({baz: 999});
o.foo = 42;
Object.defineProperty(o, 'bar', { value: 41, enumerable: true });
var r = 0;
for (var key in o) {
if (!o.hasOwnProperty(key)) continue;
r += o[key];
}
console.assert(r === 83, 'Object.prototype.hasOwnProperty');
};
tests.ObjectPrototypeIsPrototypeOf = function() {
var pfx = 'Object.prototype.isPrototypeOf';
console.assert(!Boolean.prototype.isPrototypeOf(false),
'Boolean.prototype.isPrototypeOf(false)');
console.assert(!Number.prototype.isPrototypeOf(0),
'Number.prototype.isPrototypeOf(0)');
console.assert(!String.prototype.isPrototypeOf(''),
"String.prototype.isPrototypeOf('')");
console.assert(!Object.prototype.isPrototypeOf.call(false, false),
pfx + '.call(false, false)');
console.assert(!Object.prototype.isPrototypeOf.call(0, 0),
pfx + '.call(0, 0)');
console.assert(!Object.prototype.isPrototypeOf.call('', ''),
pfx + ".call('', '')");
console.assert(!Object.prototype.isPrototypeOf.call(null, null),
pfx + '.call(null, null)');
console.assert(!Object.prototype.isPrototypeOf.call(undefined, undefined),
pfx + '.call(undefined, undefined)');
try {
Object.prototype.isPrototypeOf.call(null, Object.create(null));
console.assert(false, pfx + ".call(null, ...) didn't throw");
} catch (e) {
console.assert(e.name === 'TypeError',
pfx + '.call(null, ...) wrong error');
}
try {
Object.prototype.isPrototypeOf.call(undefined, Object.create(undefined));
console.assert(false, pfx + ".call(undefined, ...) didn't throw");
} catch (e) {
console.assert(e.name === 'TypeError',
pfx + '.call(undefined, ...) wrong error');
}
var g = {};
var p = Object.create(g);
var o = Object.create(p);
console.assert(!o.isPrototypeOf(o), pfx + ' self');
console.assert(!Object.prototype.isPrototypeOf(Object.create(null)),
pfx + ' unrelated');
console.assert(!o.isPrototypeOf({}), pfx + ' siblings');
console.assert(g.isPrototypeOf(o), pfx + ' grandchild');
console.assert(p.isPrototypeOf(o), pfx + ' child');
console.assert(!o.isPrototypeOf(p), pfx + ' parent');
console.assert(!o.isPrototypeOf(g), pfx + ' grandparent');
};
tests.ObjectPrototypePropertyIsEnumerable = function() {
try {
Object.prototype.propertyIsEnumerable.call(null, '');
console.assert(
false, "Object.prototype.propertyIsEnumerable(null) didn't throw");
} catch (e) {
console.assert(e.name === 'TypeError',
'Object.prototype.propertyIsEnumerable(null) wrong error');
}
try {
Object.prototype.propertyIsEnumerable.call(undefined, '');
console.assert(
false, "Object.prototype.propertyIsEnumerable(undefined) didn't throw");
} catch (e) {
console.assert(e.name === 'TypeError',
'Object.prototype.propertyIsEnumerable(undefined) wrong error');
}
var OppIE = Object.prototype.propertyIsEnumerable;
console.assert(OppIE.call('foo', '0'),
'Object.prototype.propertyIsEnumerable primitive true');
console.assert(!OppIE.call('foo', 'length'),
'Object.prototype.propertyIsEnumerable primitive false');
var o = {foo: 'foo'};
Object.defineProperty(o, 'bar', {value: 'bar', enumerable: false});
console.assert(o.propertyIsEnumerable('foo'),
'Object.prototype.propertyIsEnumerable true');
console.assert(!o.propertyIsEnumerable('bar'),
'Object.prototype.propertyIsEnumerable false 1');
console.assert(!o.propertyIsEnumerable('baz'),
'Object.prototype.propertyIsEnumerable false 2');
};
///////////////////////////////////////////////////////////////////////////////
// Function and Function.prototype
tests.FunctionConstructor = function() {
var f = new Function;
console.assert(f() === undefined, 'new Function() returns callable');
console.assert(f.length === 0, 'new Function() .length');
var actual = String(f);
var expected = 'function anonymous(\n) {\n\n}';
console.assert(actual === expected, 'new Function() .toString() ' +
'Actual: "' + actual + '" Expected: "' + expected + '"');
f = new Function('return 42;');
console.assert(f() === 42, 'new Function simple returns callable');
console.assert(f.length === 0, 'new Function simple .length');
actual = String(f);
expected = 'function anonymous(\n) {\nreturn 42;\n}';
console.assert(actual === expected, 'new Function simple .toString() ' +
'Actual: "' + actual + '" Expected: "' + expected + '"');
f = new Function('a, b', 'c', 'return a + b * c;');
console.assert(f(2, 3, 10) === 32, 'new Function with args returns callable');
console.assert(f.length === 3, 'new Function with args .length');
actual = String(f);
expected = 'function anonymous(a, b,c\n) {\nreturn a + b * c;\n}';
console.assert(actual === expected, 'new Function with args .toString() ' +
'Actual: "' + actual + '" Expected: "' + expected + '"');
};
tests.FunctionPrototypeHasNoPrototype = function() {
console.assert(Function.prototype.hasOwnProperty('prototype') === false,
'Function.prototype has no .prototype');
};
tests.FunctionPrototypeToStringApplyNonFunctionThrows = function() {
try {
Function.prototype.toString.apply({});
console.assert(
false, "Function.prototype.toString.apply non-function didn't throw");
} catch (e) {
console.assert(e.name === 'TypeError',
'Function.prototype.toString().apply non-function wrong error');
}
};
tests.FunctionPrototypeApplyNonFuncThrows = function() {
try {
var o = {};
o.apply = Function.prototype.apply;
o.apply();
console.assert(false, "Function.prototype.apply non-function didn't throw");
} catch (e) {
console.assert(e.name === 'TypeError',
'Function.prototype.apply non-function wrong error');
}
};
tests.FunctionPrototypeApplyThis = function() {
var o = {};
function f() { return this; }
console.assert(f.apply(o, []) === o, 'Function.prototype.apply this');
};
tests.FunctionPrototypeApplyArgsUndefinedOrNull = function() {
var n = 0;
function f() { n += arguments.length; }
f.apply(undefined, undefined);
f.apply(undefined, null);
console.assert(n === 0, 'Function.prototype.apply(undefined) or null');
};
tests.FunctionPrototypeApplyArgsNonObject = function() {
try {
(function() {}).apply(undefined, 'not an object');
console.assert(
false, "Function.prototype.apply(..., non-object) didn't throw");
} catch (e) {
console.assert(e.name === 'TypeError',
'Function.prototype.apply(...., non-object) wrong error');
}
};
tests.FunctionPrototypeApplyArgsSparse = function() {
var f = function(a, b, c) {
if (!(1 in arguments)) {
throw Error("Argument 1 missing");
}
return a + c;
};
console.assert(f.apply(undefined, [1, , 3]) === 4,
'Function.prototype.apply(..., sparse)');
};
tests.FunctionPrototypeApplyArgsArraylike = function() {
var n = (function(a, b, c) {
return a + b + c;
}).apply(undefined, {0: 1, 1: 2, 2: 3, length: 3});
console.assert(n === 6, 'Function.prototype.apply(..., array-like)');
};
tests.FunctionPrototypeApplyArgsNonArraylike = function() {
console.assert(isNaN((function(a, b, c) {
return a + b + c;
}).apply(undefined, {0: 1, 1: 2, 2: 4})),
'Function.prototype.apply(..., non-array-like)');
};
tests.FunctionPrototypeCallNonFuncThrows = function() {
try {
var o = {};
o.call = Function.prototype.call;
o.call();
console.assert(false, "Function.prototype.call non-func didn't throw");
} catch (e) {
console.assert(e.name === 'TypeError',
'Function.prototype.call non-func wrong error');
}
};
tests.FunctionPrototypeCallThis = function() {
var o = {};
function f() { return this; }
console.assert(f.call(o) === o, 'Function.prototype.call this');
};
tests.FunctionPrototypeCallNoArgs = function() {
function f() { return arguments.length; }
console.assert(f.call(undefined) === 0, 'Function.prototype.call no args');
};
tests.FunctionPrototypeCall = function() {
var f = function(a, b, c) {
if (!(1 in arguments)) {
throw Error("Argument 1 missing");
}
return a + c;
};
console.assert(f.call(undefined, 1, 2, 3) === 4, 'Function.prototype.call');
};
tests.FunctionPrototypeBindNonFuncThrows = function() {
try {
var o = {};
o.bind = Function.prototype.bind;
o.bind();
console.assert(false, "Function.prototype.bind non-func didn't throw");
} catch (e) {
console.assert(e.name === 'TypeError',
'Function.prototype.bind non-func wrong error');
}
};
tests.FunctionPrototypeBindThis = function() {
var o = {};
function f() { return this; }
console.assert(f.bind(o)() === o, 'Function.prototype.bind this');
};
tests.FunctionPrototypeBindNoArgs = function() {
function f() { return arguments.length; }
console.assert(f.bind(undefined)() === 0, 'Function.prototype.bind no args');
};
tests.FunctionPrototypeBind = function() {
var d = 4;
var f = function(a, b, c) {
return a + b + c + d;
};
console.assert(f.bind(undefined, 1).bind(undefined, 2)(3) === 10,
'Function.prototype.bind');
};
tests.FunctionPrototypeBindCallBF = function() {
var constructed;
function Foo() {constructed = (this instanceof Foo)}
var f = Foo.bind();
f();
console.assert(constructed === false,
'Function.prototype.bind: calling bound function calls target');
};
tests.FunctionPrototypeBindConstructBF = function() {
var constructed;
function Foo() {constructed = (this instanceof Foo)}
var f = Foo.bind();
new f;
console.assert(constructed === true,
'Function.prototype.bind: constructing bound function constructs target');
};
tests.FunctionPrototypeCallBindConstructBF = function() {
var invoked;
function Foo() {invoked = true;}
var f = Foo.call.bind(Foo);
try {
new f;
console.assert(false, "Calling bound call function didn't throw");
} catch (e) {
console.assert(e.name === 'TypeError',
'Calling bound call function threw wrong error');
}
console.assert(!invoked, 'Calling bound call function invoked call target');
};
///////////////////////////////////////////////////////////////////////////////
// Array and Array.prototype
tests.ArrayNoArgs = function() {
var a = new Array;
console.assert(Array.isArray(a), 'new Array() returns array');
console.assert(a.length === 0, '(new Array().length');
};
tests.ArrayNumericArg = function() {
var a = new Array(42);
console.assert(Array.isArray(a), 'new Array(number) returns array');
console.assert(!(0 in a), 'new Array(number) has no first item');
console.assert(!(41 in a), 'new Array(number) has no last item');
console.assert(a.length === 42, 'new Array(number).length');
};
tests.ArrayNonNumericArg = function() {
var a = new Array('foo');
console.assert(Array.isArray(a), 'new Array(non-number) returns array');
console.assert(a.length === 1, 'new Array(non-number).length');
console.assert(a[0] ==='foo', 'new Array(non-number)[0]');
};
tests.ArrayMultipleArgs = function() {
var a = new Array(1, 2, 3);
console.assert(Array.isArray(a), 'new Array(multiple...) return array');
console.assert(a.length === 3, 'new Array(multiple...).ength');
console.assert(String(a) ==='1,2,3', 'new Array(multiple...).toString()');
};
tests.ArrayIsArrayArrayPrototype = function() {
console.assert(
Array.isArray(Array.prototype), 'Array.isArray Array.prototype');
};
tests.ArrayIsArrayArrayInstance = function() {
console.assert(Array.isArray(new Array), 'Array.isArray Array instance');
};
tests.ArrayIsArrayArrayLiteral = function() {
console.assert(Array.isArray([]), 'Array.isArray Array literal');
};
tests.ArrayIsArrayArrayLike = function() {
console.assert(!Array.isArray({0: 'foo', 1: 'bar', length: 2}),
'Array.isArray(array-like)');
};
tests.ArrayPrototypeConcat = function() {
var a = ['foo', 'bar', 'baz', , 'quux', 'quuux'];
var c = a.concat();
console.assert(a.length === 6 && c.length === 6 && c !== a &&
String(c) === String(a), 'Array.prototype.concat()');
var o = {0: 'quux', 1: 'quuux', length: 2};
c = [].concat(['foo', 'bar'], 'baz', undefined, o);
console.assert(c.length === 5 && '3' in c && c[3] === undefined &&
String(c) === 'foo,bar,baz,,[object Object]',
'Array.prototype.concat(...)');
o = {0: 'foo', 1: 'bar', length: 2};
c = Array.prototype.concat.call(o, 'baz', [, 'quux', 'quuux']);
console.assert(c.length === 5 &&
String(c) === '[object Object],baz,,quux,quuux',
'Array.prototype.concat.call(object, ...)');
};
tests.ArrayPrototypeIndexOf = function() {
console.assert([1, 2, 3, 2, 1].indexOf(2) === 1, 'Array.prototype.indexOf');
console.assert([1, 2, 3, 2, 1].indexOf(4) === -1,
'Array.prototype.indexOf not found');
console.assert([1, 2, 3, 2, 1].indexOf(2, 2) === 3,
'Array.prototype.indexOf(..., +)');
console.assert([1, 2, 3, 2, 1].indexOf(1, -3) === 4,
'Array.prototype.indexOf(..., -)');
console.assert(['x', NaN, 'y'].indexOf(NaN) === -1,
'Array.prototype.indexOf NaN');
var o = {0: 1, 1: 2, 2: 3, 3: 2, 4: 1, length: 5};
console.assert(Array.prototype.indexOf.call(o, 2) === 1,
'Array.prototype.indexOf.call(array-like, ...)');
};
tests.ArrayPrototypeJoin = function() {
console.assert([1, 2, 3].join('-') === '1-2-3', 'Array.prototype.join');
};
tests.ArrayPrototypeLastIndexOf = function() {
console.assert([1, 2, 3, 2, 1].lastIndexOf(2) === 3,
'Array.prototype.lastIndexOf');
console.assert([1, 2, 3, 2, 1].lastIndexOf(4) === -1,
'Array.prototype.lastIndexOf not found');
console.assert([1, 2, 3, 2, 1].lastIndexOf(2, 2) === 1,
'Array.prototype.lastIndexOf(..., +)');
console.assert([1, 2, 3, 2, 1].lastIndexOf(1, -3) === 0,
'Array.prototype.lastIndexOf(..., -)');
var o = {0: 1, 1: 2, 2: 3, 3: 2, 4: 1, length: 5};
console.assert(Array.prototype.lastIndexOf.call(o, 2) === 3,
'Array.prototype.lastIndexOf.call(array-like, ...)');
};
tests.ArrayPrototypeJoinCycleDetection = function() {
var a = [1, , 3];
a[1] = a;
a.join('-');
// Didn't crash!
console.assert(true, 'Array.prototype.join cycle detection');
};
tests.ArrayPrototypePop = function() {
var a = ['foo', 'bar', 'baz'];
var r = a.pop();
console.assert(a.length === 2 && r === 'baz', 'Array.prototype.pop');
a = [];
r = a.pop();
console.assert(
a.length === 0 && r === undefined, 'Array.prototype.pop empty array');
var o = {0: 'foo', 1: 'bar', 2: 'baz', length: 3};
r = Array.prototype.pop.apply(o);
console.assert(
o.length === 2 && r === 'baz', 'Array.prototype.pop.apply(array-like)');
o = {length: 0};
r = Array.prototype.pop.apply(o);
console.assert(o.length === 0 && r === undefined,
'Array.prototype.pop.apply(empty array-like)');
o = {5000000000000000: 'foo',
5000000000000001: 'quux',
length: 5000000000000002};
r = Array.prototype.pop.apply(o);
console.assert(o.length === 5000000000000001 && o[5000000000000000] === 'foo',
'Array.prototype.pop.apply(huge array-like)');
};
tests.ArrayPrototypePush = function() {
var a = [];
console.assert(a.push('foo') === 1 && a.push('bar') === 2 &&
a.length === 2 && a[0] === 'foo' && a[1] === 'bar',
'Array.prototype.push');
var o = {length: 0};
console.assert(Array.prototype.push.call(o, 'foo') === 1 &&
Array.prototype.push.call(o, 'bar') === 2 &&
o.length === 2 && o[0] === 'foo' && o[1] === 'bar',
'Array.prototype.push.call(array-like, ...)');
var o = {length: 5000000000000000};
console.assert(Array.prototype.push.call(o, 'foo') === 5000000000000001 &&
Array.prototype.push.call(o, 'bar') === 5000000000000002 &&
o[5000000000000000] === 'foo' && o[5000000000000001] === 'bar' &&
o.length === 5000000000000002,
'Array.prototype.push.call(huge array-like, ...)');
};
tests.ArrayPrototypeReverse = function () {
var a = [1, 2, 3];
console.assert(a.reverse() === a && a.length === 3 && String(a) === '3,2,1',
'Array.prototype.reverse odd-length');
a = [1, 2, , 4];
console.assert(a.reverse() === a && a.length === 4 && String(a) === '4,,2,1',
'Array.prototype.reverse even-length');
a = [];
console.assert(a.reverse() === a && a.length === 0,
'Array.prototype.reverse empty');
var o = {0: 1, 1: 2, 2: 3, length: 3};
console.assert(Array.prototype.reverse.call(o) === o &&
o.length === 3 && Array.prototype.slice.apply(o).toString() === '3,2,1',
'Array.prototype.reverse.call(odd-length array-like)');
o = {0: 1, 1: 2, 3: 4, length: 4};
console.assert(Array.prototype.reverse.call(o) === o &&
o.length === 4 && Array.prototype.slice.apply(o).toString() === '4,,2,1',
'Array.prototype.reverse.call(even-length array-like)');
o = {length: 0};
console.assert(Array.prototype.reverse.call(o) === o && o.length === 0,
'Array.prototype.reverse.call(empty array-like)');
};
tests.ArrayPrototypeShift = function() {
var a = ['foo', 'bar', 'baz'];
var r = a.shift();
console.assert(a.length === 2 && a[0] === 'bar' && a[1] === 'baz' &&
r === 'foo', 'Array.prototype.shift');
a = [];
r = a.shift();
console.assert(
a.length === 0 && r === undefined, 'Array.prototype.shift empty array');
var o = {0: 'foo', 1: 'bar', 2: 'baz', length: 3};
r = Array.prototype.shift.apply(o);
console.assert(o.length === 2 && o[0] === 'bar' && o[1] === 'baz' &&
r === 'foo', 'Array.prototype.shift.apply(array-like)');
o = {length: 0};
r = Array.prototype.shift.apply(o);
console.assert(o.length === 0 && r === undefined,
'Array.prototype.shift.apply(empty array-like)');
// SKIP until more efficient shift implementation available.
console.log('SKIP:\tArray.prototype.shift.apply(huge array-like)');
// o = {5000000000000000: 'foo',
// 5000000000000001: 'quux',
// length: 5000000000000002};
// r = Array.prototype.shift.apply(o);
// console.assert(o.length === 5000000000000001 && o[5000000000000000] === 'quux',
// 'Array.prototype.shift.apply(huge array-like)');
};
tests.ArrayPrototypeSlice = function() {
var a = ['foo', 'bar', 'baz', , 'quux', 'quuux'];
var s = a.slice();
console.assert(a.length === 6 && s.length === 6 && String(s) === String(a),
'Array.prototype.slice()');
s = a.slice(-2);
console.assert(a.length === 6 && s.length === 2 && String(s) === 'quux,quuux',
'Array.prototype.slice(-)');
s = a.slice(1, 4);
console.assert(a.length === 6 && s.length === 3 && !('2' in s) &&
String(s) === 'bar,baz,', 'Array.prototype.slice(+, +)');
s = a.slice(1, -2);
console.assert(a.length === 6 && s.length === 3 && !('2' in s) &&
String(s) === 'bar,baz,', 'Array.prototype.slice(+, +)');
var o = {0: 'foo', 1: 'bar', 2: 'baz', 4: 'quux', 5: 'quuux', length: 6};
s = Array.prototype.slice.call(o, 1, -2);
console.assert(o.length === 6 && s.length === 3 && !('2' in s) &&
String(s) === 'bar,baz,', 'Array.prototype.slice.call(array-like, -, +)');
o = {
5000000000000000: 'foo', 5000000000000001: 'bar',
5000000000000002: 'baz', 5000000000000004: 'quux',
5000000000000005: 'quuux', length: 5000000000000006
};
s = Array.prototype.slice.call(o, -5, -2);
console.assert(o.length === 5000000000000006 &&
s.length === 3 && !('2' in s) && String(s) === 'bar,baz,',
'Array.prototype.slice.call(huge array-like, -, -)');
};
tests.ArrayPrototypeSort = function() {
console.assert([5, 2, 3, 1, 4].sort().join() === '1,2,3,4,5',
'Array.prototype.sort()');
// TODO(cpcallen):
console.assert(['z', undefined, 10, , 'aa', null, 'a', 5, NaN, , 1].sort()
.map(String).join() === '1,10,5,NaN,a,aa,null,z,undefined,,',
'Array.prototype.sort() compaction');
console.assert([99, 9, 10, 11, 1, 0, 5].sort(function(a, b) {return a - b;})
.join() === '0,1,5,9,10,11,99',
'Array.prototype.sort(comparefn)');
// TODO(cpcallen):
console.assert(['z', undefined, 10, , 'aa', null, 'a', 5, NaN, , 1].sort(
function(a, b) {
// Try to put undefineds first - should not succeed.
if (a === undefined) return b === undefined ? 0 : -1;
if (b === undefined) return 1;
// Reverse order of ususal sort.
a = String(a);
b = String(b);
if (a > b) return -1;
if (b > a) return 1;
return 0;
}).map(String).join() === 'z,null,aa,a,NaN,5,10,1,undefined,,',
'Array.prototype.sort(comparefn) compaction');
};
tests.ArrayPrototypeSplice = function() {
var a = ['foo', 'bar', 'baz', , 'quux', 'quuux'];
var s = a.splice();
console.assert(a.length === 6 && String(a) === 'foo,bar,baz,,quux,quuux' &&
s.length === 0 && String(s) === '', 'Array.prototype.splice()');
a = ['foo', 'bar', 'baz', , 'quux', 'quuux'];
s = a.splice(-2);
console.assert(a.length === 4 && String(a) === 'foo,bar,baz,' &&
s.length === 2 && String(s) === 'quux,quuux',
'Array.prototype.splice(-)');
a = ['foo', 'bar', 'baz', , 'quux', 'quuux'];
s = a.splice(1, 3, 'bletch');
console.assert(a.length === 4 && String(a) === 'foo,bletch,quux,quuux' &&
s.length === 3 && String(s) === 'bar,baz,',
'Array.prototype.splice(+, +, ...)');
var o = {0: 'foo', 1: 'bar', 2: 'baz', 4: 'quux', 5: 'quuux', length: 6};
s = Array.prototype.splice.call(o, 0, 100, 'bletch');
console.assert(!Array.isArray(o) && o.length === 1 &&
Object.keys(o).length === 2 && o[0] === 'bletch' &&
s.length === 6 && !('3' in s) && String(s) === 'foo,bar,baz,,quux,quuux',
'Array.prototype.splice.call(array-like, 0, large, ...)');
o = {
5000000000000000: 'foo', 5000000000000001: 'bar',
5000000000000002: 'baz', 5000000000000004: 'quux',
5000000000000005: 'quuux', length: 5000000000000006
};
s = Array.prototype.splice.call(o, -2, -999, 'bletch', 'qux');
console.assert(!Array.isArray(o) && o.length === 5000000000000008 &&
o[5000000000000004] === 'bletch' && o[5000000000000005] === 'qux' &&
o[5000000000000006] === 'quux' && o[5000000000000007] === 'quuux' &&
Array.isArray(s) && s.length === 0,
'Array.prototype.splice.call(huge array-like, -, -)');
};
tests.ArrayPrototypeToStringCycleDetection = function() {
var a = [1, , 3];
a[1] = a;
a.toString();
// Didn't crash!
console.assert(true, 'Array.prototype.toString cycle detection');
};
tests.ArrayPrototypeUnshift = function() {
var a = [];
console.assert(a.unshift('foo') === 1 && a.unshift('bar') === 2 &&
a.length === 2 && a[0] === 'bar' && a[1] === 'foo',
'Array.prototype.unshift');
var o = {length: 0};
console.assert(Array.prototype.unshift.call(o, 'foo') === 1 &&
Array.prototype.unshift.call(o, 'bar') === 2 &&
o.length === 2 && o[0] === 'bar' && o[1] === 'foo',
'Array.prototype.unshift.call(array-like, ...)');
// SKIP until more efficient unshift implementation available.
console.log('SKIP:\tArray.prototype.unshift.apply(huge array-like, ...)');
// var o = {length: 5000000000000000};
// console.assert(Array.prototype.unshift.call(o, 'foo') === 5000000000000001 &&
// Array.prototype.unshift.call(o, 'bar') === 5000000000000002 &&
// o[5000000000000000] === 'foo' && o[5000000000000001] === 'bar' &&
// o.length === 5000000000000002,
// 'Array.prototype.unshift.call(huge array-like, ...)');
};
tests.ArrayLegalIndexLength = function() {
var cases = [
// [value, asIndex, asLength]
[false, 0, 0],
[true, 0, 1],
[0, 1, 0],
[1, 2, 1],
[0xfffffffe, 0xffffffff, 0xfffffffe],
[0xffffffff, 0, 0xffffffff],
[0x100000000, 0, NaN],
[4.5, 0, NaN],
[-1, 0, NaN],
['0', 1, 0],
['1', 2, 1],
['0xfffffffe', 0, 0xfffffffe],
['0xffffffff', 0, 0xffffffff],
['0x100000000', 0, NaN],
['4294967294', 4294967295, 0xfffffffe],
['4294967295', 0, 0xffffffff],
['4294967296', 0, NaN],
['4.5', 0, NaN],
['-1', 0, NaN],
['hello', 0, NaN],
[null, 0, 0], // wat
[undefined, 0, NaN],
[[], 0, 0], // wat!
[{}, 0, NaN],
];
for (var i = 0, tc; (tc = cases[i]); i++) {
var a = [];
a[tc[0]] = true;
console.assert(a.length === tc[1],
'Array legal index ' + JSON.stringify(tc[0]));
var a = [];
try {
a.length = tc[0];
if (isNaN(tc[2])) {
console.assert(false,
"Array illegal .length didn't throw " + JSON.stringify(tc[0]));
}
} catch (e) {
console.assert(e.name === 'RangeError',
'Array illegal .length wrong error ' + JSON.stringify(tc[0]));
}
}
};
///////////////////////////////////////////////////////////////////////////////
// Boolean and Boolean.prototype
tests.Boolean = function() {
console.assert(Boolean(undefined) === false, 'Boolean undefined');
console.assert(Boolean(null) === false, 'Boolean null');
console.assert(Boolean(false) === false, 'Boolean false');
console.assert(Boolean(true) === true, 'Boolean true');
console.assert(Boolean(NaN) === false, 'Boolean NaN');
console.assert(Boolean(0) === false, 'Boolean 0');
console.assert(Boolean(1) === true, 'Boolean 1');
console.assert(Boolean('') === false, 'Boolean empty string');
console.assert(Boolean('foo') === true, 'Boolean non-empty string');
console.assert(Boolean({}) === true, 'Boolean object');
console.assert(Boolean([]) === true, 'Boolean array');
console.assert(Boolean(function() {}) === true, 'Boolean function');
};
tests.BooleanPrototypeToString = function () {
console.assert(Boolean.prototype.toString() === 'false',
'Boolean.prototype.toString()');
console.assert(Boolean.prototype.toString.call(true) === 'true',
'Boolean.prototype.toString.call(true)');
console.assert(Boolean.prototype.toString.call(false) === 'false',
'Boolean.prototype.toString.call(false)');
try {
Boolean.prototype.toString.call({});
console.assert(false, "Boolean.prototype.toString.call({}) didn't throw");
} catch (e) {
console.assert(e.name === 'TypeError',
'Boolean.prototype.toString.call({}) wrong error');
}
};
tests.BooleanPrototypeValueOf = function () {
console.assert(Boolean.prototype.valueOf() === false,
'Boolean.prototype.valueOf()');
console.assert(Boolean.prototype.valueOf.call(true) === true,
'Boolean.prototype.valueOf.call(true)');
console.assert(Boolean.prototype.valueOf.call(false) === false,
'Boolean.prototype.valueOf.call(false)');
try {
Boolean.prototype.valueOf.call({});
console.assert(false, "Boolean.prototype.valueOf.call({}) didn't throw");
} catch (e) {
console.assert(e.name === 'TypeError',
'Boolean.prototype.valueOf.call({}) wrong error');
}
};
///////////////////////////////////////////////////////////////////////////////
// Number and Number.prototype
tests.Number = function() {
console.assert(Number() === 0, 'Number()');
console.assert(isNaN(Number(undefined)), 'Number undefined');
console.assert(Number(null) === 0, 'Number null');
console.assert(Number(true) === 1, 'Number true');
console.assert(Number(false) === 0, 'Number false');
console.assert(Number('42') === 42, "Number '42'");
console.assert(isNaN(Number('Hello')), 'Number non-empty string');
console.assert(Number('') === 0, 'Number empty string');
console.assert(Number(3.1) === 3.1, 'Number number');
console.assert(isNaN(Number({})), 'Number object');
console.assert(Number([]) === 0, 'Number []');
console.assert(Number([42]) === 42, 'Number [42]');
console.assert(isNaN(Number([1,2,3])), 'Number [1,2,3]');
console.assert(isNaN(Number(function() {})), 'Number function');
console.assert(isNaN(Number.NaN), 'Number NaN');
console.assert(!isFinite(Number.POSITIVE_INFINITY), 'Number +Infinity');
console.assert(!isFinite(Number.NEGATIVE_INFINITY), 'Number -Infinity');
console.assert(Number.POSITIVE_INFINITY === -Number.NEGATIVE_INFINITY,
'Number infinities');
};
tests.NumberPrototypeToString = function () {
console.assert(Number.prototype.toString() === '0',
'Number.prototype.toString()');
console.assert(Number.prototype.toString.call(84) === '84',
'Number.prototype.toString.call(85)');
try {
Number.prototype.toString.call({});
console.assert(false, "Number.prototype.toString.call({}) didn't throw");
} catch (e) {
console.assert(e.name === 'TypeError',
'Number.prototype.toString.call({}) wrong error');
}
};
// Run some tests of Number.toString(radix) with various different
// radix arguments.
tests.NumberPrototypeToStringRadix = function() {
var cases = [
[42, , '42'],
[42, 16, '2a'],
// Old versions of Node incorrectly reports '-132.144444'.
[-42.4, 5, '-132.2'],
[42, '2', '101010'],
[-3.14, , '-3.14'],
[999999999999999999999999999, undefined, '1e+27'],
[NaN, undefined, 'NaN'],
[Infinity, , 'Infinity'],
[-Infinity, , '-Infinity'],
];
for (var i = 0, tc; (tc = cases[i]); i++) {
console.assert(Number.prototype.toString.call(tc[0], tc[1]) === tc[2],
'Number.prototype.toString.call(' + tc[0] + ', ' + tc[1] + ')');
}
};
tests.NumberPrototypeValueOf = function () {
console.assert(Number.prototype.valueOf() === 0,
'Number.prototype.valueOf()');
console.assert(Number.prototype.valueOf.call(85) === 85,
'Number.prototype.valueOf.call(85)');
try {
Number.prototype.valueOf.call({});
console.assert(false, "Number.prototype.valueOf.call({}) didn't throw");
} catch (e) {
console.assert(e.name === 'TypeError',
'Number.prototype.valueOf.call({}) wrong error');
}
};
///////////////////////////////////////////////////////////////////////////////
// String and String.prototype
tests.String = function() {
console.assert(String() === '', 'String()');
console.assert(String(undefined) === 'undefined', 'String undefined');
console.assert(String(null) === 'null', 'String null');
console.assert(String(true) === 'true', 'String true');
console.assert(String(false) === 'false', 'String false');
console.assert(String(0) === '0', 'String 0');
console.assert(String(-0) === '0', 'String -0');
console.assert(String(Infinity) === 'Infinity', 'String +Infinity');
console.assert(String(-Infinity) === '-Infinity', 'String -Infinity');
console.assert(String(NaN) === 'NaN', 'String NaN');
console.assert(String({}) === '[object Object]', 'String object');
console.assert(String([1, 2, 3,,5]) === '1,2,3,,5', 'String array');
};
tests.StringPrototypeLength = function() {
console.assert(String.prototype.length === 0, 'String.prototype.length');
};
tests.StringPrototypeReplaceStringString = function() {
console.assert('xxxx'.replace('xx', 'y') === 'yxx',
'String.prototype.replace(string, string)');
};
tests.StringPrototypeReplaceRegExpString = function() {
console.assert('xxxx'.replace(/(X)\1/ig, 'y') === 'yy',
'String.prototype.replace(regexp, string)');
};
tests.StringPrototypeReplaceStringFunction = function() {
var str = 'xxxx'.replace('xx', function () {
return '[' + Array.prototype.join.apply(arguments) + ']';
});
console.assert(str === '[xx,0,xxxx]xx',
'String.prototype.replace(string, function)');
};
tests.StringPrototypeReplaceRegExpFunction = function() {
var str = 'xxxx'.replace(/(X)\1/ig, function () {
return '[' + Array.prototype.join.apply(arguments) + ']';
});
console.assert(str === '[xx,x,0,xxxx][xx,x,2,xxxx]',
'String.prototype.replace(regexp, function)');
};
tests.StringPrototypeSearch = function() {
console.assert('hello'.search('H') === -1,
'String.prototype.search(string) not found');
console.assert('hello'.search('ll') === 2,
'String.prototype.search(string) found');
console.assert('hello'.search(/H/) === -1,
'String.prototype.search(regexp) not found');
console.assert('hello'.search(/(.)\1/) === 2,
'String.prototype.search(regexp) found');
};
tests.StringPrototypeToString = function () {
console.assert(String.prototype.toString() === '',
'String.prototype.toString()');
console.assert(String.prototype.toString.call('a string') === 'a string',
"String.prototype.toString.call('a string')");
try {
String.prototype.toString.call({});
console.assert(false, "String.prototype.toString.call({}) didn't throw");
} catch (e) {
console.assert(e.name === 'TypeError',
'String.prototype.toString.call({}) wrong error');
}
};
tests.StringPrototypeValueOf = function () {
console.assert(String.prototype.valueOf() === '',
'String.prototype.valueOf()');
console.assert(String.prototype.valueOf.call('a string') === 'a string',
"String.prototype.valueOf.call('a string')");
try {
String.prototype.valueOf.call({});
console.assert(false, "String.prototype.valueOf.call({}) didn't throw");
} catch (e) {
console.assert(e.name === 'TypeError',
'String.prototype.valueOf.call({}) wrong error');
}
};
///////////////////////////////////////////////////////////////////////////////
// RegExp
tests.RegExpPrototypeTestApplyNonRegExpThrows = function() {
try {
/foo/.test.apply({}, ['foo']);
console.assert(
false, "RegExp.prototype.test.apply(non-regexp) didn't throw");
} catch (e) {
console.assert(e.name === 'TypeError',
'RegExp.prototype.test.apply(non-regexp) wrong error');
}
};
///////////////////////////////////////////////////////////////////////////////
// JSON
tests.JsonStringify = function () {
var obj = {string: 'foo', number: 42, true: true, false: false, null: null,
object: { obj: {}, arr: [] }, array: [{}, []] };
var str = '{"string":"foo","number":42,"true":true,"false":false,' +
'"null":null,"object":{"obj":{},"arr":[]},"array":[{},[]]}';
console.assert(JSON.stringify(obj) === str, 'JSON.stringify basic');
console.assert(JSON.stringify(function(){}) === undefined,
'JSON.stringify(function(){})');
console.assert(JSON.stringify([function(){}]) === '[null]',
'JSON.stringify([function(){}])');
console.assert(JSON.stringify({f: function(){}}) === '{}',
'JSON.stringify({f: function(){}})');
str = '{"string":"foo","number":42}';
console.assert(JSON.stringify(obj, ['string', 'number']) === str,
'JSON.stringify filter');
str = '{\n "string": "foo",\n "number": 42\n}';
console.assert(JSON.stringify(obj, ['string', 'number'], 2) === str,
'JSON.stringify pretty number');
str = '{\n--"string": "foo",\n--"number": 42\n}';
console.assert(JSON.stringify(obj, ['string', 'number'], '--') === str,
'JSON.stringify pretty string');
obj = {e: 'enumerable', ne: 'nonenumerable'};
Object.defineProperty(obj, 'ne', {enumerable: false});
console.assert(JSON.stringify(obj) === '{"e":"enumerable"}',
'JSON.stringify nonenumerable');
console.assert(JSON.stringify(Object.create({foo: 'bar'})) === '{}',
'JSON.stringify inherited');
obj = {};
obj.circular = obj;
try {
JSON.stringify(obj);
console.assert(false, "JSON.stringify didn't throw");
} catch (e) {
console.assert(e.name === 'TypeError', 'JSON.stringify wrong error');
}
};
///////////////////////////////////////////////////////////////////////////////
// Other built-in functions
tests.decodeUriThrows = function() {
try {
decodeURI('%xy');
console.assert(false, "decodeURI(invalid-URI) didn't throw");
} catch (e) {
console.assert(e.name === 'URIError', 'decodeURI(invalid-URI) wrong error');
}
};
///////////////////////////////////////////////////////////////////////////////
// Other tests
tests.newHack = function() {
console.assert(
(new 'Array.prototype.push') === Array.prototype.push, 'new hack');
};
tests.newHackUnknown = function() {
try {
new 'nonexistent-builtin-name';
console.assert(false, "new hack with unknown built-in didn't throw");
} catch (e) {
console.assert(e.name === 'ReferenceError',
'new hack with unknown built-in wrong error');
}
};
tests.newHacknNonLiteral = function() {
try {
var builtin = 'Object.prototype';
new builtin;
console.assert(false, "new hack with non-literal didn't throw");
} catch (e) {
console.assert(e.name === 'TypeError',
'new hack with non-literal wrong error');
}
};
tests.es6CausesSyntaxErrors = function() {
var tests = [
// Class statements & expressions
'class Foo{};',
'false && class Foo{};',
// Arrow functions.
'false && [].map((item) => String(item));',
// For-of statement.
'for (var x of [1, 2, 3]) {};',
// Let & const.
'let x;',
'const x;',
];
for (var i = 0; i < tests.length; i++) {
var src = tests[i];
try {
eval(tests[i]);
console.assert(false, "es5 didn't throw for: " + src);
} catch (e) {
console.assert(e.name === 'SyntaxError',
'es5 threw wrong error for: ' + src);
}
}
};
tests.strictModeSyntaxErrors = function() {
var tests = [
// With statement.
'var o = { foo: 42 }; var f = function() { with (o) { foo; }};',
// Binding eval in global scope, or arguments in a function.
'var eval = "rebinding eval?!?";',
'(function() { arguments = undefined; });',
// Duplicate argument names.
'(function(a, a) {});',
// Octal numeric literals.
'0777;',
// Delete of unqualified or undeclared identifier.
'var foo; delete foo;',
'delete foo;',
];
for (var i = 0; i < tests.length; i++) {
var src = tests[i];
try {
eval(tests[i]);
console.assert(false, "strict mode didn't throw for: " + src);
} catch (e) {
console.assert(e.name === 'SyntaxError',
'strict mode wrong error for: ' + src);
}
}
};
================================================
FILE: server/tests/db/test_01_es6.js
================================================
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Test the ES6 functions of the server.
* @author fraser@google.com (Neil Fraser)
*/
// Test automatic setting of function .name properties.
tests.functionNameSetting = function() {
var myAssignedFunc;
myAssignedFunc = function() {};
console.assert(myAssignedFunc.name === 'myAssignedFunc',
'Assignment expression sets anonymous function name');
var o = {myPropFunc: function() {}};
console.assert(o.myPropFunc.name === 'myPropFunc',
'Object expression sets anonymous function name');
var myVarDeclFunc = function() {};
console.assert(myVarDeclFunc.name === 'myVarDeclFunc',
'Variable declaration sets anonymous function name');
};
// Run some tests of the various constructors and their associated
// literals and prototype objects.
tests.builtinClassesES6 = function() {
var classes = [
{
constructor: WeakMap,
classStr: '[object WeakMap]',
prototypeClass: '[object Object]',
functionNotConstructor: true // WeakMap() can't be called without new.
},
];
for (var i = 0, tc; (tc = classes[i]); i++) {
var c = tc.constructor;
var prototypeType = (tc.prototypeType || 'object');
// Check constructor is a function:
console.assert(typeof c === 'function', c + ' isFunction');
// Check constructor's proto is Function.prototype
console.assert(Object.getPrototypeOf(c) === Function.prototype,
c + ' protoIsFunctionPrototype');
// Check prototype is of correct type:
console.assert(typeof c.prototype === prototypeType,
c + ' prototypeIs');
// Check prototype has correct class:
console.assert(
Object.prototype.toString.apply(c.prototype) ===
tc.prototypeClass || tc.classStr,
c + ' prototypeClassIs');
// Check prototype has correct proto:
console.assert(
Object.getPrototypeOf(c.prototype) ===
(tc.prototypeProto === undefined ? Object.prototype : tc.prototypeProto),
c + ' prototypeProtoIs');
// Check prototype's .constructor is constructor:
console.assert(c.prototype.constructor === c,
c + ' prototypeConstructorIs');
if (!tc.noInstance) {
// Check instance's type:
console.assert(typeof new c === prototypeType, c + ' instanceIs');
// Check instance's proto:
console.assert(Object.getPrototypeOf(new c) === c.prototype,
c + ' instancePrototypeIs');
// Check instance's class:
console.assert(Object.prototype.toString.apply(new c) === tc.classStr,
c + ' instanceClassIs');
// Check instance is instanceof its contructor:
console.assert((new c) instanceof c, c + ' instanceIsInstanceof');
if (!tc.functionNotConstructor) {
// Recheck instances when constructor called as function:
// Recheck instance's type:
console.assert(typeof c() === prototypeType, c + ' returnIs');
// Recheck instance's proto:
console.assert(Object.getPrototypeOf(c()) === c.prototype,
c + ' returnPrototypeIs');
// Recheck instance's class:
console.assert(Object.prototype.toString.apply(c()) === tc.classStr,
c + ' returnClassIs');
// Recheck instance is instanceof its contructor:
console.assert(c() instanceof c, c + ' returnIsInstanceof');
}
}
// No need to check literals.
}
};
///////////////////////////////////////////////////////////////////////////////
// Object and Object.prototype
tests.ObjectSetPrototypeOfNullUndefined = function() {
try {
Object.setPrototypeOf(null, null);
console.assert(false, "Object.setPrototypeOf(null, ...) didn't throw");
} catch (e) {
console.assert(e.name === 'TypeError',
'Object.setPrototypeOf(null, ...) wrong error');
}
try {
Object.setPrototypeOf(undefined, null);
console.assert(false, "Object.setPrototypeOf(undefined, ...) didn't throw");
} catch (e) {
console.assert(e.name === 'TypeError',
'Object.setPrototypeOf(undefined, ...) wrong error');
}
};
tests.ObjectSetPrototypeOfPrimitives = function() {
console.assert(Object.setPrototypeOf(true, null) === true,
'Object.setPrototypeOf boolean');
console.assert(Object.setPrototypeOf(1337, null) === 1337,
'Object.setPrototypeOf number');
console.assert(Object.setPrototypeOf('hi', null) === 'hi',
'Object.setPrototypeOf string');
};
tests.ObjectSetPrototypeOf = function() {
var o = {parent: 'o'};
var p = {parent: 'p'};
var q = Object.create(o);
console.assert(Object.setPrototypeOf(q, p) === q,
'Object.setPrototypeOf(q, p) return value');
console.assert(Object.getPrototypeOf(q) === p,
'Object.setPrototypeOf(q, p) new parent');
console.assert(q.parent === 'p',
'Object.setPrototypeOf(q, p) inheritance');
};
tests.ObjectSetPrototypeOfToNull = function() {
var o = {parent: 'o'};
var q = Object.create(o);
console.assert(Object.setPrototypeOf(q, null) === q,
'Object.setPrototypeOf(q, null) return value');
console.assert(Object.getPrototypeOf(q) === null,
'Object.setPrototypeOf(q, null) new parent');
};
tests.ObjectSetPrototypeOfCircular = function() {
var o = {};
var p = Object.create(o);
try {
Object.setPrototypeOf(o, p);
console.assert(false, "Object.setPrototypeOf(o, p) didn't throw");
} catch (e) {
console.assert(e.name === 'TypeError',
'Object.setPrototypeOf(o, p) wrong error');
}
};
tests.ObjectIs = function() {
console.assert(Object.is('foo', 'foo'), 'equal strings');
console.assert(Object.is(Array, Array), 'equal objects');
console.assert(!Object.is('foo', 'bar'), 'unequal strings');
console.assert(!Object.is([], []), 'unequal objects');
var test = {a: 1};
console.assert(Object.is(test, test), 'custom object');
console.assert(Object.is(null, null), 'null');
console.assert(!Object.is(0, -0), 'unequal zero');
console.assert(Object.is(-0, -0), 'negative zero');
console.assert(Object.is(NaN, 0/0), 'NaN');
};
///////////////////////////////////////////////////////////////////////////////
// Function and Function.prototype
tests.FunctionPrototypeBindClassConstructor = function() {
var f = WeakMap.bind();
try {
f();
console.assert(false, "Calling bound class constructor didn't throw");
} catch (e) {
console.assert(e.name === 'TypeError',
'Calling bound class constructor threw wrong error');
}
}
tests.FunctionPrototypeBindClassConstructorNew = function() {
console.assert(String(new (WeakMap.bind())) === '[object WeakMap]',
'FunctionPrototypeBindClassConstructorNew');
};
///////////////////////////////////////////////////////////////////////////////
// Array and Array.prototype
tests.ArrayFind = function() {
var inventory = [
{name: 'apples', quantity: 2},
{name: 'bananas', quantity: 0},
{name: 'cherries', quantity: 5}
];
function isCherries(fruit) {
return fruit.name === 'cherries';
}
console.assert([].find(isCherries) === undefined, 'Array.find 0');
console.assert(inventory.find(isCherries) === inventory[2], 'Array.find 1');
};
tests.ArrayFindIndex = function() {
var inventory = [
{name: 'apples', quantity: 2},
{name: 'bananas', quantity: 0},
{name: 'cherries', quantity: 5}
];
function isCherries(fruit) {
return fruit.name === 'cherries';
}
console.assert([].findIndex(isCherries) === -1, 'Array.findIndex 0');
console.assert(inventory.findIndex(isCherries) === 2, 'Array.findIndex 1');
};
///////////////////////////////////////////////////////////////////////////////
// String and String.prototype
tests.StringBooleanSearchFunctions = function() {
var str = 'To be, or not to be, that is the question.';
console.assert(str.includes('To be'), 'Includes "To be"');
console.assert(str.includes('question'), 'Includes "question"');
console.assert(!str.includes('nonexistent'), 'Includes "nonexistent"');
console.assert(!str.includes('To be', 1), 'Includes "To be" (1)');
console.assert(!str.includes('TO BE'), 'Includes "TO BE"');
console.assert(str.startsWith('To be'), 'StartsWith "To be"');
console.assert(!str.startsWith('not to be'), 'StartsWith "not to be"');
console.assert(str.startsWith('not to be', 10), 'StartsWith "not to be" (10)');
console.assert(str.endsWith('question.'), 'EndsWith "question."');
console.assert(!str.endsWith('to be'), 'EndsWith "to be"');
console.assert(str.endsWith('to be', 19), 'EndsWith "to be" (19)');
};
tests.StringRepeat = function() {
try {
'abc'.repeat(-1);
console.assert(false, 'Repeat Negative');
} catch (e) {
console.assert(e.name === 'RangeError',
'Repeat Negative Error');
}
console.assert('abc'.repeat(0) === '', 'Repeat 0');
console.assert('abc'.repeat(1) === 'abc', 'Repeat 1');
console.assert('abc'.repeat(2) === 'abcabc', 'Repeat 2');
console.assert('abc'.repeat(3.5) === 'abcabcabc', 'Repeat 3.5');
try {
'abc'.repeat(1 / 0);
console.assert(false, 'RegExpPrototypeTestApplyNonRegExpThrows');
} catch (e) {
console.assert(e.name === 'RangeError',
'RegExpPrototypeTestApplyNonRegExpThrowsError');
}
};
///////////////////////////////////////////////////////////////////////////////
// Number
tests.NumberEpsilon = function() {
console.assert(Number.EPSILON > 0, 'Epsilon > zero');
console.assert(Number.EPSILON < 0.001, 'Epsilon < 0.001');
};
tests.NumberIsFinite = function() {
console.assert(!Number.isFinite(Infinity), 'Number.isFinite Infinity');
console.assert(!Number.isFinite(NaN), 'Number.isFinite NaN');
console.assert(!Number.isFinite(-Infinity), 'Number.isFinite -Infinity');
console.assert(Number.isFinite(0), 'Number.isFinite 0');
console.assert(Number.isFinite(2e64), 'Number.isFinite 2e64');
console.assert(!Number.isFinite('0'), 'Number.isFinite "0"');
console.assert(!Number.isFinite(null), 'Number.isFinite null');
};
tests.NumberIsNaN = function() {
console.assert(Number.isNaN(NaN), 'Number.isNaN NaN');
console.assert(Number.isNaN(Number.NaN), 'Number.isNaN Number.NaN');
console.assert(Number.isNaN(0 / 0), 'Number.isNaN 0 / 0');
console.assert(!Number.isNaN('NaN'), 'Number.isNaN "NaN"');
console.assert(!Number.isNaN(undefined), 'Number.isNaN undefined');
console.assert(!Number.isNaN({}), 'Number.isNaN {}');
console.assert(!Number.isNaN('blabla'), 'Number.isNaN "blabla"');
console.assert(!Number.isNaN(true), 'Number.isNaN true');
console.assert(!Number.isNaN(null), 'Number.isNaN null');
console.assert(!Number.isNaN(37), 'Number.isNaN 37');
console.assert(!Number.isNaN('37'), 'Number.isNaN "37"');
console.assert(!Number.isNaN('37.37'), 'Number.isNaN "37.37"');
console.assert(!Number.isNaN(''), 'Number.isNaN ""');
console.assert(!Number.isNaN(' '), 'Number.isNaN " "');
};
tests.NumberIsInteger = function() {
console.assert(Number.isInteger(-17), 'Number.isInteger -17');
console.assert(Number.isInteger(Math.pow(2, 64)), 'Number.isInteger 2**64');
console.assert(Number.isInteger(-Math.pow(2, 64)), 'Number.isInteger -2**64');
console.assert(!Number.isInteger(NaN), 'Number.isInteger NaN');
console.assert(!Number.isInteger(Infinity), 'Number.isInteger Infinity');
console.assert(!Number.isInteger('3'), 'Number.isInteger "3"');
console.assert(!Number.isInteger(3.1), 'Number.isInteger 3.1');
console.assert(Number.isInteger(3.0), 'Number.isInteger 3.0');
};
tests.NumberIsSafeInteger = function() {
console.assert(Number.isSafeInteger(3), 'Number.isSafeInteger 3');
console.assert(!Number.isSafeInteger(Math.pow(2, 53)), 'Number.isSafeInteger 2**53');
console.assert(Number.isSafeInteger(Math.pow(2, 53) - 1), 'Number.isSafeInteger 2**53-1');
console.assert(!Number.isSafeInteger(NaN), 'Number.isSafeInteger NaN');
console.assert(!Number.isSafeInteger(Infinity), 'Number.isSafeInteger Infinity');
console.assert(!Number.isSafeInteger('3'), 'Number.isSafeInteger "3"');
console.assert(!Number.isSafeInteger(3.1), 'Number.isSafeInteger 3.1');
console.assert(Number.isSafeInteger(3.0), 'Number.isSafeInteger 3.0');
};
tests.NumberMaxSafeInteger = function() {
console.assert(Number.MAX_SAFE_INTEGER + 1 === Math.pow(2, 53),
'Number.MAX_SAFE_INTEGER');
console.assert(Number.isSafeInteger(Number.MAX_SAFE_INTEGER),
'Number.isSafeInteger(Number.MAX_SAFE_INTEGER);');
console.assert(!Number.isSafeInteger(Number.MAX_SAFE_INTEGER + 1),
'Number.isSafeInteger(Number.MAX_SAFE_INTEGER + 1);');
};
tests.NumberMinSafeInteger = function() {
console.assert(Number.MIN_SAFE_INTEGER === -(Math.pow(2, 53) - 1),
'Number.MIN_SAFE_INTEGER');
console.assert(Number.isSafeInteger(Number.MIN_SAFE_INTEGER),
'Number.isSafeInteger(Number.MIN_SAFE_INTEGER);');
console.assert(!Number.isSafeInteger(Number.MIN_SAFE_INTEGER - 1),
'Number.isSafeInteger(Number.MIN_SAFE_INTEGER - 1);');
};
///////////////////////////////////////////////////////////////////////////////
// Math
tests.MathAcosh = function() {
console.assert(Number.isNaN(Math.acosh(-1)), 'Math.acosh -1');
console.assert(Number.isNaN(Math.acosh(0)), 'Math.acosh 0');
console.assert(Number.isNaN(Math.acosh(0.5)), 'Math.acosh 0.5');
console.assert(Math.acosh(1) === 0, 'Math.acosh 1');
console.assert(Math.acosh(2).toPrecision(10) === '1.316957897', 'Math.acosh 2');
};
tests.MathAsinh = function() {
console.assert(Math.asinh(1).toPrecision(10) === '0.8813735870', 'Math.asinh 1');
console.assert(Math.asinh(0) === 0, 'Math.asinh 0');
};
tests.MathAtanh = function() {
console.assert(Number.isNaN(Math.atanh(-2)), 'Math.atanh -2');
console.assert(Math.atanh(-1) === -Infinity, 'Math.atanh -1');
console.assert(Math.atanh(0) === 0, 'Math.atanh 0');
console.assert(Math.atanh(0.5).toPrecision(10) === '0.5493061443', 'Math.atanh 0.5');
console.assert(Math.atanh(1) === Infinity, 'Math.atanh 1');
console.assert(Number.isNaN(Math.atanh(2)), 'Math.atanh 2');
};
tests.MathCbrt = function() {
console.assert(Number.isNaN(Math.cbrt(NaN)), 'Math.cbrt NaN');
console.assert(Math.cbrt(-1) === -1, 'Math.cbrt -1');
console.assert(Object.is(Math.cbrt(-0), -0), 'Math.cbrt -0');
console.assert(Math.cbrt(-Infinity) === -Infinity, 'Math.cbrt -Infinity');
console.assert(Object.is(Math.cbrt(0), 0), 'Math.cbrt 0');
console.assert(Math.cbrt(1) === 1, 'Math.cbrt 1');
console.assert(Math.cbrt(Infinity) === Infinity, 'Math.cbrt Infinity');
console.assert(Math.cbrt(null) === 0, 'Math.cbrt null');
console.assert(Math.cbrt(2).toPrecision(10) === '1.259921050', 'Math.cbrt 2');
};
tests.MathClz32 = function() {
console.assert(Math.clz32(1) === 31, 'Math.clz32 1');
console.assert(Math.clz32(1000) === 22, 'Math.clz32 1000');
console.assert(Math.clz32() === 32, 'Math.clz32 ()');
console.assert(Math.clz32(NaN) === 32, 'Math.clz32 NaN');
console.assert(Math.clz32(Infinity) === 32, 'Math.clz32 Infinity');
console.assert(Math.clz32(-Infinity) === 32, 'Math.clz32 -Infinity');
console.assert(Math.clz32(0) === 32, 'Math.clz32 0');
console.assert(Math.clz32(-0) === 32, 'Math.clz32 -0');
console.assert(Math.clz32(null) === 32, 'Math.clz32 null');
console.assert(Math.clz32(undefined) === 32, 'Math.clz32 undefined');
console.assert(Math.clz32('foo') === 32, 'Math.clz32 "foo"');
console.assert(Math.clz32({}) === 32, 'Math.clz32 {}');
console.assert(Math.clz32([]) === 32, 'Math.clz32 []');
console.assert(Math.clz32(true) === 31, 'Math.clz32 true');
console.assert(Math.clz32(3.5) === 30, 'Math.clz32 3.5');
};
tests.MathCosh = function() {
console.assert(Math.cosh(-1).toPrecision(10) === '1.543080635', 'Math.cosh -1');
console.assert(Math.cosh(0) === 1, 'Math.cosh 0');
console.assert(Math.cosh(1).toPrecision(10) === '1.543080635', 'Math.cosh 1');
};
tests.MathExpm1 = function() {
console.assert(Math.expm1(-1).toPrecision(10) === '-0.6321205588', 'Math.expm1 -1');
console.assert(Math.expm1(0) === 0, 'Math.expm1 0');
console.assert(Math.expm1(1).toPrecision(10) === '1.718281828', 'Math.expm1 1');
};
tests.MathFround = function() {
console.assert(Math.fround(1.5) === 1.5, 'Math.fround 1.5');
console.assert(Math.fround(1.337).toPrecision(10) === '1.337000012', 'Math.fround 1.337');
console.assert(Math.fround(Math.pow(2, 150)) === Infinity, 'Math.fround 2**150');
console.assert(Number.isNaN(Math.fround('abc')), 'Math.fround "abc"');
console.assert(Number.isNaN(Math.fround(NaN)), 'Math.fround NaN');
};
tests.MathHypot = function() {
console.assert(Math.hypot(3, 4) === 5, 'Math.hypot 3, 4');
console.assert(Math.hypot(3, 4, 5).toPrecision(10) === '7.071067812', 'Math.hypot 3, 4, 5');
console.assert(Math.hypot() === 0, 'Math.hypot ()');
console.assert(Number.isNaN(Math.hypot(NaN)), 'Math.hypot NaN');
console.assert(Number.isNaN(Math.hypot(3, 4, 'foo')), 'Math.hypot 3, 4, "foo"');
console.assert(Math.hypot(3, 4, '5').toPrecision(10) === '7.071067812', 'Math.hypot 3, 4, "5"');
console.assert(Math.hypot(-3) === 3, 'Math.hypot -3');
};
tests.MathImul = function() {
console.assert(Math.imul(2, 4) === 8, 'Math.imul 2, 4');
console.assert(Math.imul(-1, 8) === -8, 'Math.imul -1, 8');
console.assert(Math.imul(-2, -2) === 4, 'Math.imul -2, -2');
console.assert(Math.imul(0xffffffff, 5) === -5, 'Math.imul 0xffffffff, 5');
console.assert(Math.imul(0xfffffffe, 5) === -10, 'Math.imul 0xfffffffe, 5');
};
tests.MathLog10 = function() {
console.assert(Math.log10(2).toPrecision(10) === '0.3010299957', 'Math.log10 2');
console.assert(Math.log10(1) === 0, 'Math.log10 1');
console.assert(Math.log10(0) === -Infinity, 'Math.log10 0');
console.assert(Number.isNaN(Math.log10(-2)), 'Math.log10 -2');
console.assert(Math.log10(100000) === 5, 'Math.log10 100000');
};
tests.MathLog1p = function() {
console.assert(Math.log1p(1).toPrecision(10) === '0.6931471806', 'Math.log1p 1');
console.assert(Math.log1p(0) === 0, 'Math.log1p 0');
console.assert(Math.log1p(-1) === -Infinity, 'Math.log1p -1');
console.assert(Number.isNaN(Math.log1p(-2)), 'Math.log1p -2');
};
tests.MathLog2 = function() {
console.assert(Math.log2(3).toPrecision(10) === '1.584962501', 'Math.log2 3');
console.assert(Math.log2(2) === 1, 'Math.log2 2');
console.assert(Math.log2(1) === 0, 'Math.log2 1');
console.assert(Math.log2(0) === -Infinity, 'Math.log2 0');
console.assert(Number.isNaN(Math.log2(-2)), 'Math.log2 -2');
console.assert(Math.log2(1024) === 10, 'Math.log2 1024');
};
tests.MathSign = function() {
console.assert(Math.sign(3) === 1, 'Math.sign 3');
console.assert(Math.sign(-3) === -1, 'Math.sign -3');
console.assert(Math.sign('-3') === -1, 'Math.sign "-3"');
console.assert(Object.is(Math.sign(0), 0), 'Math.sign 0');
console.assert(Object.is(Math.sign(-0), -0), 'Math.sign -0');
console.assert(Number.isNaN(Math.sign(NaN)), 'Math.sign NaN');
console.assert(Number.isNaN(Math.sign('foo')), 'Math.sign "foo"');
console.assert(Number.isNaN(Math.sign()), 'Math.sign undefined');
};
tests.MathSinh = function() {
console.assert(Math.sinh(0) === 0, 'Math.sinh 0');
console.assert(Math.sinh(1).toPrecision(10) === '1.175201194', 'Math.sinh 1');
};
tests.MathTanh = function() {
console.assert(Math.tanh(0) === 0, 'Math.tanh 0');
console.assert(Math.tanh(Infinity) === 1, 'Math.tanh Infinity');
console.assert(Math.tanh(1).toPrecision(10) === '0.7615941560', 'Math.tanh 1');
};
tests.MathTrunc = function() {
console.assert(Math.trunc(13.37) === 13, 'Math.trunc 13.37');
console.assert(Math.trunc(42.84) === 42, 'Math.trunc 42.84');
console.assert(Object.is(Math.trunc(0.123), 0), 'Math.trunc 0.123');
console.assert(Object.is(Math.trunc(-0.123), -0), 'Math.trunc -0.123');
console.assert(Math.trunc('-1.123') === -1, 'Math.trunc "-1.123"');
console.assert(Number.isNaN(Math.trunc(NaN)), 'Math.trunc NaN');
console.assert(Number.isNaN(Math.trunc('foo')), 'Math.trunc "foo"');
console.assert(Number.isNaN(Math.trunc()), 'Math.trunc undefined');
};
///////////////////////////////////////////////////////////////////////////////
// WeakMap and WeakMap.prototype
tests.WeakMap = function() {
var w = new WeakMap;
var p = {};
var o = Object.create(p);
console.assert(!w.has(p), 'WeakMapPrototypeHasNonKey');
console.assert(!w.delete(p), 'WeakMapPrototypeDeleteNonKey');
console.assert(w.set(o, 'o') === w, 'WeakMapPrototypeSet');
console.assert(w.get(o) === 'o', 'WeakMapPrototypeGet');
console.assert(w.get(p) === undefined, 'WeakMapPrototypeGetNonKey');
console.assert(w.has(o), 'WeakMapPrototypeHas');
console.assert(w.delete(o), 'WeakMapPrototypeDelete');
console.assert(!w.has(o), 'WeakMapPrototypeHasNonKey');
};
tests.WeakMapPrototypeMethodsRejectInvalid = function() {
var w = new WeakMap;
var name = 'WeakMapPrototypeMethodsReject';
function expectError(method, thisVal, args) {
var label = String(thisVal === w ? args : 'ThisIs' + args);
try {
w[method].apply(thisVal, args);
console.assert(false, name + label);
} catch (e) {
console.assert(e.name === 'TypeError', name + label + 'Error');
}
}
var methods = ['delete', 'get', 'has', 'set'];
var values = [null, undefined, true, false, 0, 42, '', 'hi'];
for (var i = 0; i < methods.length; i++) {
var method = methods[i];
for (var j = 0; j < values.length; j++) {
var value = values[j];
expectError(method, value, [{}]);
expectError(method, w, [value]);
}
expectError(method, WeakMap.prototpye, [{}]); // Ordinary object.
}
};
================================================
FILE: server/tests/db/test_01_es7.js
================================================
/**
* @license
* Copyright 2018 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Test the ES7 functions of the server.
* @author fraser@google.com (Neil Fraser)
*/
///////////////////////////////////////////////////////////////////////////////
// Array and Array.prototype
tests.ArrayPrototypeIncludes = function() {
console.assert([1, 2, 3, 2, 1].includes(2), 'Array.prototype.includes');
console.assert(![1, 2, 3, 2, 1].includes(4),
'Array.prototype.includes not found');
console.assert([1, 2, 3, 2, 1].includes(2, 2),
'Array.prototype.includes(..., +)');
console.assert([1, 2, 3, 2, 1].includes(1, -3),
'Array.prototype.includes(..., -)');
console.assert(['x', NaN, 'y'].includes(NaN),
'Array.prototype.includes NaN');
var o = {0: 1, 1: 2, 2: 3, 3: 2, 4: 1, length: 5};
console.assert(Array.prototype.includes.call(o, 2),
'Array.prototype.includes.call(array-like, ...)');
};
================================================
FILE: server/tests/db/test_02_errors.js
================================================
/**
* @license
* Copyright 2018 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Test language extensions related to errors.
* @author cpcallen@google.com (Christopher Allen)
*/
tests.errorStack = function() {
// Use eval to make parsing .stack easier.
var e = eval('new Error;');
var lines = e.stack.split('\n');
console.assert(lines[0].trim() === 'at "new Error;" 1:1',
'new Error has .stack');
try {
(function buggy() {1 instanceof 2;})();
console.assert(false, "thrown Error wasn't thrown??");
} catch (e) {
lines = e.stack.split('\n');
console.assert(lines[0].trim() === 'at buggy 1:19',
'thrown Error has .stack');
}
// Bug #241.
function foo() {
switch (1) {
case 1:
return undefined.hasNoProperties;
}
}
try {
foo();
console.assert(false, "Invalid MemberExpression didn't throw??");
} catch (e) {
lines = e.stack.split('\n');
console.assert(lines[0].trim() === 'at foo 4:16',
'Invalid MemberExpression escaped blame');
}
function bar() {
return undefinedVariable;
}
try {
bar();
console.assert(false, "Invalid Identifier didn't throw??");
} catch (e) {
lines = e.stack.split('\n');
console.assert(lines[0].trim() === 'at bar 2:12',
'Invalid Identifier escaped blame');
}
};
================================================
FILE: server/tests/db/test_02_perms.js
================================================
/**
* @license
* Copyright 2018 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Test the permissions system.
* @author cpcallen@google.com (Christopher Allen)
*/
tests.perms = function() {
console.assert(perms() === CC.root, 'perms() returns root');
};
tests.setPerms = function() {
var bob = {};
console.assert(perms() === CC.root, 'before setPerms()');
(function() {
setPerms(bob);
console.assert(perms() === bob, 'after setPerms()');
// Perms revert at end of scope.
})();
console.assert(perms() === CC.root, 'after scope end');
};
tests.getOwnerOf = function() {
var bob = {};
var roots = {};
setPerms(bob);
var bobs = {};
console.assert(Object.getOwnerOf(Object) === CC.root, 'getOwenerOfObject');
console.assert(Object.getOwnerOf(roots) === CC.root, 'getOwnerOfNew');
console.assert(Object.getOwnerOf(bobs) === bob, 'getOwnerOfBobs');
};
tests.setOwnerOf = function() {
var bob = {};
var obj = {};
console.assert(Object.setOwnerOf(obj, bob) === obj, 'setOwneerOf return');
console.assert(Object.getOwnerOf(obj) === bob, 'setOwenerOf effect');
};
================================================
FILE: server/tests/db/test_09_end.js
================================================
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Run the unit tests.
* @author fraser@google.com (Neil Fraser)
*/
$.system.log('Starting tests');
for (var name in tests) {
var oldBad = console.badCount;
try {
tests[name]();
} catch (e) {
console.assert(false, 'CRASH: ' + name + '\n' + e);
}
if (oldBad < console.badCount) {
$.system.log(String(tests[name]));
}
}
$.system.log('');
$.system.log('Completed tests');
$.system.log('Pass: %d', console.goodCount);
$.system.log('Fail: %d', console.badCount);
================================================
FILE: server/tests/db/test_10_fibonacci.js
================================================
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Run a performance stress test.
* @author fraser@google.com (Neil Fraser)
*/
// Define function as global so that it can be run again
// after checkpoint and restart.
function test_fibonacci10k() {
for (var run = 1; run <= 3; run++) {
var start = Date.now();
var fibonacci = function(n, output) {
var a = 1, b = 1, sum;
for (var i = 0; i < n; i++) {
output.push(a);
sum = a + b;
a = b;
b = sum;
}
}
for(var i = 0; i < 10000; i++) {
var result = [];
fibonacci(78, result);
}
result;
var ms = Date.now() - start;
$.system.log('Run #%d fibonacci10k: %d ms', run, ms);
}
}
$.system.log('Benchmarking fibonacci10k...');
test_fibonacci10k();
================================================
FILE: server/tests/db/test_20_reboot.js
================================================
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Reboot the server, and verify restart.
* @author fraser@google.com (Neil Fraser)
*/
$.system.shutdown();
$.system.log('Benchmarking resurrected fibonacci10k...');
test_fibonacci10k();
$.system.shutdown();
================================================
FILE: server/tests/dump_test.js
================================================
/**
* @license
* Copyright 2018 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Tests for Saving the state of the interpreter as
* eval-able JS.
* @author cpcallen@google.com (Christopher Allen)
*/
'use strict';
const {configFromSpec, Do, dump} = require('../dump');
const fs = require('fs');
const Interpreter = require('../interpreter');
const path = require('path');
const Selector = require('../selector');
const {T} = require('./testing');
const util = require('util');
/**
* Unit tests for the dump function
* @param {!T} t The test runner object.
*/
exports.testConfigFromSpec = function(t) {
const cases = [{
input: [],
expected: [],
}, {
input: [
{filename: 'foo',
header: ['// F1 BIOS', '// Copyright YEAR Foonly inc.', 'LINES'],
headerSubs: {YEAR: '1978', LINES: ['// 1', '// 2']},
contents: ['a', 'b']}],
expected: [
{filename: 'foo',
header: '// F1 BIOS\n// Copyright YEAR Foonly inc.\nLINES',
headerSubs: {YEAR: '1978', LINES: '// 1\n// 2'},
prune: [],
pruneRest: [],
contents: [
{selector: new Selector('a'), do: Do.RECURSE, reorder: false},
{selector: new Selector('b'), do: Do.RECURSE, reorder: false}
],
rest: false
}],
}, {
input: [{filename: 'foo', prune: ['a', 'b'], rest: true}],
expected: [
{filename: 'foo', header: undefined, headerSubs: {},
prune: [new Selector('a'), new Selector('b')],
pruneRest: [],
contents: [], rest: true
}],
}, {
input: [{filename: 'foo', pruneRest: ['c', 'd'], rest: true}],
expected: [
{filename: 'foo', header: undefined, headerSubs: {},
prune: [],
pruneRest: [new Selector('c'), new Selector('d')],
contents: [], rest: true
}],
}, {
input: [{options: {}}, {options: {treeOnly: false}}],
expected: [{options: {}}, {options: {treeOnly: false}}],
}];
for (const {input, expected} of cases) {
const out = configFromSpec(input);
t.expect(util.format('configFromSpec(%o)', input),
util.format('%o', out),
util.format('%o', expected));
}
const invalid = [
undefined, // Not an array.
'a string', // Not an array.
{object: 'not array'}, // Not an array.
['array', 'of', 'strings'], // Array but not of objects.
[{}], // Neither SpecFileItem nor SpecOptionsItem.
[{filename: 'foo'}], // Missing both .contents and .rest.
[{filename: 'foo', contents: [], rest: 'bar'}], // .rest not bool.
[{filename: 'foo', contents: [42]}], // .contents[0] not object or string.
[{filename: 'foo', contents: ['foo[']}], // .contents[0] invalid selector.
[{filename: 'foo', contents: [{}]}], // ... has no .path.
[{filename: 'foo', contents: [{path: 'bar'}]}], // ... has no .do.
[{filename: 'foo', contents: [{path: 'bar', do: 2}]}], // ... invalid .do.
[{filename: 'foo', contents: [{path: 'bar', do: 'baz'}]}], // Ditto.
[{filename: 'foo', // .reorder not a boolean.
contents: [{path: 'bar', do: 'SET', reorder: 'qux'}]}],
[{filename: 'foo', rest: 42}], // .rest not a boolean.
[{filename: 'foo', rest: 'false'}], // .rest not a boolean.
[{filename: 'foo', prune: 'x', rest: true}], // .prune not an array.
[{filename: 'foo', prune: ['foo['], rest: true}], // .prune[0] invalid.
[{filename: 'foo', pruneRest: 'x', rest: true}], // .prune not an array.
[{filename: 'foo', pruneRest: ['foo['], rest: true}], // .prune[0] invalid.
[{options: 'not an object'}], // .options is not an object.
];
for (const input of invalid) {
const name = util.format('configFromSpec(%o)', input);
try {
configFromSpec(input);
t.fail(util.format("%O didn't throw", input));
} catch (e) {
if (!(e instanceof TypeError || e instanceof SyntaxError)) {
t.fail(util.format('%O threw wrong error', input), e);
}
}
}
};
/**
* Unit tests for the dump function
* @param {!T} t The test runner object.
*/
exports.testDump = function(t) {
const intrp = new Interpreter({noLog: ['net']});
// Load tinycore.
const coreDir = 'tests/tinycore';
for (const file of fs.readdirSync(coreDir) || []) {
if (file.match(/^(core|test).*\.js$/)) {
const filename = path.join(coreDir, file);
intrp.createThreadForSrc(String(fs.readFileSync(filename, 'utf8')));
intrp.run();
}
}
intrp.stop(); // Close any listening sockets, so node will exit.
const specText = fs.readFileSync(path.join(coreDir, 'dump_spec.json'));
const spec = JSON.parse(String(specText));
var config = configFromSpec(spec);
dump(new Interpreter(), intrp, config, '/tmp');
};
================================================
FILE: server/tests/dumper_test.js
================================================
/**
* @license
* Copyright 2018 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Tests for Saving the state of the interpreter as
* eval-able JS.
* @author cpcallen@google.com (Christopher Allen)
*/
'use strict';
const {Dumper, Do, testOnly, Writable} = require('../dumper');
const {getInterpreter} = require('./interpreter_common');
const Interpreter = require('../interpreter');
const path = require('path');
const Selector = require('../selector');
const {T} = require('./testing');
const util = require('util');
// Unpack test-only exports.
const {Components, ObjectDumper, ScopeDumper} = testOnly;
/**
* A mock Writable, for testing.
* @implements {Writable}
*/
class MockWritable {
constructor() {
/** @const {!Array} */
this.output = [];
}
/** @override */
write(chunk) {
this.output.push(String(chunk));
}
/** @return {string} */
toString() {
return this.output.join('');
}
}
/**
* Tests for the ObjectDumper.prototype.isWritable method.
* @suppress {accessControls}
*/
exports.testObjectDumperPrototypeIsWritable = function(t) {
const intrp = getInterpreter();
// Create some objects and properties:
// - .foo writable on child but not Object.prototype.
// - .bar writable on child but not parent.
// - .baz writable on child and parent.
intrp.createThreadForSrc(`
Object.prototype.foo = undefined; // Cheeky!
Object.defineProperty(Object.prototype, 'foo', {writable: false});
var parent = {bar: undefined, baz: undefined};
Object.defineProperty(parent, 'bar', {writable: false});
var child = {foo: undefined, bar: undefined, baz: undefined};
Object.setPrototypeOf(child, parent);
`);
intrp.run();
const pristine = new Interpreter();
const dumper = new Dumper(pristine, intrp);
dumper.dumpBinding(new Selector('Object'), Do.SET);
dumper.dumpBinding(new Selector('Object.prototype'), Do.SET);
const objectPrototypeDumper = dumper.getObjectDumper_(intrp.OBJECT);
const parentDumper = dumper.getDumperFor('parent');
const childDumper = dumper.getDumperFor('child');
// Fake dumping of parent and child as if created by object
// literals. (.dumpBinding would use Object.create, pre-setting
// their prototypes - we don't want that for this test.)
parentDumper.proto = intrp.OBJECT;
parentDumper.ref = new Components(dumper.global, 'parent');
childDumper.proto = intrp.OBJECT;
childDumper.ref = new Components(dumper.global, 'child');
// Now dump various bindings in a certain order, and check
// writability of child.foo, .bar and .baz in each situation.
objectPrototypeDumper.dumpBinding(dumper, 'foo', Do.SET);
parentDumper.dumpBinding(dumper, Selector.PROTOTYPE, Do.SET);
parentDumper.dumpBinding(dumper, 'bar', Do.SET);
childDumper.dumpBinding(dumper, Selector.PROTOTYPE, Do.DECL);
t.expect("childDumper.isWritable('foo') // 0",
childDumper.isWritable(dumper, 'foo'), true);
t.expect("childDumper.isWritable('bar') // 0",
childDumper.isWritable(dumper, 'bar'), true);
t.expect("childDumper.isWritable('baz') // 0",
childDumper.isWritable(dumper, 'baz'), true);
objectPrototypeDumper.dumpBinding(dumper, 'foo', Do.ATTR);
parentDumper.dumpBinding(dumper, 'bar', Do.ATTR);
t.expect("childDumper.isWritable('foo') // 1",
childDumper.isWritable(dumper, 'foo'), false);
t.expect("childDumper.isWritable('bar') // 1",
childDumper.isWritable(dumper, 'bar'), true);
t.expect("childDumper.isWritable('baz') // 1",
childDumper.isWritable(dumper, 'baz'), true);
childDumper.dumpBinding(dumper, Selector.PROTOTYPE, Do.SET);
t.expect("childDumper.isWritable('foo') // 2",
childDumper.isWritable(dumper, 'foo'), false);
t.expect("childDumper.isWritable('bar') // 2",
childDumper.isWritable(dumper, 'bar'), false);
t.expect("childDumper.isWritable('baz') // 2",
childDumper.isWritable(dumper, 'baz'), true);
childDumper.dumpBinding(dumper, 'foo', Do.DECL);
childDumper.dumpBinding(dumper, 'bar', Do.DECL);
childDumper.dumpBinding(dumper, 'baz', Do.DECL);
t.expect("childDumper.isWritable('foo') // 3",
childDumper.isWritable(dumper, 'foo'), true);
t.expect("childDumper.isWritable('bar') // 3",
childDumper.isWritable(dumper, 'bar'), true);
t.expect("childDumper.isWritable('baz') // 3",
childDumper.isWritable(dumper, 'baz'), true);
};
/**
* Tests for the ObjectDumper.prototype.updateRef method.
* @suppress {accessControls}
*/
exports.testObjectDumperUpdateRef = function(t) {
const intrp = new Interpreter();
// ScopeDumper for global scope and ObjectDumpers for some arbitrary objects.
const globalDumper = new ScopeDumper(intrp.global);
const fooDumper = new ObjectDumper(new intrp.Object());
const barDumper = new ObjectDumper(new intrp.Object());
const reachableDumper = new ObjectDumper(new intrp.Object());
const unreachableDumper = new ObjectDumper(new intrp.Object());
// Stub Dumper.
const /** !Dumper */ dumper = /** @type {?} */({
intrp2: intrp,
scope: intrp.global,
});
// Scenario 0: Reject self references.
fooDumper.updateRef(dumper, new Components(fooDumper, ''));
t.expect('fooDumper.updateRef(); fooDumper.ref',
fooDumper.ref, null);
// Scenario 1: Typical cases during dumping. We've dumped foo and
// are dumping foo.bar, which might also have (not preferred)
// references from reachable and unreachable objects or the global
// scope.
fooDumper.preferredRef = new Components(globalDumper, 'foo');
fooDumper.ref = fooDumper.preferredRef; // Reachable.
barDumper.preferredRef = new Components(fooDumper, 'bar'); // foo.bar
barDumper.ref = null; // Not yet reachable.
reachableDumper.preferredRef = new Components(globalDumper, 'reachable');
reachableDumper.ref = reachableDumper.preferredRef; // Reachable.
unreachableDumper.preferredRef = new Components(globalDumper, 'unreachable');
unreachableDumper.ref = null; // Not yet reachable.
// Test all N*N combinations of possible (existing, proposed) refs
// for bar. Cases are in order increrasing preferability: earlier
// ones should be replace by later but not vice-versa.
const cases = [
null, // No known reference yet.
// Refs from an unreachable object are better than nothing.
new Components(unreachableDumper, Selector.PROTOTYPE),
new Components(unreachableDumper, '#hash'),
new Components(unreachableDumper, '42'),
new Components(unreachableDumper, 'aaaaaaaaaa'),
new Components(unreachableDumper, 'bar'),
// Refs from reachable objects are better - but other than
// foo.bar, these two objects are equally good so order just comes
// down to selector badness.
new Components(reachableDumper, Selector.PROTOTYPE),
new Components(fooDumper, Selector.PROTOTYPE),
new Components(reachableDumper, '#hash'),
new Components(fooDumper, '#hash'),
new Components(reachableDumper, '42'),
new Components(fooDumper, '42'),
new Components(reachableDumper, 'aaaaaaaaaa'),
new Components(fooDumper, 'aaaaaaaaaa'),
new Components(reachableDumper, 'bar'),
new Components(reachableDumper, 'b'),
new Components(fooDumper, 'b'),
// Refs from a scope are generally better.
new Components(globalDumper, 'aaaaaaaaaa'),
new Components(globalDumper, 'bar'),
new Components(globalDumper, 'b'),
// The preferred reference is best of all.
new Components(fooDumper, 'bar'),
];
for (var i = 0; i < cases.length; i++) {
for (var j = 1; j < cases.length; j++) { // Don't call updateRef with null.
if (!reachableDumper.ref) throw new Error();
const before = cases[i];
const suggested = cases[j];
const expected = cases[Math.max(i, j)];
const name = util.format('updateRef %o to %o?', before, suggested);
const message =
util.format(['barDumper.ref = %s;',
'barDumper.updateRef(%s);',
'barDumper.ref;'].map(s => ' ' + s).join('\n'),
before, suggested);
barDumper.ref = before;
barDumper.updateRef(dumper, suggested);
t.expect(name, barDumper.ref, expected, message);
}
}
// TODO(cpcallen): Scenario 2: unreachable refs (e.g. due to scoping).
};
/**
* Unit tests for the Dumper.prototype.isShadowed_ method.
* @param {!T} t The test runner object.
* @suppress {accessControls}
*/
exports.testDumperPrototypeIsShadowed_ = function(t) {
const intrp = new Interpreter();
const pristine = new Interpreter();
const dumper = new Dumper(pristine, intrp);
intrp.global.createMutableBinding('foo', 'foo');
intrp.global.createMutableBinding('bar', 'bar');
const inner = new Interpreter.Scope(Interpreter.Scope.Type.FUNCTION,
intrp.ROOT, intrp.global);
inner.createMutableBinding('foo', 'foobar!');
dumper.scope = inner;
t.expect("isShadowed_('foo')", dumper.isShadowed_('foo'), true);
t.expect("isShadowed_('bar')", dumper.isShadowed_('bar'), false);
};
/**
* Unit tests for the Dumper.prototype.exprForPrimitive_ method.
* @param {!T} t The test runner object.
* @suppress {accessControls}
*/
exports.testDumperPrototypeExprForPrimitive_ = function(t) {
const intrp = new Interpreter();
const pristine = new Interpreter();
const dumper = new Dumper(pristine, intrp);
function doCases(cases) {
for (const tc of cases) {
const r = dumper.exprForPrimitive_(tc[0]);
t.expect(util.format('dumper.exprForPrimitive_(%o)', tc[0]), r, tc[1]);
t.expect(util.format('eval(dumper.exprForPrimitive_(%o))', tc[0]),
eval(r), tc[0]);
}
}
doCases([
[undefined, 'undefined'],
[null, 'null'],
[false, 'false'],
[true, 'true'],
[0, '0'],
[-0, '-0'],
[Infinity, 'Infinity'],
[-Infinity, '-Infinity'],
[NaN, 'NaN'],
['foo', "'foo'"],
]);
// Shadow some names and check results are still correct.
const inner = new Interpreter.Scope(Interpreter.Scope.Type.FUNCTION,
intrp.ROOT, intrp.global);
inner.createMutableBinding('Infinity', '42');
inner.createMutableBinding('NaN', '42');
inner.createMutableBinding('undefined', '42');
dumper.scope = inner;
doCases([
[undefined, '(void 0)'],
[Infinity, '(1/0)'],
[-Infinity, '(-1/0)'],
[NaN, '(0/0)'],
]);
};
/**
* Tests for the Dumper.prototype.exprFor_ method.
* @param {!T} t The test runner object.
* @suppress {accessControls}
*/
exports.testDumperPrototypeExprFor_ = function(t) {
// Create an Interperter with a UserFunction to dump.
const intrp = new Interpreter();
intrp.createThreadForSrc('function foo(bar) {}');
intrp.run();
const func = /** @type {!Interpreter.prototype.UserFunction} */ (
intrp.global.get('foo'));
const pristine = new Interpreter();
const dumper = new Dumper(pristine, intrp);
// Give references to needed builtins.
for (const b of [
'Date', 'Error', 'EvalError', 'RangeError', 'ReferenceError', 'TypeError',
'SyntaxError', 'URIError', 'PermissionError', 'WeakMap',
]) {
dumper.getObjectDumper_(/** @type {!Interpreter.prototype.Object} */
(intrp.builtins.get(b))).ref = new Components(dumper.global, b);
}
// Give foo a reference too, even though it has not been created yet.
dumper.getObjectDumper_(func).ref = new Components(dumper.global, 'foo');
const cases = [
[intrp.OBJECT, "new 'Object.prototype'"],
[func, 'function foo(bar) {}'],
[new intrp.Object(intrp.ROOT), '{}'],
[new intrp.Array(intrp.ROOT), '[]'],
[new intrp.Date(new Date('1975-07-27'), intrp.ROOT),
"new Date('1975-07-27T00:00:00.000Z')"],
[new intrp.RegExp(/foo/ig, intrp.ROOT), '/foo/gi'],
[new intrp.Error(intrp.ROOT, intrp.ERROR), "new Error()"],
[new intrp.Error(intrp.ROOT, intrp.ERROR, 'message'),
"new Error('message')"],
[new intrp.Error(intrp.ROOT, intrp.EVAL_ERROR), "new EvalError()"],
[new intrp.Error(intrp.ROOT, intrp.RANGE_ERROR), "new RangeError()"],
[new intrp.Error(intrp.ROOT, intrp.REFERENCE_ERROR),
"new ReferenceError()"],
[new intrp.Error(intrp.ROOT, intrp.SYNTAX_ERROR), "new SyntaxError()"],
[new intrp.Error(intrp.ROOT, intrp.TYPE_ERROR), "new TypeError()"],
[new intrp.Error(intrp.ROOT, intrp.URI_ERROR), "new URIError()"],
[new intrp.Error(intrp.ROOT, intrp.PERM_ERROR), "new PermissionError()"],
[new intrp.Error(intrp.ROOT, intrp.OBJECT), "new Error()"],
[new intrp.Error(intrp.ROOT, null), "new Error()"],
[new intrp.WeakMap(), 'new WeakMap()'],
];
// A fake reference: exprFor_ won't create an unreferenceable object.
const ref = new Components(dumper.global, 'dummyVariable');
for (const [value, expected] of cases) {
const r = dumper.exprFor_(value, ref);
t.expect(util.format('Dumper.p.exprFor_(%s)', value), r, expected);
}
};
/**
* Tests for Dumper.prototype.survey_, and in particular the
* imlementation of Dijkstra's Algorigithm it uses to set the
* .preferredRef property on ObjectDumper instances.
* @param {!T} t The test runner object.
* @suppress {accessControls}
*/
exports.testDumperPrototypeSurvey = function(t) {
const intrp = getInterpreter();
// Create various variables to dump.
intrp.createThreadForSrc(`
var func = (function() {
var unreachable = {unreachable: true};
return function foo() {return unreachable;};
})();
var arr = [{baz: {}}];
var foo = {bar: arr[0]};
Object.setPrototypeOf(foo.bar, {});
`);
intrp.run();
// Create Dumper with pristine Interpreter instance to compare to;
// get ScopeDumper for global scope. Dumper constructor performs
// survey.
const pristine = new Interpreter();
const dumper = new Dumper(pristine, intrp);
// Check preferredRef of various objects. The preferred selector is
// assumed to be the same as the selector used to obtain the object
// unless otherwise specified.
const tc = [
['func'],
['func{proto}', 'Function.prototype'],
['func{owner}', 'CC.root'],
['func.prototype'],
['func.prototype{proto}', 'Object.prototype'],
['foo'],
['foo{proto}', 'Object.prototype'],
['foo.bar{proto}'],
['foo.bar.baz{proto}', 'Object.prototype'],
['arr[0]', 'foo.bar'],
];
for (const [ss, expected] of tc) {
const objDumper = dumper.getDumperFor(ss);
t.expect('Dumper.p.survey_: .preferredRef of ' + ss,
objDumper.getSelector(/*preferred=*/true).toString(),
expected || ss);
}
// Can't create preferred Selector for unreachable (it's
// unreachable!), so check .preferredRef manually.
const func = intrp.global.get('func');
if (!(func instanceof intrp.UserFunction) || !func.scope.outerScope) {
throw new TypeError('func.scope.outerScope not a Scope');
}
const funcScopeDumper = dumper.getScopeDumper_(func.scope.outerScope);
const unreachable = func.scope.outerScope.get('unreachable');
if (!(unreachable instanceof intrp.Object)) throw new TypeError();
const unreachableDumper = dumper.getObjectDumper_(unreachable);
t.expect('Dumper.p.survey_: unreachableDumper.preferredRef.dumper',
unreachableDumper.preferredRef.dumper, funcScopeDumper);
t.expect('Dumper.p.survey_: unreachableDumper.preferredRef.part',
unreachableDumper.preferredRef.part, 'unreachable');
};
/**
* Tests for the ObjectDumper.prototype.survey and
* ScopeDumper.prototype.survey methods and their recording of
* information about Scopes, Arguments objects and so on.
* @param {!T} t The test runner object.
* @suppress {accessControls}
*/
exports.testSubDumperPrototypeSurvey = function(t) {
const intrp = new Interpreter();
// Create various variables to dump, including creating a closure
// belonging to two functions.
intrp.createThreadForSrc(`
var foo = (function() {
var x = 42;
bar = function baz() {return x;};
function quux() {return -x;};
return quux;
arguments; // Never reached, but forces Arguments instantiation.
})();
var bar; // N.B.: hoisted.
var orphanArgs = (function() {return arguments;})();
`);
intrp.run();
// Create Dumper with pristine Interpreter instance to compare to;
// get ScopeDumper for global scope. Dumper constructor performs
// survey.
const pristine = new Interpreter();
const dumper = new Dumper(pristine, intrp);
// Check relationship of functions and scopes recorded by survey.
const baz = /** @type {!Interpreter.prototype.UserFunction} */(
intrp.global.get('bar')); // Function baz was stored in var bar.
const quux = /** @type {!Interpreter.prototype.UserFunction} */(
intrp.global.get('foo')); // IIFE returned quux; was stored in var foo.
const globalDumper = dumper.getScopeDumper_(intrp.global);
const bazDumper = dumper.getObjectDumper_(baz);
const bazScopeDumper = dumper.getScopeDumper_(baz.scope);
const quuxDumper = dumper.getObjectDumper_(quux);
const quuxScopeDumper = dumper.getScopeDumper_(quux.scope);
t.expect('bazScopeDumper.scope.type', bazScopeDumper.scope.type, 'funexp');
t.expect('quuxScopeDumper.scope.type',
quuxScopeDumper.scope.type, 'function');
t.expect('globalDumper.innerFunctions.size',
globalDumper.innerFunctions.size, 0);
t.expect('globalDumper.innerScopes.size', globalDumper.innerScopes.size, 1);
t.assert('globalDumper.innerScopes.has(/* quux.scope */)',
globalDumper.innerScopes.has(quuxScopeDumper));
t.expect('quuxScopeDumper.innerFunctions.size',
quuxScopeDumper.innerFunctions.size, 1);
t.assert('quuxScopeDumper.innerFunctions.has(/* quux */)',
quuxScopeDumper.innerFunctions.has(quuxDumper));
t.expect('quuxScopeDumper.innerScopes.size',
quuxScopeDumper.innerScopes.size, 1);
t.assert('quuxScopeDumper.innerScopes.has(/* baz.scope */)',
quuxScopeDumper.innerScopes.has(bazScopeDumper));
t.expect('bazScopeDumper.innerFunctions.size',
bazScopeDumper.innerFunctions.size, 1);
t.assert('bazScopeDumper.innerFunctions.has(/* baz */)',
bazScopeDumper.innerFunctions.has(bazDumper));
t.expect('bazScopeDumper.innerScopes.size',
bazScopeDumper.innerScopes.size, 0);
// Check relationship of Arguments objects and scopes recorded by survey.
const quuxArgs = /** @type {!Interpreter.prototype.Arguments} */(
quuxScopeDumper.scope.get('arguments'));
const orphanArgs = /** @type {!Interpreter.prototype.Arguments} */(
intrp.global.get('arguments'));
t.expect('argumentsScopeDumpers.size',
dumper.argumentsScopeDumpers.size, 1);
t.assert('argumentsScopeDumpers.get(quuxArgs) === quuxScopeDumper',
dumper.argumentsScopeDumpers.get(quuxArgs) === quuxScopeDumper);
t.assert('argumentsScopeDumpers.get(orphanArgs) === quuxScopeDumper',
dumper.argumentsScopeDumpers.get(orphanArgs) === undefined);
};
/**
* Unit tests for the Dumper.prototype.exprForSelector_ method.
* @param {!T} t The test runner object.
* @suppress {accessControls}
*/
exports.testDumperPrototypeExprForSelector_ = function(t) {
const intrp = new Interpreter();
const pristine = new Interpreter();
const dumper = new Dumper(pristine, intrp);
// Test dumping a selector before and after dumping Object.getPrototypeOf.
const s1 = new Selector('foo.bar{proto}.baz');
t.expect(util.format('Dumper.p.exprForSelector_(%s) // 0', s1),
dumper.exprForSelector_(s1),
"(new 'Object.getPrototypeOf')(foo.bar).baz");
// Give Object.getPrototypeOf a referrence indicating it is
// available via the global variable myGetPrototypeOf.
dumper.getObjectDumper_(/** @type {!Interpreter.prototype.Object} */
(intrp.builtins.get('Object.getPrototypeOf'))).ref =
new Components(dumper.global, 'myGetPrototypeOf');
t.expect(util.format('Dumper.p.exprForSelector_(%s) // 1', s1),
dumper.exprForSelector_(s1),
'myGetPrototypeOf(foo.bar).baz');
// Test dumping a selector before and after dumping Object.getOwnerOf.
const s2 = new Selector('quux{owner}');
t.expect(util.format('Dumper.p.exprForSelector_(%s) // 0', s2),
dumper.exprForSelector_(s2), "(new 'Object.getOwnerOf')(quux)");
// Give Object.getOwnerOf a referrence indicating it is
// available via the global variable myGetOwnerOf.
dumper.getObjectDumper_(/** @type {!Interpreter.prototype.Object} */
(intrp.builtins.get('Object.getOwnerOf'))).ref =
new Components(dumper.global, 'myGetOwnerOf');
t.expect(util.format('Dumper.p.exprForSelector_(%s) // 1', s2),
dumper.exprForSelector_(s2), 'myGetOwnerOf(quux)');
};
/**
* Unit tests for the Dumper.prototype.exprForCall_ method.
* @param {!T} t The test runner object.
* @suppress {accessControls}
*/
exports.testDumperPrototypeExprForCall_ = function(t) {
const intrp = new Interpreter();
const pristine = new Interpreter();
const dumper = new Dumper(pristine, intrp);
// Test dumping builtin calls with no arguments. Note that eval is
// inserted in the global Scope at Interpreter construction time,
// while escape is not.
t.expect("Dumper.p.exprForCall_('eval')",
dumper.exprForCall_('eval'),
'eval()'); // eval is inserted in global scope at creation.
t.expect("Dumper.p.exprForCall_('escape')",
dumper.exprForCall_('escape'),
"(new 'escape')()");
// Test dumping builtin calls with primitive arguments.
t.expect("Dumper.p.exprForCall_('eval', [true])",
dumper.exprForCall_('eval', [true]),
"eval(true)");
t.expect("Dumper.p.exprForCall_('eval', ['foo', 42])",
dumper.exprForCall_('eval', ['foo', 42]),
"eval('foo', 42)");
// Test dumping builtin calls with object arguments.
t.expect("Dumper.p.exprForCall_('eval', [eval])",
dumper.exprForCall_('eval', [intrp.builtins.get('eval')]),
"eval(eval)");
// Test dumping builtin calls with Selector arguments.
t.expect("Dumper.p.exprForCall_('eval', [new Selector('foo.bar.baz')])",
dumper.exprForCall_('eval', [new Selector('foo.bar.baz')]),
"eval(foo.bar.baz)");
};
/**
* Tests for the Dumper.prototype.dumpBinding method, and by
* implication most of ScopeDumper and ObjectDumper.
* @param {!T} t The test runner object.
*/
exports.testDumperPrototypeDumpBinding = function(t) {
/** @type {string} Common minimal init src for all testcases. */
const common = "var Object = new 'Object';\n" +
['defineProperty', 'create', 'preventExtensions',
'setPrototypeOf', 'setOwnerOf', 'prototype'].map(
(member) => `
Object.${member} = new 'Object.${member}';
Object.defineProperty(Object, '${member}', {enumerable: false});
`).join('');
/**
* @type {!Array<{src: string,
* prune: (!Array<(string|number)>|undefined),
* pruneRest: (!Array<(string|number)>|undefined),
* skip: (!Array<(string|number)>|undefined),
* set: (!Array<(string|number)>|undefined),
* dump: (!Array<(string|number)>|undefined),
* after: (!Array<(string|number)>|undefined)}>}
*/
const cases = [
{ // Test basics: DECL/SET/ATTR/DONE/RECURSE for variables and properties.
title: 'basics',
src: `
var prune = 'not dumped';
var skip = 'skipped';
var obj = {a: {x: 1}, b: 2, c: 3,
u: undefined, skip: 'skipped', prune: 'not dumped'};
Object.defineProperty(obj, 'a', {enumerable: false});
`,
prune: ['prune', 'obj.prune'],
skip: ['skip', 'obj.skip'],
set: ['Object', 'Object.setPrototypeOf', 'Object.defineProperty'],
dump: [
// [ selector, todo, expected output, expected done (default: todo) ]
// Order matters.
['prune', Do.SET, '', Do.UNSTARTED],
['skip', Do.SET, "var skip = 'skipped';\n", Do.RECURSE],
['obj', Do.DECL, 'var obj;\n'],
['obj', Do.SET, 'obj = {};\n', Do.DONE],
['obj.a', Do.DECL, 'obj.a = undefined;\n'],
['obj.a', Do.SET, 'obj.a = {};\n'],
['obj.a', Do.ATTR,
"Object.defineProperty(obj, 'a', {enumerable: false});\n"],
['obj.a', Do.RECURSE, 'obj.a.x = 1;\n'],
['obj.b', Do.SET, 'obj.b = 2;\n', Do.RECURSE],
['obj.u', Do.DECL, 'obj.u = undefined;\n', Do.RECURSE],
['obj', Do.RECURSE, 'obj.c = 3;\n', Do.DONE],
['obj.prune', Do.SET, '', Do.UNSTARTED],
['obj.skip', Do.SET, "obj.skip = 'skipped';\n", Do.RECURSE],
['obj', Do.RECURSE, ''],
],
after: [
// [ selector, expected done ]
['obj^', Do.RECURSE],
['obj.c', Do.RECURSE],
],
},
{ // Test the skipBinding option.
title: 'skipBinding',
src: `
var obj = {a: 'a', b: 'b'};
Object.setPrototypeOf(obj, {});
`,
set: ['Object', 'Object.setPrototypeOf'],
dump: [
['obj', Do.RECURSE, "var obj = {};\nobj.a = 'a';\n", Do.DONE,
{skipBindings: ['b', Selector.PROTOTYPE]}],
['obj', Do.RECURSE, 'Object.setPrototypeOf(obj, {});\n' +
"obj.b = 'b';\n", Do.RECURSE, {skipBindings: []}],
],
},
{ // Test simple recursion with pruning.
title: 'recursion-simple',
src: `
var obj = {a: {id: 'a'}, b: {id: 'b'}, c: {id: 'c'}};
Object.setPrototypeOf(obj.c, {id: 'd'});
`,
// Mark obj.b.id to be pruned, and pruneRest of obj.c.
prune: ['obj.b.id'],
pruneRest: ['obj.c'],
dump: [
['obj', Do.RECURSE,
'var obj = {};\n' +
"obj.a = {};\n" +
"obj.a.id = 'a';\n" +
'obj.b = {};\n' +
'obj.c = {};\n' +
"(new 'Object.setPrototypeOf')(obj.c, {});\n" +
"(new 'Object.getPrototypeOf')(obj.c).id = 'd';\n"],
],
after: [
['obj.a', Do.RECURSE],
['obj.a.id', Do.RECURSE],
['obj.b', Do.RECURSE],
['obj.b.id', Do.UNSTARTED],
['obj.c', Do.RECURSE],
['obj.c.id', Do.UNSTARTED],
],
},
{ // Test recursion in face of cyclic data and incomplet(able) properties.
title: 'recursion-incompletable',
src: `
var obj = {a: {id: 'a'}, b: {id: 'b'}, c: {id: 'c'}};
obj.a.self = obj.a;
obj.b.self = obj.b;
obj.c.parent = obj;
`,
// Mark obj.b.id to be skipped and obj.c.id to be pruned;
// attempting to dump obj recursively should be leave obj.a as
// RECUSE, obj.b and obj.c as DONE, and obj.a.id still
// UNSTARTED. obj.c left at DONE.
prune: ['obj.c.id'],
skip: ['obj.b.id'],
dump: [
['obj', Do.RECURSE,
// TODO(cpcallen): really want "var obj = {a: {id: 'a'}, ...".
'var obj = {};\n' +
"obj.a = {};\nobj.a.id = 'a';\nobj.a.self = obj.a;\n" +
'obj.b = {};\nobj.b.self = obj.b;\n' +
"obj.c = {};\nobj.c.parent = obj;\n", Do.DONE],
],
after: [
['obj.a', Do.RECURSE],
['obj.a.self', Do.RECURSE],
['obj.a.id', Do.RECURSE],
['obj.b', Do.DONE],
['obj.b.self', Do.DONE],
['obj.b.id', Do.UNSTARTED],
['obj.c', Do.DONE],
['obj.c.id', Do.UNSTARTED],
['obj.c.parent', Do.DONE],
],
},
{ // Test recursion that tries to revisit starting object.
title: 'recursion-revist',
src: `
var obj = {v: 42};
obj.obj = obj;
`,
dump: [
['obj', Do.DONE, 'var obj = {};\n'],
// TODO(cpcallen): might prefer '...obj.v = 42\n'.
['obj.obj', Do.RECURSE, 'obj.obj = obj;\nobj.obj.v = 42;\n'],
['obj', Do.RECURSE, ''],
],
after: [
['obj.v', Do.RECURSE],
],
},
{ // Test recursion, limited by subtree.
title: 'recursion-treeOnly',
src: `
var outsider = {iam: 'outsider'};
var obj = {
foo: [outsider, {iam: 'insider'}],
bar: {iam: 'bar'},
};
obj.foo[2] = obj.bar;
`,
set: ['obj'],
dump: [
['obj.foo', Do.RECURSE,
'obj.foo = [];\n' +
'obj.foo[0] = {};\n' +
"obj.foo[1] = {};\nobj.foo[1].iam = 'insider';\n" +
'obj.foo[2] = {};\n',
Do.DONE, {treeOnly: true}],
['obj', Do.RECURSE,
"obj.bar = obj.foo[2];\nobj.bar.iam = 'bar';\n",
Do.DONE, {treeOnly: true}],
['obj', Do.RECURSE,
"obj.foo[0].iam = 'outsider';\n",
Do.RECURSE, {treeOnly: false}],
],
},
{ // Test dumping property attributes.
title: 'attributes',
src: `
var obj = {w: {}, e: {}, c: {}};
Object.defineProperty(obj, 'w', {writable: false});
Object.defineProperty(obj, 'e', {enumerable: false});
Object.defineProperty(obj, 'c', {configurable: false});
`,
set: ['Object', 'obj'],
dump: [
['obj.w', Do.ATTR, "obj.w = {};\n" +
"(new 'Object.defineProperty')(obj, 'w', {writable: false});\n"],
['Object.defineProperty', Do.SET,
"Object.defineProperty = new 'Object.defineProperty';\n"],
['obj.e', Do.ATTR, "obj.e = {};\n" +
"Object.defineProperty(obj, 'e', {enumerable: false});\n"],
['obj.c', Do.ATTR, "obj.c = {};\n" +
"Object.defineProperty(obj, 'c', {configurable: false});\n"],
],
},
{ // Test correct dumping inherited-non-writable properties.
title: 'non-writable',
src: `
var parent = {foo: 0};
var child = [];
for (var i = 0; i <= 4; i++) {
child[i] = Object.create(parent);
child[i].foo = i;
}
child[4].foo = undefined; // Will have DECL do SET implicitly.
// Make it impossible to set child[i].foo by assignment.
Object.defineProperty(parent, 'foo', {writable: false});
`,
// Object.create is polyfilled; dumper won't call polyfill.
set: ['Object', 'Object.defineProperty', 'parent', 'child',
'child[0]', 'child[1]', 'child[2]', 'child[3]', 'child[4]'],
dump: [
// Inherited non-writable property doesn't exist yet.
['child[0].foo', Do.SET, 'child[0].foo = 0;\n', Do.RECURSE],
['parent', Do.RECURSE, 'parent.foo = 0;\n' +
"Object.defineProperty(parent, 'foo', {writable: false});\n"],
['child[1].foo', Do.DECL, "Object.defineProperty(child[1], 'foo', " +
'{writable: true, enumerable: true, configurable: true});\n'],
['child[1].foo', Do.SET, "child[1].foo = 1;\n", Do.RECURSE],
['child[2].foo', Do.SET, "Object.defineProperty(child[2], 'foo', " +
'{writable: true, enumerable: true, configurable: true,' +
' value: 2});\n', Do.RECURSE],
['child[3].foo', Do.ATTR, "Object.defineProperty(child[3], 'foo', " +
'{writable: true, enumerable: true, configurable: true,' +
' value: 3});\n', Do.RECURSE],
['child[4].foo', Do.DECL, "Object.defineProperty(child[4], 'foo', " +
'{writable: true, enumerable: true, configurable: true});\n',
Do.RECURSE],
],
after: [
['child[0]^', Do.DONE, 'parent'],
['child[1]^', Do.DONE, 'parent'],
['child[2]^', Do.DONE, 'parent'],
['child[3]^', Do.DONE, 'parent'],
['child[4]^', Do.DONE, 'parent'],
],
},
{ // Test dumping {proto} bindings.
title: '{proto}',
src: `
var parent = {};
var child0 = Object.create(parent);
var child1 = Object.create(parent);
var child2 = Object.create(parent);
var child3 = Object.create(parent);
`,
set: ['Object'], // N.B.: Object.create is polyfilled.
dump: [
['child0', Do.DONE, 'var child0 = {};\n'],
['child1', Do.DONE, 'var child1 = {};\n'],
['child2', Do.DONE, 'var child2 = {};\n'],
['parent', Do.DONE, 'var parent = {};\n'],
['child3', Do.DONE, "var child3 = (new 'Object.create')(parent);\n"],
['child1^', Do.SET, "(new 'Object.setPrototypeOf')(child1, parent);\n",
Do.DONE],
['Object.setPrototypeOf', Do.SET,
"Object.setPrototypeOf = new 'Object.setPrototypeOf';\n"],
['child2^', Do.SET, 'Object.setPrototypeOf(child2, parent);\n',
Do.DONE],
],
after: [
['child0^', Do.DECL],
['child1^', Do.DONE, 'parent'],
['child2^', Do.DONE, 'parent'],
['child3^', Do.DONE, 'parent'],
]
},
{ // Test dumping {proto} bindings: null-protoype objects.
title: 'null {proto}',
src: `
var objs = {obj: {}, fun: function() {}, arr: []};
for (var p in objs) {
Object.setPrototypeOf(objs[p], null);
}
`,
set: ['Object', 'Object.setPrototypeOf', 'objs'],
dump: [
['objs.obj', Do.DONE, "objs.obj = (new 'Object.create')(null);\n"],
['objs.obj{proto}', Do.DONE, '', Do.RECURSE],
['objs.fun', Do.DONE, 'objs.fun = function() {};\n'],
['objs.fun{proto}', Do.SET, 'Object.setPrototypeOf(objs.fun, null);\n',
Do.RECURSE],
['objs.arr', Do.DONE, 'objs.arr = [];\n'],
['objs.arr{proto}', Do.SET, 'Object.setPrototypeOf(objs.arr, null);\n',
Do.RECURSE],
],
},
{ // Test dumping {owner} bindings.
title: '{owner}',
src: `
var CC = {};
CC.root = new 'CC.root';
var setPerms = new 'setPerms';
var alice = {};
alice.thing = (function() {setPerms(alice); return {};})();
var bob = {};
bob.thing = {};
Object.setOwnerOf(bob.thing, bob);
var unowned = {};
Object.setOwnerOf(unowned, null);
`,
set: ['Object', 'CC', 'CC.root'],
dump: [
['alice', Do.DONE, 'var alice = {};\n'],
['alice.thing', Do.DONE, 'alice.thing = {};\n'],
['alice.thing{owner}', Do.SET, "(new 'Object.setOwnerOf')" +
'(alice.thing, alice);\n', Do.DONE],
['Object.setOwnerOf', Do.SET,
"Object.setOwnerOf = new 'Object.setOwnerOf';\n"],
['bob', Do.RECURSE, 'var bob = {};\nbob.thing = {};\n' +
"Object.setOwnerOf(bob.thing, bob);\n"],
['unowned', Do.SET, 'var unowned = {};\n', Do.DONE],
['unowned{owner}', Do.SET, 'Object.setOwnerOf(unowned, null);\n',
Do.RECURSE],
],
after: [
['alice', Do.DONE],
['alice{owner}', Do.DONE, 'CC.root'],
['alice.thing{owner}', Do.DONE, 'alice'],
['bob', Do.RECURSE],
['bob{owner}', Do.RECURSE, 'CC.root'],
['bob.thing{owner}', Do.RECURSE, 'bob'],
],
},
{ // Test dumping extensibility (with related recursion tests).
title: 'extensibility',
src: `
var other = {id: 'other'};
var obj1 = {id: 1};
var obj2 = {id: 2};
var obj3 = {id: 3, other: other};
Object.preventExtensions(obj1);
Object.preventExtensions(obj2);
Object.preventExtensions(obj3);
`,
set: ['Object', 'obj1', 'obj2', 'obj3'],
dump: [
['obj1.id', Do.SET, 'obj1.id = 1;\n', Do.RECURSE],
['obj1', Do.RECURSE, "(new 'Object.preventExtensions')(obj1);\n"],
['Object.preventExtensions', Do.SET,
"Object.preventExtensions = new 'Object.preventExtensions';\n",],
// Verify property set before extensibility prevented.
['obj2', Do.RECURSE, 'obj2.id = 2;\nObject.preventExtensions(obj2);\n'],
// Verify treeOnly doesn't prevent .preventExtensions being called.
['obj3', Do.RECURSE, 'obj3.id = 3;\nobj3.other = {};\n' +
'Object.preventExtensions(obj3);\n', Do.DONE, {treeOnly: true}],
// Verify we don't call .preventExtensions more than once.
['obj3', Do.RECURSE, "obj3.other.id = 'other';\n", Do.RECURSE,
{treeOnly: false}],
],
},
{ // Test dumping null variables.
// (See https://github.com/google/CodeCity/pull/371/files#r429566592)
title: 'null variable',
src: 'var n = null;',
dump: [
['n', Do.SET, 'var n = null;\n', Do.RECURSE],
],
},
{ // Test (not) dumping immutable bindings in the global scope.
title: 'immutables',
dump: [
['NaN', Do.RECURSE, ''],
['Infinity', Do.RECURSE, ''],
['undefined', Do.RECURSE, ''],
['eval', Do.RECURSE, ''],
],
},
{ // Test dumping Function objects.
title: 'Function',
src: `
var Function = new 'Function';
function f1(arg) {}
var f2 = function F2(arg) {};
var obj = {f3: function() {}};
var f4 = new Function('a1', 'a2,a3', 'a4, a5', '');
`,
set: ['obj'],
dump: [
// BUG(cpcallen): Really want 'function f1(arg) {};\n'.
['f1', Do.SET, 'var f1 = function f1(arg) {};\n', Do.DONE],
// BUG(cpcallen): this causes a crash.
// ['f1', Do.RECURSE, '', Do.RECURSE],
['f2', Do.SET, 'var f2 = function F2(arg) {};\n', Do.DONE],
['obj.f3', Do.SET, 'obj.f3 = function() {};\n', Do.DONE],
// BUG(cpcallen): Really want '... = Function(...', due to scoping.
['f4', Do.SET,
'var f4 = function anonymous(a1,a2,a3,a4, a5\n) {\n\n};\n', Do.DONE],
// TODO(ES5): verify that f4.name gets deleted.
],
after: [
['f1^', Do.DONE],
['f1.length', Do.RECURSE],
['f1.name', Do.RECURSE],
['f1.prototype', Do.DONE, 'f1.prototype'],
['f1.prototype.constructor', Do.DONE, 'f1'],
['f2^', Do.DONE],
['f2.length', Do.RECURSE],
['f2.name', Do.RECURSE],
['f2.prototype', Do.DONE, 'f2.prototype'],
['f2.prototype.constructor', Do.DONE, 'f2'],
['obj.f3^', Do.DONE],
['obj.f3.length', Do.RECURSE],
['obj.f3.name', Do.UNSTARTED], // N.B.: not implicitly set.
['obj.f3.prototype', Do.DONE, 'obj.f3.prototype'],
['obj.f3.prototype.constructor', Do.DONE, 'obj.f3'],
['f4^', Do.DONE],
// TODO(ES6): verify that f4.name is implicitly set to 'anonymous'.
['f4.length', Do.RECURSE],
['f4.prototype', Do.DONE, 'f4.prototype'],
['f4.prototype.constructor', Do.DONE, 'f4'],
],
},
{ // Test Function objects with usable and unusable .prototype
// objects. Note that we don't need to worry about the
// attributes of the .prototype property, because a function
// object's .prototype is always non-configurable.
title: 'Function .prototype',
src: `
var f1 = function() {};
var f2 = function() {};
var f3 = function() {};
var obj1 = f1.prototype;
var obj2 = f2.prototype;
f3.prototype = [];
`,
set: ['Object', 'Object.defineProperty'],
dump: [
// No problem if f1 dumped before obj1.
['f1', Do.RECURSE, 'var f1 = function() {};\n'],
['obj1', Do.DONE, 'var obj1 = f1.prototype;\n'],
// Surmountable difficulty if obj2 dumped before f2.
['obj2', Do.DONE, 'var obj2 = {};\n'],
['f2', Do.DONE, 'var f2 = function() {};\n'],
['f2.prototype', Do.DONE, 'f2.prototype = obj2;\n'],
['f2', Do.RECURSE, 'f2.prototype.constructor = f2;\n' +
"Object.defineProperty(f2.prototype, 'constructor', " +
'{enumerable: false});\n'],
// Non-plain-Object .protype values require special handling too.
['f3', Do.DONE, 'var f3 = function() {};\n'],
['f3', Do.RECURSE, 'f3.prototype = [];\n'],
],
after: [
['obj1', Do.DONE, 'obj1'], // Var not RECURSEed (only object).
['f1.prototype', Do.RECURSE, 'obj1'],
['f1.prototype.constructor', Do.RECURSE, 'f1'],
['f2.prototype', Do.RECURSE, 'obj2'],
['f2.prototype.constructor', Do.RECURSE, 'f2'],
],
},
{ // Test dumping Function objects' .prototype.constructor property.
title: 'Function .prototype.constructor',
src: `
var f1 = function() {};
var f2 = function() {};
var f3 = function() {};
Object.defineProperty(f2.prototype, 'constructor',
{enumerable: true});
Object.defineProperty(f3.prototype, 'constructor',
{writable: false, value: 42});
`,
set: ['Object', 'Object.defineProperty', 'f1', 'f2', 'f3'],
dump: [
['f3.prototype', Do.DONE, ''],
['f3.prototype.constructor', Do.SET,
'f3.prototype.constructor = 42;\n'],
['f3.prototype', Do.RECURSE, 'Object.defineProperty(f3.prototype, ' +
"'constructor', {writable: false});\n"],
],
after: [
['f1.prototype.constructor', Do.DONE],
['f2.prototype.constructor', Do.SET],
],
},
{ // Test dumping Function objects' .name property.
title: 'Function .name',
src: `
var f1 = function() {};
var f2 = function() {};
Object.defineProperty(f1, 'name', {value: 'Hi!'});
delete f2.name;
`,
set: ['Object', 'Object.defineProperty', 'f1', 'f2'],
dump: [
['f1', Do.RECURSE, "Object.defineProperty(f1, 'name', " +
"{value: 'Hi!'});\n"],
['f2', Do.RECURSE, 'delete f2.name;\n'],
],
},
{ // Test dumping Array objects.
title: 'Array',
src: `
var Array = new 'Array';
var obj = {};
var arr = [42, 69, 105, obj, {}];
var sparse = [0, , 2];
Object.setPrototypeOf(sparse, null);
sparse.length = 4;
`,
set: ['Object', 'Object.setPrototypeOf', 'obj'],
dump: [
// TODO(cpcallen): really want 'var arr = [42, 69, 105, obj, {}];\n'.
['arr', Do.RECURSE, 'var arr = [];\narr[0] = 42;\narr[1] = 69;\n' +
'arr[2] = 105;\narr[3] = obj;\narr[4] = {};\n'],
// TODO(cpcallen): really want something like
// 'var sparse = [0, , 2];\nsparse.length = 4;'.
['sparse', Do.RECURSE, 'var sparse = [];\n' +
'Object.setPrototypeOf(sparse, null);\n' +
'sparse[0] = 0;\nsparse[2] = 2;\nsparse.length = 4;\n'],
],
after: [
['arr^', Do.RECURSE],
['arr.length', Do.RECURSE],
['sparse^', Do.RECURSE],
['sparse.length', Do.RECURSE],
],
},
{ // Test dumping Date objects.
title: 'Date',
src: `
var Date = new 'Date';
var date1 = new Date('1975-07-27');
var date2 = new Date('1979-01-04');
`,
dump: [
['date1', Do.SET,
"var date1 = new (new 'Date')('1975-07-27T00:00:00.000Z');\n",
Do.DONE],
['Date', Do.SET, "var Date = new 'Date';\n", Do.DONE],
['date2', Do.SET, "var date2 = new Date('1979-01-04T00:00:00.000Z');\n",
Do.DONE],
],
after: [
['date1^', Do.DONE],
['date2^', Do.DONE],
],
},
{ // Test dumping RegExp objects.
title: 'RegExp',
src: `
var RegExp = new 'RegExp';
var re0 = new RegExp();
var re1 = /foo/ig;
var re2 = /bar/g;
Object.setPrototypeOf(re2, re1);
re2.lastIndex = 42;
var re3 = /baz/m;
Object.setPrototypeOf(re3, re1);
`,
set: ['Object', 'Object.setPrototypeOf'],
dump: [
['re0', Do.SET, 'var re0 = /(?:)/;\n', Do.DONE],
['re1', Do.SET, 'var re1 = /foo/gi;\n', Do.DONE],
['re2', Do.RECURSE, 'var re2 = /bar/g;\n' +
'Object.setPrototypeOf(re2, re1);\n' +
're2.lastIndex = 42;\n'],
['re3', Do.SET, 'var re3 = /baz/m;\n', Do.DONE],
['re3^', Do.SET, 'Object.setPrototypeOf(re3, re1);\n', Do.DONE],
],
after: [
['re1^', Do.RECURSE],
['re1.source', Do.RECURSE],
['re1.global', Do.RECURSE],
['re1.ignoreCase', Do.RECURSE],
['re1.multiline', Do.RECURSE],
['re1.lastIndex', Do.RECURSE],
['re2^', Do.RECURSE, 're1'],
['re2.source', Do.RECURSE],
['re2.global', Do.RECURSE],
['re2.ignoreCase', Do.RECURSE],
['re2.multiline', Do.RECURSE],
['re2.lastIndex', Do.RECURSE],
['re3^', Do.DONE, 're1'],
['re3.source', Do.RECURSE],
['re3.global', Do.RECURSE],
['re3.ignoreCase', Do.RECURSE],
['re3.multiline', Do.RECURSE],
['re3.lastIndex', Do.RECURSE],
],
},
{ // Test dumping Error objects.
title: 'Error',
src: `
var Error = new 'Error';
var TypeError = new 'TypeError';
var RangeError = new 'RangeError';
var error1 = new Error('message1');
error1.stack = 'stack1'; // Because it's otherwise kind of random.
var error2 = new TypeError('message2');
error2.stack = 'stack2';
var error3 = new RangeError();
Object.setPrototypeOf(error3, error1);
error3.message = 69;
Object.defineProperty(error3, 'message', {writable: false});
delete error3.stack;
`,
set: ['Object', 'Object.defineProperty', 'Object.setPrototypeOf'],
dump: [
['error1', Do.SET, "var error1 = new (new 'Error')('message1');\n",
Do.DONE],
['error1', Do.RECURSE, "error1.stack = 'stack1';\n"],
['Error', Do.SET, "var Error = new 'Error';\n", Do.DONE],
['TypeError', Do.SET, "var TypeError = new 'TypeError';\n", Do.DONE],
['RangeError', Do.SET, "var RangeError = new 'RangeError';\n", Do.DONE],
['error2', Do.SET, "var error2 = new TypeError('message2');\n",
Do.DONE],
['error2', Do.RECURSE, "error2.stack = 'stack2';\n"],
['error3', Do.SET, 'var error3 = new Error();\n', Do.DONE],
['error3.message', Do.ATTR, 'error3.message = 69;\n' +
"Object.defineProperty(error3, 'message', {writable: false});\n",
Do.RECURSE],
['error3', Do.RECURSE, 'delete error3.stack;\n' +
'Object.setPrototypeOf(error3, error1);\n'],
],
after: [
['error1.message', Do.RECURSE],
['error2.message', Do.RECURSE],
],
},
{ // Test dumping WeakMap objects.
title: 'WeakMap',
src: `
var WeakMap = new 'WeakMap';
var Object = new 'Object';
Object.setPrototypeOf = new 'Object.setPrototypeOf';
var wm1 = new WeakMap();
var wm2 = new WeakMap();
Object.setPrototypeOf(wm2, null);
`,
set: ['Object', 'Object.setPrototypeOf'],
dump: [
['wm1', Do.SET, "var wm1 = new (new 'WeakMap')();\n", Do.DONE],
['WeakMap', Do.SET, "var WeakMap = new 'WeakMap';\n", Do.DONE],
['wm2', Do.SET, 'var wm2 = new WeakMap();\n', Do.DONE],
],
after: [
['wm1^', Do.DONE],
['wm2^', Do.DECL],
],
},
{ // Test dumping builtin objects.
title: 'Builtins',
src: '',
dump: [
['Object', Do.DONE, "var Object = new 'Object';\n"],
['Object.prototype', Do.SET,
"Object.prototype = new 'Object.prototype';\n"],
],
},
];
for (const tc of cases) {
const prefix = 'dumpBinding: ' + tc.title + ': ';
// Create Interprerter and objects to dump. Run minimal common
// init then any testcase-specific init source.
const intrp = new Interpreter();
intrp.createThreadForSrc(common);
if (tc.src) intrp.createThreadForSrc(tc.src);
intrp.run();
// Create Dumper with pristine Interpreter instance to compare to.
// Supply treeOnly: false because most tests were written before
// this option was created (and made to default to true).
const pristine = new Interpreter();
const dumper = new Dumper(pristine, intrp, {treeOnly: false});
// Set a few object .done flags in advance, to limit recursive
// dumping of builtins in tests.
for (const builtin of [intrp.OBJECT, intrp.FUNCTION, intrp.ARRAY,
intrp.REGEXP, intrp.ERROR, intrp.TYPE_ERROR,
intrp.RANGE_ERROR, intrp.ROOT]) {
/** @suppress {accessControls} */
dumper.getObjectDumper_(builtin).done =
ObjectDumper.Done.DONE_RECURSIVELY;
};
// Set a few binding .done flags in advance to simulate things
// already being dumped or being marked for deferred dumping.
for (const ss of tc.prune || []) {
dumper.prune(new Selector(ss));
}
for (const ss of tc.pruneRest || []) {
dumper.pruneRest(new Selector(ss));
}
for (const ss of tc.skip || []) {
dumper.skip(new Selector(ss));
}
for (const ss of tc.set || []) {
dumper.dumpBinding(new Selector(ss), Do.SET);
}
// Check generated output for (and post-dump status of) specific bindings.
for (const [ss, todo, expected, done, options] of tc.dump || []) {
const s = new Selector(ss);
// Dump binding and check output code.
const result = new MockWritable();
if (options) dumper.setOptions(options);
dumper.setOptions({output: result});
dumper.unskip(s);
dumper.dumpBinding(s, todo);
t.expect(util.format('%sDumper.p.dumpBinding(<%s>, %o)', prefix,
s, todo),
String(result), expected);
// Check work recorded.
/** @suppress {accessControls} */
const {dumper: d, part} = dumper.getComponentsForSelector_(s);
t.expect(util.format('%sBinding status of <%s> (after dump)', prefix, s),
d.getDone(part), done === undefined ? todo : done);
}
// Check status of (some of the) additional bindings that will be
// set implicitly as a side effect of the code generated above, and
// that their values have the expected references (where
// object-valued and already dumped).
//
// TODO(cpcallen): The value checks are NOT checking the dumped
// value (or even, for .proto, the internal record of the current
// value), but instead just the preferred selector for the actual
// value in interp2. That's not really too useful, so maybe they
// should be removed.
for (const [ss, done, valueSelector] of tc.after || []) {
const s = new Selector(ss);
/** @suppress {accessControls} */
const {dumper: d, part} = dumper.getComponentsForSelector_(s);
t.expect(util.format('%sbinding status of <%s> (implicit)', prefix, s),
d.getDone(part), done);
if (valueSelector) {
const objDumper = dumper.getDumperFor(ss);
t.expect(util.format('%sref for %s', prefix, s),
objDumper.getSelector(/*preferred=*/true).toString(),
valueSelector);
}
}
}
};
/**
* Unit tests for Dumper.prototype.warn
* @param {!T} t The test runner object.
*/
exports.testDumperPrototypeWarn = function(t) {
const intrp = new Interpreter();
const dumper = new Dumper(intrp, intrp);
const output = new MockWritable();
dumper.setOptions({output: output});
dumper.warn('1');
dumper.warn('2\n');
dumper.indent = ' ';
dumper.warn('3\n4');
t.expect('Dumper.prototype.warn(...) output', String(output),
'// 1\n// 2\n // 3\n // 4\n');
};
/**
* Tests for the ScopeDumper.prototype.dump method.
* @param {!T} t The test runner object.
*/
exports.testScopeDumperPrototypeDump = function(t) {
const intrp = new Interpreter();
// Create various variables to dump.
intrp.createThreadForSrc(`
var value = 42;
var obj = (new 'Object.create')(null);
obj.prop = 69;
`);
intrp.run();
// Create Dumper with pristine Interpreter instance to compare to;
// get ScopeDumper for global scope.
const pristine = new Interpreter();
const dumper = new Dumper(pristine, intrp);
/** @suppress {accessControls} */
const globalDumper = dumper.getScopeDumper_(intrp.global);
// Set a few object .done flags in advance, to limit recursive
// dumping of builtins in tests.
// TODO(cpcallen): this is a temporary hack while refactoring
// recursion out of SubDumper.p.dumpBinding; remove once that
// refactor is done.
for (const builtin of [intrp.OBJECT, intrp.FUNCTION, intrp.ARRAY,
intrp.REGEXP, intrp.ERROR, intrp.TYPE_ERROR,
intrp.RANGE_ERROR, intrp.ROOT]) {
/** @suppress {accessControls} */
dumper.getObjectDumper_(builtin).done =
ObjectDumper.Done.DONE_RECURSIVELY;
};
// Dump one binding and check result.
let result = new MockWritable();
dumper.setOptions({output: result});
globalDumper.dumpBinding(dumper, 'obj', Do.SET);
t.expect("ScopeDumper.p.dumpBinding(..., 'obj', Do.SET, ...) outputs",
String(result), "var obj = (new 'Object.create')(null);\n");
// Dump the rest & check result.
dumper.setOptions({output: (result = new MockWritable())});
globalDumper.dump(dumper);
t.expect('ScopeDumper.p.dump(...) outputs', String(result),
'var value = 42;\nobj.prop = 69;\n');
};
/**
* Unit tests for Dumper.prototype.dump. These need to be async
* because connectionListen is (under the covers).
* @param {!T} t The test runner object.
*/
exports.testDumperPrototypeDump = async function(t) {
const intrp = new Interpreter({noLog: ['net']});
// Create a NativeFuction called "continue" that can be used to
// resolve awaited Promises. (Don't add it to the global scope, as
// doing so causes dump errors because it's not present in a
// pristine Interpreter instance.)
// TODO(cpcallen): consider abstracting test machinery into a
// runAsyncDumpTest function?
let resolve;
intrp.createNativeFunction('continue', () => {resolve();}, false);
// Create a variable and two listening sockets to dump.
intrp.createThreadForSrc(`
var listener = {onRecieve: function onRecieve(data) {}};
(new 'CC.connectionListen')(8888, listener, 100);
(new 'CC.connectionListen')(8889, listener);
(new 'continue')();
`);
intrp.start();
await new Promise((res, rej) => {resolve = res;}); // Wait for continue().
intrp.pause();
// Create Dumper with pristine Interpreter instance to compare to.
const pristine = new Interpreter();
const dumper = new Dumper(pristine, intrp);
const output = new MockWritable();
dumper.setOptions({output: output});
dumper.dump();
t.expect('Dumper.p.dump(...) outputs', String(output),
'var listener = {};\n' +
'listener.onRecieve = function onRecieve(data) {};\n' +
"(new 'CC.connectionListen')(8888, listener, 100);\n" +
"(new 'CC.connectionListen')(8889, listener);\n");
// Clean up.
intrp.createThreadForSrc(`
(new "CC.connectionUnlisten")(8888);
(new "CC.connectionUnlisten")(8889);
(new 'continue')();
`);
intrp.start();
await new Promise((res, rej) => {resolve = res;}); // Wait for continue().
intrp.stop();
};
================================================
FILE: server/tests/interpreter_bench.js
================================================
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Benchmarks for JavaScript interpreter.
* @author cpcallen@google.com (Christopher Allen)
*/
'use strict';
const util = require('util');
const Interpreter = require('../interpreter');
const getInterpreter = require('./interpreter_common').getInterpreter;
const testcases = require('./testcases');
/**
* Run a benchmark of the interpreter.
* @param {!B} b The benchmark runner object.
* @param {string} name The name of the test.
* @param {string} setup Source to be evaled to set up benchmark environment.
* @param {string} timed Source to be evaled and timed.
*/
function runBench(b, name, setup, timed) {
for (let i = 0; i < 4; i++) {
const interpreter = getInterpreter();
const err = undefined;
try {
interpreter.createThreadForSrc(setup);
interpreter.run();
interpreter.createThreadForSrc(timed);
b.start(name, i);
interpreter.run();
b.end(name, i);
} catch (err) {
b.crash(name, util.format('%s\n%s\n%s', setup, timed, err.stack));
}
}
};
/**
* Run the fibbonacci10k benchmark.
* @param {!B} b The test runner object.
*/
exports.benchFibbonacci10k = function(b) {
const name = 'fibonacci10k';
const setup = `
var fibonacci = function(n, output) {
var a = 1, b = 1, sum;
for (var i = 0; i < n; i++) {
output.push(a);
sum = a + b;
a = b;
b = sum;
}
}`;
const timed = `
for(var i = 0; i < 10000; i++) {
var result = [];
fibonacci(78, result);
}
result;
`;
runBench(b, name, setup, timed);
};
/**
* Run some benchmarks of Array.prototype.sort.
* @param {!B} b The test runner object.
*/
exports.benchSort = function(b) {
for (const len of [10, 100, 1000, 10000]) {
const name = 'sort ' + len;
const setup = `
var arr = [];
for (var i = 0; i < ${len}; i++) {
arr.push(Math.floor(Math.random() * ${len}));
}`;
const timed = `
arr.sort(function(a, b) {return a - b;});
`;
runBench(b, name, setup, timed);
}
};
================================================
FILE: server/tests/interpreter_common.js
================================================
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Load polyfills for tests.
* @author fraser@google.com (Neil Fraser)
*/
'use strict';
const fs = require('fs');
const Interpreter = require('../interpreter');
exports.startupFiles = {
es5: fs.readFileSync('startup/es5.js', 'utf8'),
es6: fs.readFileSync('startup/es6.js', 'utf8'),
es7: fs.readFileSync('startup/es7.js', 'utf8'),
esx: fs.readFileSync('startup/esx.js', 'utf8'),
cc: fs.readFileSync('startup/cc.js', 'utf8'),
};
/**
* Create an initialize an Interpreter instance.
* @param {!Interpreter.Options=} options Interpreter constructor
* options. (Default: see implementation.)
* @param {boolean=} init Load the standard startup files? (Default: true.)
* @return {!Interpreter}
*/
exports.getInterpreter = function(options, init) {
var intrp = new Interpreter(options);
if (init || init === undefined) {
for (const file of Object.values(exports.startupFiles)) {
intrp.createThreadForSrc(file);
intrp.run();
}
}
return intrp;
}
================================================
FILE: server/tests/interpreter_test.js
================================================
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Tests for JavaScript interpreter.
* @author cpcallen@google.com (Christopher Allen)
*/
'use strict';
const http = require('http');
const net = require('net');
const util = require('util');
const Interpreter = require('../interpreter');
const {getInterpreter} = require('./interpreter_common');
const Parser = require('../parser').Parser;
const {T} = require('./testing');
const testcases = require('./testcases');
///////////////////////////////////////////////////////////////////////////////
// Test helper functions.
///////////////////////////////////////////////////////////////////////////////
// Prepare static interpreter instance for runSimpleTest.
const interpreter = getInterpreter();
interpreter.global.createMutableBinding('src');
/**
* Run a simple test of the interpreter. A single, shared Interpreter
* instance is used by all tests executed by this function, but eval
* is used to evaluate src in its own scope. The supplied src must
* not modify objects accessible via the global scope!
* @param {!T} t The test runner object.
* @param {string} name The name of the test.
* @param {string} src The code to be evaled.
* @param {number|string|boolean|null|undefined} expected The expected
* completion value.
*/
function runSimpleTest(t, name, src, expected) {
let thread;
try {
interpreter.setValueToScope(interpreter.global, 'src', src);
thread = interpreter.createThreadForSrc('eval(src);').thread;
interpreter.run();
} catch (e) {
t.crash(name, util.format('%s\n%s', src, e.stack));
return;
}
const r = interpreter.pseudoToNative(thread.value);
t.expect(name, r, expected, src);
}
/**
* Run a test of the interpreter using an independent Interpreter
* instance, which may be created with non-default options and/or
* without the standard startup files, and during which various
* callbacks will be executed; see TestOptions for details.
* (Simulated) time will be automatically fast-forwarded as required
* to wake sleeping threads.
* @param {!T} t The test runner object.
* @param {string} name The name of the test.
* @param {string} src The code to be evaled.
* @param {number|string|boolean|null|undefined} expected The expected
* completion value.
* @param {!TestOptions=} options Custom test options.
*/
function runTest(t, name, src, expected, options) {
options = options || {};
const intrp = getInterpreter(options.options, options.standardInit);
if (options.onCreate) {
options.onCreate(intrp);
}
let thread;
try {
thread = intrp.createThreadForSrc(src).thread;
if (options.onCreateThread) {
options.onCreateThread(intrp, thread);
}
let runResult;
while ((runResult = intrp.run())) {
if (runResult > 0) { // Sleeping thread(s).
// Fast forward to wake-up time. Cast to defeat @private check.
/** @type {?} */(intrp).previousTime_ += runResult;
} else { // Blocked thread(s).
if (options.onBlocked) {
options.onBlocked(intrp);
}
}
}
} catch (e) {
t.crash(name, util.format('%s\n%s', src, e.stack));
return;
}
const r = intrp.pseudoToNative(thread.value);
t.expect(name, r, expected, src);
}
/**
* Run a (truly) asynchronous test of the interpreter. A new
* Interpreter instance is created for each test. Special functions
* resolve() and reject() are inserted in the global scope; they will
* end the test. If resolve() is called the test will end normally
* and the argument supplied will be compared with the expected value;
* if reject() is called the test will instead be treated as a
* failure.
* @param {!T} t The test runner object.
* @param {string} name The name of the test.
* @param {string} src The code to be evaled.
* @param {number|string|boolean|null|undefined} expected The expected
* completion value.
* @param {!TestOptions=} options Custom test options. Note that
* 'onBlocked' is ignored because the interpreter is .start()ed
* instead of .run() being called directly.
*/
async function runAsyncTest(t, name, src, expected, options) {
options = options || {};
const intrp = getInterpreter(options.options, options.standardInit);
if (options.onCreate) {
options.onCreate(intrp);
}
// Create promise to signal completion of test from within
// interpreter. Awaiting p will block until resolve or reject is
// called.
let resolve, reject, result;
const p = new Promise(function(res, rej) {resolve = res; reject = rej;});
intrp.global.createMutableBinding(
'resolve', intrp.createNativeFunction('resolve', resolve, false));
intrp.global.createMutableBinding(
'reject', intrp.createNativeFunction('reject', reject, false));
try {
const thread = intrp.createThreadForSrc(src).thread;
if (options.onCreateThread) {
options.onCreateThread(intrp, thread);
}
intrp.start();
result = await p;
} catch (e) {
t.fail(name, util.format('%s\n%s', src, e));
return;
} finally {
intrp.stop();
}
const r = intrp.pseudoToNative(result);
t.expect(name, r, expected, src);
}
/**
* Options for runTest and runAsyncTest.
* @record
*/
const TestOptions = function() {};
/**
* Interpreter constructor options.
* @type {!Interpreter.Options|undefined}
*/
TestOptions.prototype.options;
/**
* Load the standard startup files? (Default: true.)
* @type {boolean|undefined}
*/
TestOptions.prototype.standardInit;
/**
* Callback to be called after creating new interpreter instance (and
* running standard starup files, if not suppressed with standardInit:
* false) but before creating a thread for src. Can be used to insert
* extra bindings into the global scope (e.g., to create additional
* builtins).
*
* The first argument is the interpreter instance to be configured.
*
* @type {function(!Interpreter)|undefined}
*/
TestOptions.prototype.onCreate;
/**
* Callback to be called after creating a new Interpreter.Thread, but
* before running it.
*
* The first argument is the interpreter instance.
* The second argument is the thread just created.
*
* @type {function(!Interpreter, !Interpreter.Thread)|undefined}
*/
TestOptions.prototype.onCreateThread;
/**
* Callback to be called if .run() returns a negative value,
* indicating there are blocked threads. Can be used to fake
* completion of asynchronous events.
*
* The first argument is the interpreter instance to be configured.
*
* @type {function(!Interpreter)|undefined}
*/
TestOptions.prototype.onBlocked;
///////////////////////////////////////////////////////////////////////////////
// Tests: static analysis functions
///////////////////////////////////////////////////////////////////////////////
exports.testGetBoundNames = function(t) {
const name = 'getBoundNames';
const {getBoundNames} = Interpreter.testOnly;
const src = `
var a, b;
for (var c in {}) {}
function f(x) {
var y, z;
};
(function g() { var v; })();
`;
const ast = Parser.parse(src);
const boundNames = getBoundNames(ast);
const keys = Object.getOwnPropertyNames(boundNames);
t.expect(`${name}() keys`, keys.join(),
'a,b,c,f', src);
for (let i = 0; i < 3; i++) {
t.expect(`${name}()[${i}]`, boundNames[keys[i]], undefined, src);
}
t.expect(`${name}()[3]`, boundNames['f'], ast['body'][2], src);
};
exports.testHasArgumentsOrEval = function(t) {
const name = 'hasArgumentsOrEval';
const {hasArgumentsOrEval} = Interpreter.testOnly;
const cases = [
// [src, expected]; will only look at first statement src.
['Arguments;', false],
['arguments;', true],
['arguments[0];', true],
['foo[arguments];', true],
['bar(arguments);', true],
['{var x; function myArgs() {return arguments;}}', false],
['{function f() {} arguments;}', true],
['Eval;', false],
['eval;', true],
['eval();', true],
['Function.prototype.call(eval);', true],
['{var x; function myEval(arg) {eval(arg);}}', false],
['{function f() {} eval();}', true],
];
for (const [src, expected] of cases) {
try {
const ast = Parser.parse(src);
const firstStatement = ast['body'][0];
t.expect(`${name} ${src}`, hasArgumentsOrEval(firstStatement),
expected, src);
} catch (e) {
t.crash(name, util.format('%s\n%s', src, e.stack));
}
}
};
///////////////////////////////////////////////////////////////////////////////
// Tests: run tests from testcases.js.
///////////////////////////////////////////////////////////////////////////////
/**
* Run the simple tests in testcases.js
* @param {!T} t The test runner object.
*/
exports.testTestcases = function(t) {
for (const tc of testcases) {
if (!('expected' in tc)) {
t.skip(tc.name);
continue;
}
if (tc.destructive) {
const testOptions = tc.options ? {options: tc.options} : {};
runTest(t, tc.name || tc.src, tc.src, tc.expected, testOptions);
} else {
const oldOptions = interpreter.options;
if (tc.options) interpreter.options = tc.options;
runSimpleTest(t, tc.name || tc.src, tc.src, tc.expected);
if (tc.options) interpreter.options = oldOptions;
}
}
};
///////////////////////////////////////////////////////////////////////////////
// Tests: interpreter internals
///////////////////////////////////////////////////////////////////////////////
/**
* Run some tests of switch statement with fallthrough.
* @param {!T} t The test runner object.
*/
exports.testSwitchStatementFallthrough = function(t) {
const code = `
var x = '';
switch (i) {
case 1:
x += '1';
// fall through
case 2:
x += '2';
// fall through
default:
x += 'D';
// fall through
case 3:
x += '3';
// fall through
case 4:
x += '4';
// fall through
}
x;`;
const expected = ['D34', '12D34', '2D34', '34', '4'];
for (let i = 0; i < expected.length; i++) {
const src = 'var i = ' + i + ';\n' + code;
runSimpleTest(t, 'switch fallthrough ' + i, src, expected[i]);
}
};
/**
* Run some tests of switch statement completion values.
* @param {!T} t The test runner object.
*/
exports.testSwitchStatementBreaks = function(t) {
const code = `
foo: {
switch (i) {
case 1:
10;
// fall through
case 2:
20;
break;
default:
50;
// fall through
case 3:
30;
break foo;
case 4:
40;
}
}`;
const expected = [30, 20, 20, 30, 40];
for (let i = 0; i < expected.length; i++) {
const src = 'var i = ' + i + ';\n' + code;
runSimpleTest(t, 'switch completion ' + i, src, expected[i]);
}
};
/**
* Run some tests of evaluation of binary expressions, as defined in
* §11.5--11.11 of the ES5.1 spec.
* @param {!T} t The test runner object.
*/
exports.testBinaryOp = function(t) {
const cases = [
// Addition / concatenation:
["1 + 1", 2],
["'1' + 1", '11'],
["1 + '1'", '11'],
// Subtraction:
["'1' - 1", 0],
// Multiplication:
["'5' * '5'", 25],
["-5 * 0", -0],
["-5 * -0", 0],
["1 * NaN", NaN],
["Infinity * NaN", NaN],
["-Infinity * NaN", NaN],
["Infinity * Infinity", Infinity],
["Infinity * -Infinity", -Infinity],
["-Infinity * -Infinity", Infinity],
["-Infinity * Infinity", -Infinity],
// FIXME: add overflow/underflow cases
// Division:
["35 / '7'", 5],
["1 / 1", 1],
["1 / -1", -1],
["-1 / -1", 1],
["-1 / 1", -1],
["1 / NaN", NaN],
["NaN / NaN", NaN],
["NaN / 1", NaN],
["Infinity / Infinity", NaN],
["Infinity / -Infinity", NaN],
["-Infinity / -Infinity", NaN],
["-Infinity / Infinity", NaN],
["Infinity / 0", Infinity],
["Infinity / -0", -Infinity],
["-Infinity / -0", Infinity],
["-Infinity / 0", -Infinity],
["Infinity / 1", Infinity],
["Infinity / -1", -Infinity],
["-Infinity / -1", Infinity],
["-Infinity / 1", -Infinity],
["1 / Infinity", 0],
["1 / -Infinity", -0],
["-1 / -Infinity", 0],
["-1 / Infinity", -0],
["0 / 0", NaN],
["0 / -0", NaN],
["-0 / -0", NaN],
["-0 / 0", NaN],
["1 / 0", Infinity],
["1 / -0", -Infinity],
["-1 / -0", Infinity],
["-1 / 0", -Infinity],
// FIXME: add overflow/underflow cases
// Remainder:
["20 % 5.5", 3.5],
["20 % -5.5", 3.5],
["-20 % -5.5", -3.5],
["-20 % 5.5", -3.5],
["1 % NaN", NaN],
["NaN % NaN", NaN],
["NaN % 1", NaN],
["Infinity % 1", NaN],
["-Infinity % 1", NaN],
["1 % 0", NaN],
["1 % -0", NaN],
["Infinity % 0", NaN],
["Infinity % -0", NaN],
["-Infinity % -0", NaN],
["-Infinity % 0", NaN],
["0 % 1", 0],
["-0 % 1", -0],
// FIXME: add overflow/underflow cases
// Left shift:
["10 << 2", 40],
["10 << 28", -1610612736],
["10 << 33", 20],
["10 << 34", 40],
// Signed right shift:
["10 >> 4", 0],
["10 >> 33", 5],
["10 >> 34", 2],
["-11 >> 1", -6],
["-11 >> 2", -3],
// Signed right shift:
["10 >>> 4", 0],
["10 >>> 33", 5],
["10 >>> 34", 2],
["-11 >>> 0", 0xfffffff5],
["-11 >>> 1", 0x7ffffffa],
["-11 >>> 2", 0x3ffffffd],
["4294967338 >>> 0", 42],
// Bitwise:
["0x3 | 0x5", 0x7],
["0x3 ^ 0x5", 0x6],
["0x3 & 0x5", 0x1],
["NaN | 0", 0],
["-0 | 0", 0],
["Infinity | 0", 0],
["-Infinity | 0", 0],
// Comparisons:
//
// (This is mainly about making sure that the binary operators are
// hooked up to the abstract relational comparison algorithm
// correctly; that algorithm is tested separately to make sure
// details of comparisons are correct.)
["1 < 2", true],
["2 < 2", false],
["3 < 2", false],
["1 <= 2", true],
["2 <= 2", true],
["3 <= 2", false],
["1 > 2", false],
["2 > 2", false],
["3 > 2", true],
["1 >= 2", false],
["2 >= 2", true],
["3 >= 2", true],
// (Ditto for abastract equality comparison algorithm.)
["1 == 1", true],
["2 == 1", false],
["2 == 2", true],
["1 == 2", false],
["1 == '1'", true],
["1 != 1", false],
["2 != 1", true],
["2 != 2", false],
["1 != 2", true],
["1 != '1'", false],
// (Ditto for abastract strict equality comparison algorithm.)
["1 === 1", true],
["2 === 1", false],
["2 === 2", true],
["1 === 2", false],
["1 === '1'", false],
["1 !== 1", false],
["2 !== 1", true],
["2 !== 2", false],
["1 !== 2", true],
["1 !== '1'", true],
];
for (const tc of cases) {
const src = tc[0] + ';';
runSimpleTest(t, 'BinaryExpression: ' + tc[0], src, tc[1]);
}
};
/**
* Run some tests of the Abstract Relational Comparison Algorithm, as
* defined in §11.8.5 of the ES5.1 spec and as embodied by the '<'
* operator.
* @param {!T} t The test runner object.
*/
exports.testArca = function(t) {
const cases = [
['0, NaN', undefined],
['NaN, NaN', undefined],
['NaN, 0', undefined],
['1, 1', false],
['0, -0', false],
['-0, 0', false],
['Infinity, Number.MAX_VALUE', false],
['Number.MAX_VALUE, Infinity', true],
['-Infinity, -Number.MAX_VALUE', true],
['-Number.MAX_VALUE, -Infinity', false],
['1, 2', true],
['2, 1', false],
// String comparisons:
['"", ""', false],
['"", " "', true],
['" ", ""', false],
['" ", " "', false],
['"foo", "foobar"', true],
['"foo", "bar"', false],
['"foobar", "foo"', false],
['"10", "9"', true],
['"10", 9', false],
// \ufb00 vs. \U0001f019: this test fails if we do simple
// lexicographic comparison of UTF-8 or UTF-32. The latter
// character is a larger code point and sorts later in UTF8,
// but in UTF16 it gets replaced by two surrogates, both of
// which are smaller than \uf000.
['"ff", "🀙"', false],
// Mixed:
['11, "2"', false], // Numeric
['2, "11"', true], // Numeric
['"11", "2"', true], // String
];
for (const tc of cases) {
const src = `
(function(a,b){
return ((a < b) || (a >= b)) ? (a < b) : undefined;
})(${tc[0]});`;
runSimpleTest(t, 'ARCA: ' + tc[0], src, tc[1]);
}
};
/**
* Run some tests of the Abstract Equality Comparison Algorithm and
* the Abstract Strict Equality Comparison Algorithm, as defined in
* §11.9.3 and §11.9.6 respectiveyl of the ES5.1 spec and as embodied
* by the '==' and '===' operators.
* @param {!T} t The test runner object.
*/
exports.testAeca = function(t) {
const cases = [
['false, false', true, true], // Numeric
['false, true', false, false], // Numeric
['true, true', true, true], // Numeric
['true, false', false, false], // Numeric
// Numeric comparisons:
['0, NaN', false, false],
['NaN, NaN', false, false],
['NaN, 0', false, false],
['1, 1', true, true],
['0, -0', true, true],
['-0, 0', true, true],
['Infinity, Number.MAX_VALUE', false, false],
['Number.MAX_VALUE, Infinity', false, false],
['Infinity, -Number.MAX_VALUE', false, false],
['-Number.MAX_VALUE, -Infinity', false, false],
['1, 2', false, false],
['2, 1', false, false],
// String comparisons:
['"", ""', true, true],
['"", " "', false, false],
['" ", ""', false, false],
['" ", " "', true, true],
['"foo", "foobar"', false, false],
['"foo", "bar"', false, false],
['"foobar", "foo"', false, false],
['"10", "9"', false, false],
// Null / undefined:
['undefined, undefined', true, true],
['undefined, null', true, false],
['null, null', true, true],
['null, undefined', true, false],
// Objects:
['Object.prototype, Object.prototype', true, true],
['{}, {}', false, false],
// Mixed:
['"10", 10', true, false], // Numeric
['10, "10"', true, false], // Numeric
['"10", 9', false, false], // Numeric
['"10", "9"', false, false], // String
['"10", "10"', true, true], // String
['false, 0', true, false], // Numeric
['false, 1', false, false], // Numeric
['true, 1', true, false], // Numeric
['true, 0', false, false], // Numeric
['0, false', true, false], // Numeric
['1, false', false, false], // Numeric
['1, true', true, false], // Numeric
['0, true', false, false], // Numeric
['null, false', false, false],
['null, 0', false, false],
['null, ""', false, false],
['false, null', false, false],
['0, null', false, false],
['"", null', false, false],
['{}, false', false, false],
['{}, 0', false, false],
['{}, ""', false, false],
['{}, null', false, false],
['{}, undefined', false, false],
];
for (const tc of cases) {
let src = `(function(a,b) {return a == b})(${tc[0]});`;
runSimpleTest(t, 'AECA: ' + tc[0], src, tc[1]);
src = `(function(a,b) {return a === b})(${tc[0]});`;
runSimpleTest(t, 'ASECA: ' + tc[0], src, tc[2]);
}
};
/**
* Run a test of asynchronous functions:
* @param {!T} t The test runner object.
* @suppress {visibility}
*/
exports.testAsync = function(t) {
// Function to install an async NativeFunction on new Interpreter
// instances. The function, when called, will save its
// resolve/reject callbacks and first arg in test-local variables.
let resolve, reject, arg;
function createAsync(intrp) {
intrp.global.createMutableBinding('async', new intrp.NativeFunction({
name: 'async', length: 0,
call: function(intrp, thread, state, thisVal, args) {
arg = args[0];
const rr = intrp.getResolveReject(thread, state);
resolve = rr.resolve;
reject = rr.reject;
return Interpreter.FunctionResult.Block;
}
}));
};
// Test ordinary return.
let name = 'testAsyncResolve';
let src = `
'before';
async();
'between';
async('af') + 'ter';
`;
runTest(t, name, src, 'after', {
standardInit: false, // Save time.
onCreate: createAsync,
onBlocked: (intrp) => {resolve(arg);},
});
// Test throwing an exception.
name ='testAsyncReject';
src = `
try {
'before';
async();
'after';
} catch (e) {
e;
}
`;
runTest(t, name, src, 'except', {
standardInit: false, // Save time.
onCreate: createAsync,
onBlocked: (intrp) => {reject('except');},
});
// Extra check to verify async function can't resolve/reject more
// than once without an asertion failure.
name = 'testAsyncSafetyCheck';
let ok;
src = `
async(); // Returns ok === undefined then sets ok to 'ok'.
async(); // Returns ok === 'ok' then uselessly sets ok a second time.
`;
runTest(t, name, src, 'ok', {
standardInit: false, // Save time.
onCreate: createAsync,
onBlocked: (intrp) => {
resolve(ok);
// Call reject; this is expected to blow up.
try {
reject('foo');
} catch (e) {
ok = 'ok';
}
},
});
// A test of unwind_, to make sure it unwinds and kills the correct
// thread when an async function throws.
name = 'testAsyncRejectUnwind';
const intrp = getInterpreter({noLog: ['unhandled']});
createAsync(intrp); // Install async function.
// Create cannon-fodder thread that will usually be ready to run.
const bgThread = intrp.createThreadForSrc(`
// Repeatedly suspend; every 10th time suspend for a long time.
for (var i = 1; true; i++) {
suspend((i % 10) ? 0 : 1000);
}
`).thread;
// Create thread to call async function.
const asyncThread = intrp.createThreadForSrc('async();').thread;
intrp.run();
// asyncThread has run once and blocked; bgThread has run ten times
// and is now sleeping for 1s.
// Create Error err to throw. It should have no stack to start with.
const err = new intrp.Error(intrp.ROOT, intrp.ERROR, 'sample error');
t.assert(name + ': Error has no .stack initially',
!err.has('stack', intrp.ROOT));
// Throw err.
intrp.thread_ = bgThread; // Try to trick reject into killing wrong thread.
reject(err); // Throw unhandled Error in asyncThread.
// Verify correct thread was unwound and killed.
t.assert(name + ': unwound thread stack empty',
asyncThread.stateStack_.length === 0);
t.expect(name + ': unwound thread status',
asyncThread.status, Interpreter.Thread.Status.ZOMBIE);
t.assert(name + ': background thread stack non-empty',
bgThread.stateStack_.length > 0);
t.expect(name + ': background thread status',
bgThread.status, Interpreter.Thread.Status.SLEEPING);
// Verify err has aquired a stack.
t.assert(name + ': Error has .stack after being thrown',
err.has('stack', intrp.ROOT));
const stack = err.get('stack', intrp.ROOT);
t.assert(name + ': Error .stack mentions function that threw',
stack.match(/in async/));
t.assert(name + ': Error .stack mentions call site',
stack.match(/at "async\(\);" 1:1/));
};
/**
* Run tests of the Thread constructor and the suspend(), setTimeout()
* and clearTimeout() functions.
* @param {!T} t The test runner object.
*/
exports.testThreading = function(t) {
let src = `
'before';
suspend();
'after';
`;
runTest(t, 'suspend()', src, 'after');
// Check that Threads have ids.
src = `
var t1 = new Thread(function() {});
var t2 = new Thread(function() {});
typeof t1.id === 'number' && typeof t2.id === 'number' && t1.id !== t2.id;
`;
runSimpleTest(t, '(new Thread).id', src, true);
src = `
var s = '';
new Thread(function() {s += this;}, 500, 2);
new Thread(function(x) {s += x;}, 1500, undefined, [4]);
new Thread(function() {s += '1';})
suspend(1000);
s += '3';
suspend(1000);
s += '5';
s;
`;
runTest(t, 'new Thread', src, '12345');
src = `
var current;
var thread = new Thread(function() {current = Thread.current();});
suspend();
current === thread;
`;
runTest(t, 'Thread.current()', src, true);
src = `
var result;
new Thread(function() {
result = 'OK';
Thread.kill(Thread.current());
result = 'The reports of my death are greatly exaggerated.';
});
suspend();
result;
`;
runTest(t, 'Thread.kill', src, 'OK');
src = `
'before';
suspend(10000);
'after';
`;
runTest(t, 'suspend(1000)', src, 'after');
src = `
var s = '';
setTimeout(function(x) {s += '2';}, 500);
setTimeout(function(x) {s += '4';}, 1500);
s += '1';
suspend(1000);
s += '3';
suspend(1000);
s += '5';
s;
`;
runTest(t, 'setTimeout', src, '12345');
src = `
// Should have no effect:
clearTimeout('foo');
clearTimeout(Thread.current());
var s = '';
var tid = setTimeout(function(a, b) {
s += a;
suspend();
s += b;
}, 0, '2', '4');
s += 1;
suspend();
s += '3';
clearTimeout(tid);
suspend();
s += '5';
s;
`;
runTest(t, 'clearTimeout', src, '1235');
};
/**
* Run tests of the Thread time-limit mechanism.
* @param {!T} t The test runner object.
*/
exports.testTimeLimit = function(t) {
// Some constants used by several tests in this section. It should
// be the case that a for loop executing the specified number of
// iterations will take longer than the specified time limit, even
// if the body of the loop is empty.
//
// Ideally these should be very small values to ensure the tests
// run quickly, but in practice random delays (OS-level time
// slicing, GC and JIT delays, etc.) make make tests very flaky if
// these values are too small.
const iterations = 10000;
const timeLimit = 5; // in ms.
// First check that a sufficiently slow loop will get timed out.
// (This also verifies the requirements on the iterations and
// timeLimit constants mentioned above.)
let name = 'Thread hits timeLimit';
let src = `
try {
for (var i = 0; i < ${iterations}; i++) {
}
"Thread didn't time out"; // Maybe increase iterations?
} catch (e) {
e.name + ': ' + e.message; // Can't call String(e): we're out of time!
}
`;
runTest(t, name, src, 'RangeError: Thread ran too long', {
onCreateThread: (intrp, thread) => {thread.timeLimit = timeLimit;},
});
// Now check that calling suspend() regularly will save the thread
// from timing out.
name = 'Thread can use suspend to avoid timeLimit';
src = `
try {
for (var i = 0; i < ${iterations}; i++) {
suspend();
}
"Thread didn't time out";
} catch (e) {
e.name + ': ' + e.message; // Can't call String(e): we're out of time!
}
`;
runTest(t, name, src, "Thread didn't time out", {
onCreateThread: (intrp, thread) => {thread.timeLimit = timeLimit;},
});
// Test we can't call anything after timing out.
name = "Thread can't call after timeout";
src = `
try {
try {
for (var i = 0; i < ${iterations}; i++) {
}
"Thread didn't time out"; // Maybe increase iterations?
} catch (e) {
String(e);
'Still able to call';
}
} catch (e) {
e.name + ': ' + e.message; // Can't call String(e): we're out of time!
}
`;
runTest(t, name, src, 'RangeError: Thread ran too long', {
onCreateThread: (intrp, thread) => {thread.timeLimit = timeLimit;},
});
// Test we can't call anything after timing out.
name = "Thread can call suspend after timeout";
src = `
try {
try {
for (var i = 0; i < ${iterations}; i++) {
}
"Thread didn't time out"; // Maybe increase iterations?
} catch (e) {
suspend();
'Still able to call suspend';
}
} catch (e) {
e.name + ': ' + e.message; // Can't call String(e): we're out of time!
}
`;
runTest(t, name, src, 'Still able to call suspend', {
onCreateThread: (intrp, thread) => {thread.timeLimit = timeLimit;},
});
// Test timeLimit is inherited by child Threads.
name = 'Threads inherit timeLimit from parent Thread';
src = `
var r;
setTimeout(function() {
try {
for (var i = 0; i < ${iterations}; i++) {
}
r = "Thread didn't time out"; // Maybe increase iterations?
} catch (e) {
r = e.name + ': ' + e.message; // Can't call String(e).
}
});
suspend(1000000); // Fortunately simulated time passes really quickly.
r;
`;
runTest(t, name, src, 'RangeError: Thread ran too long', {
onCreateThread: (intrp, thread) => {thread.timeLimit = timeLimit;},
});
};
/**
* Run a test of the .start() and .pause() methods on Interpreter
* instances. This is an async test because we use real (albeit
* small) timeouts to make sure everything works as it ought to.
* @param {!T} t The test runner object.
*/
exports.testStartStop = async function(t) {
function snooze(ms) {
return new Promise(function(resolve, reject) {setTimeout(resolve, ms);});
}
const intrp = getInterpreter();
let name = 'testStart';
let src = `
var x = 0;
while (true) {
suspend(10);
x++;
};
`;
try {
// Garbage collection occuring during test can case flakiness.
gc();
intrp.start();
// .start() will create a zero-delay timeout to check for sleeping
// tasks to awaken. Snooze briefly to allow it to run, after
// which there should be no outstanding timeouts. This will
// ensure that we verify .createThreadForSrc() frobs .start() to get
// things going again.
await snooze(0);
intrp.createThreadForSrc(src);
await snooze(29);
intrp.pause();
} catch (e) {
t.crash(name, util.format('%s\n%s', src, e.stack));
return;
} finally {
intrp.stop();
}
let r = intrp.getValueFromScope(intrp.global, 'x');
const expected = 2;
t.expect(name, r, 2, src + '\n(after 29ms)');
// Check that .pause() actually paused execution.
name = 'testPause';
await snooze(10);
r = intrp.getValueFromScope(intrp.global, 'x');
t.expect(name, r, expected, src + '\n(after 39ms)');
};
///////////////////////////////////////////////////////////////////////////////
// Tests: builtins
///////////////////////////////////////////////////////////////////////////////
/**
* Run some tests of the various constructors and their associated
* literals and prototype objects.
* @param {!T} t The test runner object.
*/
exports.testClasses = function(t) {
const classes = {
Object: {
prototypeProto: 'null',
literal: '{}'
},
Function: {
prototypeType: 'function',
literal: 'function(){}'
},
Array: {
literal: '[]'
},
RegExp: {
prototypeClass: 'Object', // Was 'RegExp' in ES5.1.
literal: '/foo/'
},
Date: {
prototypeClass: 'Object', // Was 'RegExp' in ES5.1.
functionNotConstructor: true // Date() doesn't construct.
},
Error: {},
EvalError: {
prototypeProto: 'Error.prototype',
class: 'Error'
},
RangeError: {
prototypeProto: 'Error.prototype',
class: 'Error'
},
ReferenceError: {
prototypeProto: 'Error.prototype',
class: 'Error'
},
SyntaxError: {
prototypeProto: 'Error.prototype',
class: 'Error'
},
TypeError: {
prototypeProto: 'Error.prototype',
class: 'Error'
},
URIError: {
prototypeProto: 'Error.prototype',
class: 'Error'
},
PermissionError: {
prototypeProto: 'Error.prototype',
class: 'Error'
},
Boolean: {
literal: 'false',
literalType: 'boolean',
noInstance: true,
},
Number: {
literal: '42',
literalType: 'number',
noInstance: true,
},
String: {
literal: '"hello"',
literalType: 'string',
noInstance: true,
},
WeakMap: {
prototypeClass: 'Object',
functionNotConstructor: true // WeakMap() can't be called without new.
},
};
for (const c in classes) {
const tc = classes[c];
// Check constructor is a function:
let name = c + 'IsFunction';
let src = 'typeof ' + c + ';';
runSimpleTest(t, name, src, 'function');
// Check constructor's proto is Function.prototype
name = c + 'ProtoIsFunctionPrototype';
src = 'Object.getPrototypeOf(' + c + ') === Function.prototype;';
runSimpleTest(t, name, src, true);
// Check prototype is of correct type:
const prototypeType = (tc.prototypeType || 'object');
name = c + 'PrototypeIs' + prototypeType;
src = 'typeof ' + c + '.prototype;';
runSimpleTest(t, name, src, prototypeType);
// Check prototype has correct class:
const prototypeClass = (tc.prototypeClass || tc.class || c);
name = c + 'PrototypeClassIs' + prototypeClass;
src = 'Object.prototype.toString.apply(' + c + '.prototype);';
runSimpleTest(t, name, src, '[object ' + prototypeClass + ']');
// Check prototype has correct proto:
const prototypeProto = (tc.prototypeProto || 'Object.prototype');
name = c + 'PrototypeProtoIs' + prototypeProto;
src = 'Object.getPrototypeOf(' + c + '.prototype) === ' +
prototypeProto + ';';
runSimpleTest(t, name, src, true);
// Check prototype's .constructor is constructor:
name = c + 'PrototypeConstructorIs' + c;
src = c + '.prototype.constructor === ' + c + ';';
runSimpleTest(t, name, src, true);
const cls = tc.class || c;
if (!tc.noInstance) {
// Check instance's type:
name = c + 'InstanceIs' + prototypeType;
src = 'typeof (new ' + c + ');';
runSimpleTest(t, name, src, prototypeType);
// Check instance's proto:
name = c + 'InstancePrototypeIs' + c + 'Prototype';
src = 'Object.getPrototypeOf(new ' + c + ') === ' + c + '.prototype;';
runSimpleTest(t, name, src, true);
// Check instance's class:
name = c + 'InstanceClassIs' + cls;
src = 'Object.prototype.toString.apply(new ' + c + ');';
runSimpleTest(t, name, src, '[object ' + cls + ']');
// Check instance is instanceof its contructor:
name = c + 'InstanceIsInstanceof' + c;
src = '(new ' + c + ') instanceof ' + c + ';';
runSimpleTest(t, name, src, true);
if (!tc.functionNotConstructor) {
// Recheck instances when constructor called as function:
// Recheck instance's type:
name = c + 'ReturnIs' + prototypeType;
src = 'typeof ' + c + '();';
runSimpleTest(t, name, src, prototypeType);
// Recheck instance's proto:
name = c + 'ReturnPrototypeIs' + c + 'Prototype';
src = 'Object.getPrototypeOf(' + c + '()) === ' + c + '.prototype;';
runSimpleTest(t, name, src, true);
// Recheck instance's class:
name = c + 'ReturnClassIs' + cls;
src = 'Object.prototype.toString.apply(' + c + '());';
runSimpleTest(t, name, src, '[object ' + cls + ']');
// Recheck instance is instanceof its contructor:
name = c + 'ReturnIsInstanceof' + c;
src = c + '() instanceof ' + c + ';';
runSimpleTest(t, name, src, true);
}
}
if (tc.literal) {
// Check literal's type:
const literalType = (tc.literalType || prototypeType);
name = c + 'LiteralIs' + literalType;
src = 'typeof (' + tc.literal + ');';
runSimpleTest(t, name, src, literalType);
// Check literal's proto:
name = c + 'LiteralPrototypeIs' + c + 'Prototype';
src = 'Object.getPrototypeOf(' + tc.literal + ') === ' + c +
'.prototype;';
runSimpleTest(t, name, src, true);
// Check literal's class:
name = c + 'LiteralClassIs' + cls;
src = 'Object.prototype.toString.apply(' + tc.literal + ');';
runSimpleTest(t, name, src, '[object ' + cls + ']');
// Primitives can never be instances.
if (literalType === 'object' || literalType === 'function') {
// Check literal is instanceof its contructor.
name = c + 'LiteralIsInstanceof' + c;
src = '(' + tc.literal + ') instanceof ' + c + ';';
runSimpleTest(t, name, src, true);
}
}
}
};
/**
* Run a test of multiple simultaneous calls to Array.prototype.join.
* @param {!T} t The test runner object.
*/
exports.testArrayPrototypeJoinParallelism = function(t) {
let src = `
// Make String() do a suspend(), to tend to cause multiple
// simultaneous .join() calls become badly interleved with each
// other.
String = function(value) {
suspend();
return (new 'String')(value); // Call original.
};
var arr = [1, [2, [3, [4, 5]]]];
// Set up another Array.prototype.join traversing a subset of
// the same objects to screw with us.
new Thread(function() {arr[1].join();});
// Try to do the join anyway.
arr.join()
`;
runTest(t, 'Array.prototype.join parallel', src, '1,2,3,4,5');
};
/**
* Run some tests of Number.toString(radix) with various different
* radix arguments.
* @param {!T} t The test runner object.
*/
exports.testNumberToString = function(t) {
const cases = [
['(42).toString()', '42'],
['(42).toString(16)', '2a'],
//['(-42.4).toString(5)', '-132.2'], Node incorrectly reports '-132.144444'.
['(42).toString("2")', '101010'],
['(-3.14).toString()', '-3.14'],
['(999999999999999999999999999).toString()', '1e+27'],
['(NaN).toString()', 'NaN'],
['(Infinity).toString()', 'Infinity'],
['(-Infinity).toString()', '-Infinity'],
];
for (const tc of cases) {
const src = tc[0] + ';';
runSimpleTest(t, 'testNumberToString: ' + tc[0], src, tc[1]);
}
};
/**
* Run tests of the server side of the networking subsystem
* (connectionListen et al.)
* @param {!T} t The test runner object.
*/
exports.testServing = async function(t) {
// Run a test of connectionListen() and connectionUnlisten(), and
// of the server receiving data using the .receive and .end methods
// on a connection object.
let name = 'testServerInbound';
let src = `
var data = '', conn = {};
conn.onReceive = function(d) {
data += d;
};
conn.onEnd = function() {
CC.connectionClose(this);
CC.connectionUnlisten(8888);
resolve(data);
};
CC.connectionListen(8888, conn);
send();
`;
function createSend(intrp) {
intrp.global.createMutableBinding('send', intrp.createNativeFunction(
'send', function() {
// Send some data to server.
const client = net.createConnection({port: 8888}, function() {
client.write('foo');
client.write('bar');
client.end();
});
}));
};
await runAsyncTest(t, name, src, 'foobar', {
options: {noLog: ['net']},
onCreate: createSend
});
// Run a test of the connectionListen(), connectionUnlisten(),
// connectionWrite() and connectionClose functions.
name = 'testServerOutbound';
src = `
var conn = {};
conn.onConnect = function() {
CC.connectionWrite(this, 'foo');
CC.connectionWrite(this, 'bar');
CC.connectionClose(this);
};
CC.connectionListen(8888, conn);
resolve(receive());
CC.connectionUnlisten(8888);
`;
function createReceive(intrp) {
intrp.global.createMutableBinding('receive', new intrp.NativeFunction({
name: 'receive', length: 0,
call: function(intrp, thread, state, thisVal, args) {
let reply = '';
const rr = intrp.getResolveReject(thread, state);
// Receive some data from the server.
const client = net.createConnection({port: 8888}, function() {
client.on('data', function(data) {
reply += data;
});
client.on('end', function() {
rr.resolve(reply);
});
client.on('error', function() {
rr.reject();
});
});
return Interpreter.FunctionResult.Block;
}
}));
};
await runAsyncTest(t, name, src, 'foobar', {
options: {noLog: ['net']},
onCreate: createReceive,
});
// Check to make sure that connectionListen() throws if attempting
// to bind to an invalid port or rebind a port already in use.
name = 'testConnectionListenThrows';
const server = new net.Server();
server.listen(8887);
src = `
// Some invalid ports:
// * 8887 is in use by the above net.Server.
// * 8888 will be in-use by via previous connectionListen.
// * Others are not integers or are out-of-range.
var ports = ['foo', {}, -1, 80.8, 8887, 8888, 65536];
try {
CC.connectionListen(8888, {});
for (var i = 0; i < ports.length; i++) {
try {
CC.connectionListen(ports[i], {});
resolve('Unexpected success listening on port ' + ports[i]);
} catch (e) {
if (!(e instanceof Error)) {
resolve('threw non-Error value ' + String(e));
}
}
}
} finally {
CC.connectionUnlisten(8888);
}
resolve('OK');
`;
await runAsyncTest(t, name, src, 'OK', {options: {noLog: ['net']}});
server.close();
// Check to make sure that connectionUnlisten() throws if attempting
// to unbind an invalid or not / no longer bound port.
name = 'testConnectionUnlistenThrows';
src = `
var ports = ['foo', {}, -1, 22, 80.8, 4567, 8888, 65536];
CC.connectionListen(8888, {});
CC.connectionUnlisten(8888, {});
for (var i = 0; i < ports.length; i++) {
try {
CC.connectionUnlisten(ports[i], {});
resolve('Unexpected success unlistening on port ' + ports[i]);
} catch (e) {
if (!(e instanceof Error)) {
resolve('threw non-Error value ' + String(e));
}
}
}
resolve('OK');
`;
await runAsyncTest(t, name, src, 'OK', {options: {noLog: ['net']}});
// Check to make sure that connectionWrite() throws if attempting to
// write anything not a string or to anything not a connected
// object.
name = 'testConnectionWriteThrows';
src = `
var conn = {toString: function() {return 'an open connection';}};
conn.onConnect = function() {
var cases = [
{obj: undefined, data: 'fine'},
{obj: null, data: 'fine'},
{obj: 42, data: 'fine'},
{obj: true, data: 'fine'},
{obj: 'a string', data: 'fine'},
{obj: {/* not connected */}, data: 'fine'},
{obj: this, data: undefined},
{obj: this, data: null},
{obj: this, data: 42},
{obj: this, data: true},
{obj: this, data: {}},
];
for (var tc, i = 0; (tc = cases[i]); i++) {
try {
CC.connectionWrite(tc.obj, tc.data);
resolve('Unexpected success writing ' + tc.data +
' to ' + String(tc.obj));
} catch (e) {
if (!(e instanceof TypeError)) {
resolve('threw non-TypeError value ' + String(e));
}
}
}
CC.connectionClose(this);
resolve('OK');
};
CC.connectionListen(8888, conn);
try {
receive();
} finally {
CC.connectionUnlisten(8888);
}
`;
await runAsyncTest(t, name, src, 'OK', {
options: {noLog: ['net']},
onCreate: createReceive,
});
// Run a test to make sure listening sockets survive the interpreter
// being paused and restarted.
name = 'testServerPauseStart';
src = `
var data = '', conn = {};
conn.onReceive = function(d) {
data += d;
};
conn.onEnd = function() {
CC.connectionClose(this);
CC.connectionUnlisten(8888);
resolve(data);
};
CC.connectionListen(8888, conn);
pause();
send();
`;
function createPauseAndSend(intrp) {
intrp.global.createMutableBinding('pause', intrp.createNativeFunction(
'pause', function() {
intrp.pause();
intrp.start();
}));
createSend(intrp);
};
await runAsyncTest(t, name, src, 'foobar', {
options: {noLog: ['net']},
onCreate: createPauseAndSend
});
// Run a test to make sure listening sockets are re-listened after
// the interpreter is stopped and restarted.
name = 'testServerStopStart';
src = `
var data = '', conn = {};
conn.onReceive = function(d) {
data += d;
};
conn.onEnd = function() {
CC.connectionClose(this);
CC.connectionUnlisten(8888);
resolve(data);
};
CC.connectionListen(8888, conn);
stop();
send();
`;
function createStopAndSend(intrp) {
intrp.global.createMutableBinding('stop', intrp.createNativeFunction(
'stop', function() {
intrp.stop();
intrp.start();
}));
createSend(intrp);
};
await runAsyncTest(t, name, src, 'foobar', {
options: {noLog: ['net']},
onCreate: createStopAndSend
});
};
/**
* Run tests of the client side of the networking subsystem (xhr).
* @param {!T} t The test runner object.
*/
exports.testClient = async function(t) {
// Run test of the xhr() function using HTTP.
let name = 'testXhrHttp';
const httpTestServer = http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'text/plain'});
res.end('OK HTTP: ' + req.url);
}).listen(9980);
let src = `
try {
resolve(CC.xhr('http://localhost:9980/foo'));
} catch (e) {
reject(e);
}
`;
await runAsyncTest(t, name, src, 'OK HTTP: /foo',
{options: {noLog: ['net']}});
httpTestServer.close();
// Run test of the xhr() function using HTTPS.
// TODO(cpcallen): Don't depend on external webserver.
name = 'testXhr';
src = `
try {
resolve(CC.xhr('https://neil.fraser.name/software/JS-Interpreter/' +
'demos/async.txt'));
} catch (e) {
reject(e);
}
`;
await runAsyncTest(t, name, src, 'It worked!\n', {options: {noLog: ['net']}});
};
================================================
FILE: server/tests/interpreter_unit_test.js
================================================
/**
* @license
* Copyright 2018 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Unit tests for internal functions of JavaScript interpreter.
* @author cpcallen@google.com (Christopher Allen)
*/
'use strict';
const util = require('util');
const Interpreter = require('../interpreter');
const {T} = require('./testing');
/**
* Unit tests for Interpreter.toInteger, .toLength. and .toUint32
* @param {!T} t The test runner object.
*/
exports.testToIntegerEtc = function(t) {
const intrp = new Interpreter;
const cases = [
// [value, ToInteger(value), ToLength(value), ToUint32(value)]
[false, 0, 0, 0],
[true, 1, 1, 1],
[0, 0, 0, 0],
[-0, -0, 0, 0],
[1, 1, 1, 1],
[-1, -1, 0, 0xffffffff],
[0xfffffffe, 0xfffffffe, 0xfffffffe, 0xfffffffe],
[0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff],
[0x100000000, 0x100000000, 0x100000000, 0],
[4.5, 4, 4, 4],
[2**53-1, 2**53-1, 2**53-1, 0xffffffff],
[2**53, 2**53, 2**53-1, 0],
[Infinity, Infinity, 2**53-1, 0],
[-Infinity, -Infinity, 0, 0],
[NaN, 0, 0, 0],
['0', 0, 0, 0],
['-0', -0, 0, 0],
['1', 1, 1, 1],
['-1', -1, 0, 0xffffffff],
['0xfffffffe', 0xfffffffe, 0xfffffffe, 0xfffffffe],
['0xffffffff', 0xffffffff, 0xffffffff, 0xffffffff],
['0x100000000', 0x100000000, 0x100000000, 0],
['4294967294', 0xfffffffe, 0xfffffffe, 0xfffffffe],
['4294967295', 0xffffffff, 0xffffffff, 0xffffffff],
['4294967296', 0x100000000, 0x100000000, 0],
['4.5', 4, 4, 4],
['9007199254740991', 2**53-1, 2**53-1, 0xffffffff],
['9007199254740992', 2**53, 2**53-1, 0],
['hello', 0, 0, 0],
[null, 0, 0, 0],
[undefined, 0, 0, 0],
[new intrp.Array, 0, 0, 0],
[new intrp.Object, 0, 0, 0],
];
const funcs =
[Interpreter.toInteger, Interpreter.toLength, Interpreter.toUint32];
for (const [input, ...expected] of cases) {
for (let i = 0; i < funcs.length; i++) {
const name = util.format('%s(%o)', funcs[i].name, input);
t.expect(name, funcs[i](input), expected[i]);
}
}
};
/**
* Unit tests for Interpreter.prototype.nativeToPseudo.
* @param {!T} t The test runner object.
*/
exports.testNativeToPseudo = function(t) {
const intrp = new Interpreter;
// Test handling of Arrays (including extra non-index properties).
const props = {0: 0, 1: 1, 2: 2, length: 3, extra: 4};
const arr = [];
for (const k in props) {
if (!props.hasOwnProperty(k)) continue;
arr[/** @type{?} */(k)] = props[k];
}
const pArr = intrp.nativeToPseudo(arr, intrp.ROOT);
for (const k in props) {
if (!props.hasOwnProperty(k)) continue;
const name = 'testNativeToPseudo(array)["' + k + '"]';
const r = pArr.get(k, intrp.ROOT);
t.expect(name, r, props[k]);
}
// Test handling of Errors.
const cases = [
[Error, intrp.ERROR],
[EvalError, intrp.EVAL_ERROR],
[RangeError, intrp.RANGE_ERROR],
[ReferenceError, intrp.REFERENCE_ERROR],
[SyntaxError, intrp.SYNTAX_ERROR],
[TypeError, intrp.TYPE_ERROR],
[URIError, intrp.URI_ERROR],
];
for (const [Err, proto] of cases) {
const name = 'testNativeToPseudo(' + Err.prototype.name + ')';
const errMessage = 'test ' + Err.prototype.name;
const error = Err(errMessage);
const pError = intrp.nativeToPseudo(error, intrp.ROOT);
t.expect(name + ' instanceof intrp.Error',
pError instanceof intrp.Error, true);
t.expect(name + '.proto', pError.proto, proto);
t.expect(name + '.message', pError.get('message', intrp.ROOT), errMessage);
t.expect(name + '.stack', pError.get('stack', intrp.ROOT), error.stack);
}
};
/**
* Unit tests for Interpreter.Scope class.
* @param {!T} t The test runner object.
*/
exports.testScope = function(t) {
const intrp = new Interpreter;
const outer = new Interpreter.Scope(
Interpreter.Scope.Type.DUMMY, intrp.ROOT, null, 'this');
const inner = new Interpreter.Scope(
Interpreter.Scope.Type.DUMMY, intrp.ROOT, outer);
// 0: Initial condition.
t.expect("outer.this // 0", outer.this, 'this');
t.expect("inner.this // 0", inner.this, 'this');
t.expect("outer.hasBinding('foo') // 0", outer.hasBinding('foo'), false);
t.expect("outer.resolve('foo') // 0", outer.resolve('foo'), null);
t.expect("inner.resolve('foo') // 0", inner.resolve('foo'), null);
// 1: Create outer binding.
outer.createMutableBinding('foo', 42);
t.expect("outer.hasBinding('foo') // 1", outer.hasBinding('foo'), true);
t.expect("inner.hasBinding('foo') // 1", inner.hasBinding('foo'), false);
t.expect("outer.resolve('foo') // 1", outer.resolve('foo'), outer);
t.expect("inner.resolve('foo') // 1", inner.resolve('foo'), outer);
t.expect("outer.get('foo') // 1", outer.get('foo'), 42);
t.expect("getValueFromScope(outer, 'foo', ...) // 1",
intrp.getValueFromScope(outer, 'foo'), 42);
t.expect("getValueFromScope(inner, 'foo', ...) // 1",
intrp.getValueFromScope(inner, 'foo'), 42);
try {
outer.createMutableBinding('foo', 42);
t.fail("outer.createMutableBinding('foo', ...) // 1", "Didn't throw.");
} catch (e) {
t.pass("outer.createMutableBinding('foo', ...) // 1");
}
// 2: Set outer binding.
outer.set('foo', 69);
t.expect("outer.get('foo') // 2", outer.get('foo'), 69);
t.expect("getValueFromScope(inner, 'foo', ...) // 2",
intrp.getValueFromScope(inner, 'foo'), 69);
t.expect("getValueFromScope(outer, 'foo', ...) // 2",
intrp.getValueFromScope(outer, 'foo'), 69);
// 3: Create inner binding.
inner.createImmutableBinding('foo', 105);
t.expect("outer.hasBinding('foo') // 3", outer.hasBinding('foo'), true);
t.expect("inner.hasBinding('foo') // 3", inner.hasBinding('foo'), true);
t.expect("outer.resolve('foo') // 3", outer.resolve('foo'), outer);
t.expect("inner.resolve('foo') // 3", inner.resolve('foo'), inner);
t.expect("outer.get('foo') // 3", outer.get('foo'), 69);
t.expect("inner.get('foo') // 3", inner.get('foo'), 105);
t.expect("getValueFromScope(inner, 'foo', ...) // 3",
intrp.getValueFromScope(inner, 'foo'), 105);
t.expect("getValueFromScope(outer, 'foo', ...) // 3",
intrp.getValueFromScope(outer, 'foo'), 69);
// 4: Try to create duplicate binding.
try {
outer.createMutableBinding('foo', 17);
t.fail("outer.createMutableBinding('foo', ...) // 4", "Didn't throw.");
} catch (e) {
t.pass("outer.createMutableBinding('foo', ...) // 4");
}
// 5: Try to set immutable binding (two different ways)
t.assert("inner.set('foo', 37) instanceof TypeError",
inner.set('foo', 37) instanceof TypeError);
try {
intrp.setValueToScope(inner, 'foo', 37);
t.fail("setValueToScope(inner, 'foo', 37, ...) // 5", "Didn't throw.");
} catch (e) {
t.pass("setValueToScope(inner, 'foo', 37, ...) // 5");
}
};
/**
* Unit tests for Interpreter.Source class.
* @param {!T} t The test runner object.
*/
exports.testSource = function(t) {
let src = new Interpreter.Source('ABCDEF');
let name = "Source('ABCDEF')";
src = src.slice(0, 6);
t.expect(name + '.toString()', String(src), 'ABCDEF');
src = src.slice(1, 5);
name += '.slice(1, 5)';
t.expect(name + '.toString()', String(src), 'BCDE');
src = src.slice(2, 4);
name += '.slice(2, 4)';
t.expect(name + '.toString()', String(src), 'CD');
const s = '1\n.2\n..3\n.4\n5\n';
const pos3 = s.indexOf('3');
src = new Interpreter.Source(s);
name = util.format('Source(%o)', s);
let lc = src.lineColForPos(pos3);
t.expect(name + '.lineColForPos(' + pos3 + ').line', lc.line, 3);
t.expect(name + '.lineColForPos(' + pos3 + ').col', lc.col, 3);
src = src.slice(2, 12);
name += '.slice(2, 12)';
lc = src.lineColForPos(pos3);
t.expect(name + '.lineColForPos(' + pos3 + ').line', lc.line, 2);
t.expect(name + '.lineColForPos(' + pos3 + ').col', lc.col, 3);
src = src.slice(2, 12);
name += '.slice(2, 12)';
lc = src.lineColForPos(pos3);
t.expect(name + '.toString()', String(src), '.2\n..3\n.4\n');
t.expect(name + '.lineColForPos(' + pos3 + ').line', lc.line, 2);
t.expect(name + '.lineColForPos(' + pos3 + ').col', lc.col, 3);
src = new Interpreter.Source('startBound').slice(0, 5).slice(0, 0);
name = "Source('startBound').slice(0, 5).slice(0, 0)";
lc = src.lineColForPos(0);
t.expect(name + '.lineColForPos(0).line', lc.line, 1);
t.expect(name + '.lineColForPos(0).col', lc.line, 1);
t.expect(name + '.toString()', String(src), '');
src = new Interpreter.Source('endBound').slice(3, 8).slice(8, 8);
name = "Source('endBound').slice(3, 8).slice(8, 8)";
lc = src.lineColForPos(8);
t.expect(name + '.lineColForPos(8).line', lc.line, 1);
t.expect(name + '.lineColForPos(8).col', lc.line, 1);
t.expect(name + '.toString()', String(src), '');
};
================================================
FILE: server/tests/iterable_weakmap_test.js
================================================
/**
* @license
* Copyright 2018 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Test for IterableWeakMap.
* @author cpcallen@google.com (Christopher Allen)
*/
'use strict';
const util = require('util');
const IterableWeakMap = require('../iterable_weakmap');
const {T} = require('./testing');
/**
* Request garbage collection and cycle the event loop to give
* finalisers a chance to be run. No guarantees about either,
* unfortunately.
* @return {!Promise}
*/
async function gcAndFinalise() {
// Cycle event loop to allow finalisers to run. Need to cycle it
// once before GC to ensure that WeakRefs can be cleared (their
// targets can never be cleared in the same turn as the WeakRef was
// created), then again after to allow finalisers to run.
await new Promise((res, rej) => setImmediate(res));
gc();
await new Promise((res, rej) => setImmediate(res));
}
/**
* Run some basic tests of IterableWeakMap.
* @param {!T} t The test runner object.
*/
exports.testIterableWeakMap = async function(t) {
const name = 'IterableWeakMap';
const assertSame = function(got, want, desc) {
t.expect(name + ': ' + desc, got, want);
};
assertSame(IterableWeakMap.prototype[Symbol.iterator],
IterableWeakMap.prototype.entries,
'prototype[Symbol.iterator] and prototype.entries are the same method');
const obj1 = {};
const obj2 = {};
const iwm = new IterableWeakMap([[obj1, 42], [obj2, 69]]);
(() => {
// Sequester obj3 in an IIFE, because just doing tmp = undefined
// to allow the object to be garbage collected seems to be
// insufficient. (Presumably V8 optimises the assignment away.)
const obj3 = {};
assertSame(iwm.set(obj3, 105), iwm, 'iwm.set(tmp, 105)');
assertSame(iwm.get(obj3), 105, 'iwm.get(tmp)');
assertSame(Array.from(iwm.values()).reduce((x, y) => x + y), 42 + 69 + 105,
'sum of .values()');
let count = 0;
let sum = 0;
iwm.forEach((v, k, m) => {
assertSame(m, iwm, 'Map param in iwm.forEach callback');
count++;
sum += v;
});
assertSame(count, 3, 'Iterations in iwm.forEach callback');
assertSame(sum, 42 + 69 + 105, 'Sum of values in iwm.forEach callback');
})();
assertSame(iwm.get(obj1), 42, 'iwm.get(obj)');
assertSame(iwm.has(obj1), true, 'iwm.has(obj)');
assertSame(iwm.has({}), false, 'iwm.has({})');
assertSame(iwm.size, 3, 'iwm.size');
await gcAndFinalise();
assertSame(iwm.has(obj1), true, 'iwm.has(obj) (after GC)');
assertSame(iwm.get(obj1), 42, 'iwm.get(obj) (after GC)');
assertSame(iwm.size, 2, 'iwm.size (after GC)');
const keys = Array.from(iwm.keys());
assertSame(keys.length, 2, 'Array.from(iwm.keys()).length');
assertSame(keys[0], obj1, 'Array.from(iwm.keys())[0]');
assertSame(keys[1], obj2, 'Array.from(iwm.keys())[1]');
assertSame(iwm.delete({}), false, 'iwm.delete({})');
assertSame(iwm.delete(obj2), true, 'iwm.delete(obj)');
assertSame(iwm.size, 1, 'iwm.size (after delete)');
const entries = Array.from(iwm);
assertSame(entries.length, 1, 'Array.from(iwm).length (after delete)');
assertSame(entries[0][0], obj1, 'Array.from(iwm)[0][0]');
assertSame(entries[0][1], 42, 'Array.from(iwm)[0][1]');
iwm.clear();
assertSame(iwm.has(obj1), false, 'iwm.has(obj) (after clear)');
assertSame(iwm.get(obj1), undefined, 'iwm.get(obj) (after clear)');
assertSame(iwm.size, 0, 'iwm.size (after clear)');
};
/**
* Test for correct handling of cyclic garbage in IterableWeakMap.
* @param {!T} t The test runner object.
*/
exports.testIterableWeakMapCyclic = async function(t) {
const iwm = new IterableWeakMap;
(() => {
const objs = [{}, {}, {}];
iwm.set(objs[0], objs[0]); // obj[0] is held circularly.
iwm.set(objs[1], objs[2]); // obj[1] and [2] are held by each other.
iwm.set(objs[2], objs[1]);
})();
t.expect('IterableWeakMapCyclic: iwm.size (before GC)', iwm.size, 3);
await gcAndFinalise();
t.expect('IterableWeakMapCyclic: iwm.size (after GC)', iwm.size, 0);
};
/**
* Test for layered collection of IterableWeakMap.
*
* When a WeakMap contains a chain of object (i.e., wm.get(o1) === o2,
* wm.get(o2) === o3, etc.) all should simultaneously be eligible for
* collection if the 'head' object becomes unreachable. This test
* will either pass (if that is true of IterableWeakMap) or issue a
* warning if it takes several GCs to entierly empty the map.
* @param {!T} t The test runner object.
*/
exports.testIterableWeakMapLayeredGC = async function(t) {
/* N.B.: This test seems to be deterministic but very sensitive to
* seemingly insignificant code changes, which can (for no obvious
* reason, but probably due to some internal optimisations) result
* in the IterableWeakMap keys not being garbage collected at all.
*
* This can be difficult to debug, because e.g. adding a console.log
* call inside the loop that calls gc() will make the problem go
* away.
*/
const name = 'IterableWeakMapLayeredGC';
const iwm = new IterableWeakMap;
// Make a chain of entries.
(() => {
const objs = [{}, {}, {}, {}, {}];
for (let i = 0; i < objs.length; i++) {
iwm.set(objs[i], objs[i + 1]);
}
})();
const limit = 10; // objs.length * 2
let count = 0;
for (; count < limit && iwm.size > 0; count++) {
await gcAndFinalise();
}
if (count >= limit) {
t.fail(name, 'Test failed to terminate in a reasonable time.');
} else if (count > 1) {
t.result('WARN', name,
'IterableWeakMap causes layered GC! (' + count + ' iterations)');
} else {
t.pass(name);
}
};
================================================
FILE: server/tests/iterable_weakset_test.js
================================================
/**
* @license
* Copyright 2018 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Test for IterableWeakSet.
* @author cpcallen@google.com (Christopher Allen)
*/
'use strict';
const util = require('util');
const IterableWeakSet = require('../iterable_weakset');
const {T} = require('./testing');
/**
* Request garbage collection and cycle the event loop to give
* finalisers a chance to be run. No guarantees about either,
* unfortunately.
* @return {!Promise}
*/
async function gcAndFinalise() {
// Cycle event loop to allow finalisers to run. Need to cycle it
// once before GC to ensure that WeakRefs can be cleared (their
// targets can never be cleared in the same turn as the WeakRef was
// created), then again after to allow finalisers to run.
await new Promise((res, rej) => setImmediate(res));
gc();
await new Promise((res, rej) => setImmediate(res));
}
/**
* Run some basic tests of IterableWeakSet.
* @param {!T} t The test runner object.
*/
exports.testIterableWeakSet = async function(t) {
const name = 'IterableWeakSet';
const assertSame = function(got, want, desc) {
t.expect(name + ': ' + desc, got, want);
};
assertSame(IterableWeakSet.prototype[Symbol.iterator],
IterableWeakSet.prototype.values,
'prototype[Symbol.iterator] and prototype.values are the same method');
assertSame(IterableWeakSet.prototype.keys, IterableWeakSet.prototype.values,
'prototype.keys and prototype.values are the same method');
const obj1 = {x: 42};
const obj2 = {x: 69};
const iws = new IterableWeakSet([obj1, obj2]);
(() => {
// Sequester obj3 in an IIFE, because just doing tmp = undefined
// to allow the object to be garbage collected seems to be
// insufficient. (Presumably V8 optimises the assignment away.)
const obj3 = {x: 105};
assertSame(iws.add(obj3), iws, 'iws.add(tmp)');
assertSame(iws.has(obj3), true, 'iws.has(tmp)');
assertSame(
Array.from(iws.values()).map((obj) => obj.x).toString(),
'42,69,105', '.x values from .values()');
let count = 0;
let sum = 0;
iws.forEach((v1, v2, s) => {
assertSame(v1, v2, 'value params in iws.forEach callback');
assertSame(s, iws, 'Set param in iws.forEach callback');
count++;
sum += v1.x;
});
assertSame(count, 3, 'Iterations in iws.forEach callback');
assertSame(sum, 42 + 69 + 105, 'Sum of .x values in iws.forEach callback');
})();
assertSame(iws.has(obj1), true, 'iws.has(obj)');
assertSame(iws.has({}), false, 'iws.has({})');
assertSame(iws.size, 3, 'iws.size');
await gcAndFinalise();
assertSame(iws.has(obj1), true, 'iws.has(obj) (after GC)');
assertSame(iws.size, 2, 'iws.size (after GC)');
const keys = Array.from(iws.keys());
assertSame(keys.length, 2, 'Array.from(iws.keys()).length');
assertSame(keys[0], obj1, 'Array.from(iws.keys())[0]');
assertSame(keys[1], obj2, 'Array.from(iws.keys())[1]');
assertSame(iws.delete({}), false, 'iws.delete({})');
assertSame(iws.delete(obj2), true, 'iws.delete(obj)');
assertSame(iws.size, 1, 'iws.size (after delete)');
const values = Array.from(iws);
assertSame(values.length, 1, 'Array.from(iws).length (after delete)');
assertSame(values[0], obj1, 'Array.from(iws)[0]');
iws.clear();
assertSame(iws.has(obj1), false, 'iws.has(obj) (after clear)');
assertSame(iws.size, 0, 'iws.size (after clear)');
};
================================================
FILE: server/tests/priorityqueue_test.js
================================================
/**
* @license
* Copyright 2020 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Tests for PriorityQueue.
* @author cpcallen@google.com (Christopher Allen)
*/
'use strict';
const util = require('util');
const PriorityQueue = require('../priorityqueue').PriorityQueue;
const {T} = require('./testing');
// Unpack test-only functions.
const {parent, children} = require('../priorityqueue').testOnly;
/**
* Test the inernal parent() function.
* @param {!T} t The test runner object.
*/
exports.testParent = function(t) {
const cases = [
[0, -1],
[1, 0],
[2, 0],
[3, 1],
[4, 1],
[5, 2],
[6, 2],
];
for (const [i, expected] of cases) {
t.expect(util.format('parent(%d)', i), parent(i), expected);
};
};
/**
* Test the internal children() function.
* @param {!T} t The test runner object.
*/
exports.testChildren = function(t) {
const cases = [
[0, [1, 2]],
[1, [3, 4]],
[2, [5, 6]],
];
for (const [i, [left, right]] of cases) {
const result = children(i);
t.expect(util.format('parent(%d)[0]', i), result[0], left);
t.expect(util.format('parent(%d)[0]', i), result[1], right);
};
};
/**
* Check pq.heap_ and pq.indices_ obey their invariants.
* @param {T} t The test runner object.
* @param {!PriorityQueue} pq The PriorityQueue object to test the
* invariants of.
* @param {string=} note A textual description of the test situation.
* @suppress {accessControls}
*/
function checkInvariants(t, pq, note) {
if (note) note = ' // ' + note;
for (let i = 0; i < pq.heap_.length; i++) {
// Check heap ordering invariant.
const p = parent(i);
if (p >= 0) {
t.assert('PriorityQueue heap ordering invariant' + note,
pq.heap_[i].priority >= pq.heap_[p].priority,
util.format(
'.heap_[%d].priority === %d, .heap_[%d].priority === %d',
i, pq.heap_[i].priority, p, pq.heap_[p].priority) +
util.format('\n%o\n', pq.heap_));
}
// Check index is correct for .heap_[i].value
t.expect(util.format('PriorityQueue: .indices_.get(.heap_[%d].value)%s',
i, note),
pq.indices_.get(pq.heap_[i].value), i);
}
for (const [value, index] of pq.indices_) {
// Check value is correct for .indices_.get(v).
t.expect(util.format('PriorityQueue: .heap_[.indices_.get(%o)].value%s',
value, note),
pq.heap_[index].value, value);
}
t.expect('PriorityQueue: .heap_.length (vs. .indices_.size)' + note,
pq.heap_.length, pq.indices_.size);
};
/**
* Run some basic tests of PriorityQueue.
* @param {!T} t The test runner object.
*/
exports.testPriorityQueue = function(t) {
const name = 'PriorityQueue';
const pq = new PriorityQueue();
// Insert some values in a particular order, using value as priority.
for (const v of [2, 4, 6, 8, 10, 12, 14, 15, 13, 11, 9, 7, 5, 3, 1]) {
pq.set(v, v);
checkInvariants(t, pq, util.format('after .insert(%d, %d)', v, v));
}
// Remove three items.
for (let i = 1; i <= 3; i++) {
t.expect(name + ' .deleteMin() // ' + i, pq.deleteMin(), i);
t.expect(name + ' .length // ' + i, pq.length, 15 - i);
checkInvariants(t, pq, 'after .deleteMin #' + i);
}
// Reduce priority of 6 to 4.5.
pq.set(6, 4.5);
checkInvariants(t, pq, 'after .reducePriority(6, 4.5)');
// Remove next three items; verify order per changed priorities.
t.expect(name + ' .deleteMin() // 4', pq.deleteMin(), 4);
checkInvariants(t, pq, 'after .deleteMin #4');
t.expect(name + ' .deleteMin() // 5', pq.deleteMin(), 6);
checkInvariants(t, pq, 'after .deleteMin #5');
t.expect(name + ' .deleteMin() // 6', pq.deleteMin(), 5);
checkInvariants(t, pq, 'after .deleteMin #6');
// Remove remaining items.
for (let i = 7; i <= 15; i++) {
t.expect(name + ' .deleteMin() // ' + i, pq.deleteMin(), i);
t.expect(name + ' .length // ' + i, pq.length, 15 - i);
checkInvariants(t, pq, 'after .deleteMin #' + i);
}
};
================================================
FILE: server/tests/registry_test.js
================================================
/**
* @license
* Copyright 2018 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Unit tests for the Registry class.
* @author cpcallen@google.com (Christopher Allen)
*/
'use strict';
const Registry = require('../registry');
const {T} = require('./testing');
/**
* Unit tests for the Interpreter.Registry class.
* @param {!T} t The test runner object.
*/
exports.testRegistry = function(t) {
const reg = new Registry;
const obj = {};
// 0: Initial condition.
t.expect("reg.has('foo') // 0", reg.has('foo'), false);
try {
reg.get('foo');
t.fail("reg.get('foo') // 0", "Didn't throw.");
} catch(e) {
t.pass("reg.get('foo') // 0");
}
t.expect("reg.getKey(obj) // 0", reg.getKey(obj), undefined);
t.expect("reg.keys().length // 0", reg.keys().length, 0);
// 1: Register obj as 'foo'.
reg.set('foo', obj);
t.expect("reg.has('foo') // 1", reg.has('foo'), true);
t.expect("reg.get('foo') // 1", reg.get('foo'), obj);
t.expect("reg.getKey(obj) // 1", reg.getKey(obj), 'foo');
t.expect("reg.keys().length // 1", reg.keys().length, 1);
t.expect("reg.keys()[0] // 1", reg.keys()[0], 'foo');
// 2: Attempt to register another object as 'foo'.
try {
reg.set('foo', {});
t.fail("reg.set('foo', {}) // 2", "Didn't throw.");
} catch(e) {
t.pass("reg.set('foo', {}) // 2");
}
t.expect("reg.has('foo') // 2", reg.has('foo'), true);
t.expect("reg.get('foo') // 2", reg.get('foo'), obj);
t.expect("reg.getKey(obj) // 2", reg.getKey(obj), 'foo');
t.expect("reg.getKey({}) // 2", reg.getKey({}), undefined);
// 3: Attempt to register obj as 'bar'.
try {
reg.set('bar', obj);
t.fail("reg.set('bar', obj) // 3", "Didn't throw.");
} catch(e) {
t.pass("reg.set('bar', obj) // 3");
}
t.expect("reg.has('bar') // 3", reg.has('bar'), false);
t.expect("reg.getKey(obj) // 3", reg.getKey(obj), 'foo');
// Test iterators.
// TODO(cpcallen): test with more than one item to iterate over?
const keys = reg.keys();
t.expect("reg.keys().length", keys.length, 1);
t.expect("reg.keys()[0]", keys[0], 'foo');
const values = reg.values();
t.expect("reg.values().length", values.length, 1);
t.expect("reg.values()[0]", values[0], obj);
const entries = reg.entries();
t.expect("reg.entries().length", entries.length, 1);
t.expect("reg.entries()[0][0]", entries[0][0], 'foo');
t.expect("reg.entries()[0][1]", entries[0][1], obj);
};
================================================
FILE: server/tests/run
================================================
#!/bin/bash
# Run unit tests in Node.
node --expose-gc tests/run.js
# Delete any existing checkpoint files.
rm tests/db/*.city
# Start Code City the first time.
echo "Starting Code City (1 of 2)"
./codecity tests/db/test.cfg
echo "Stopped Code City (1 of 2)"
# Start Code City the second time.
echo "Starting Code City (2 of 2)"
./codecity tests/db/test.cfg
echo "Stopped Code City (2 of 2)"
================================================
FILE: server/tests/run.js
================================================
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Test runner for server tests.
* @author cpcallen@google.com (Christopher Allen)
*/
'use strict';
// Force closure-compiler to compile server and testst/benchmarks (for
// syntax/type checking). Server could be compiled separately but
// it's faster to have do both in one run. Tests and benchmark files
// need to be enumerated explicitly because closure-compiler ignores
// require statements with arguments that are not a string literal.
const compileTargets = [
require('../codecity'),
require('./code_test'),
require('./dump_test'),
require('./dumper_test'),
require('./interpreter_test'),
require('./interpreter_unit_test'),
require('./interpreter_test'),
require('./iterable_weakmap_test'),
require('./iterable_weakset_test'),
require('./registry_test'),
require('./priorityqueue_test'),
require('./selector_test'),
require('./serialize_test'),
require('./interpreter_bench'),
require('./serialize_bench'),
];
// Force compilation of tests/benchmarks (for synta
const fs = require('fs');
const {T, B} = require('./testing');
/**
* Run benchmarks.
* @param {!Array} files Filenames containing benchmarks to run.
*/
async function runBenchmarks(files) {
for (var i = 0; i < files.length; i++) {
var benchmarks = require(files[i]);
var b = new B;
if (!compileTargets.includes(benchmarks)) {
b.result('WARN', files[i] + ' is not being checked by closure-compiler');
}
for (var k in benchmarks) {
if (k.startsWith('bench') && typeof benchmarks[k] === 'function') {
try {
await benchmarks[k](b);
} catch (e) {
b.crash(k, e);
}
}
}
}
}
/**
* Run tests.
* @param {!Array} files Filenames containing tests to run.
*/
async function runTests(files) {
var t = new T;
for (var i = 0; i < files.length; i++) {
var tests = require(files[i]);
if (!compileTargets.includes(tests)) {
t.result('WARN', files[i] + ' is not being checked by closure-compiler');
}
for (var k in tests) {
if (k.startsWith('test') && typeof tests[k] === 'function') {
try {
await tests[k](t);
} catch (e) {
t.crash(k, e);
}
}
}
}
// Print results summary.
console.log('\n%s\n', String(t));
}
/**
* Get list of test filenames matching a particular regexp.
* @param {!RegExp} pattern RegExp to match.
* @return {!Array} List of filenames.
*/
function getFiles(pattern) {
var f = fs.readdirSync(__dirname); // __dirname is location of this module.
return f.filter(function (fn) { return pattern.test(fn); }).
map(function (fn) { return './' + fn; });
}
///////////////////////////////////////////////////////////////////////////////
// Main program
//
(async function main() {
await runTests(getFiles(/_test.js$/));
await runBenchmarks(getFiles(/_bench.js$/));
})();
================================================
FILE: server/tests/selector_test.js
================================================
/**
* @license
* Copyright 2018 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Test for CSS-style selectors for JS objects.
* @author cpcallen@google.com (Christopher Allen)
*/
'use strict';
const Selector = require('../selector');
const {T} = require('./testing');
const util = require('util');
/**
* Unit tests for Selector
* @param {!T} t The test runner object.
*/
exports.testSelector = function(t) {
const cases = [
// Test cases of form [SS, [P1, P2, ...], tS, tE, tSE] where
// SS: selector string, to use as argument to Selector constructor,
// [Pn...]: expected parts array,
// tS: expected toString output,
// tE: expected toExpr output (can be omitted if same),
// tSE: expected toSetExpr output (if different not same + ' = NEW').
['foo', ['foo'], 'foo'],
['foo.bar', ['foo', 'bar'], 'foo.bar'],
['foo["bar"]', ['foo', 'bar'], 'foo.bar'],
["foo['bar']", ['foo', 'bar'], 'foo.bar'],
['foo[42]', ['foo', '42'], 'foo[42]'],
["foo['42']", ['foo', '42'], 'foo[42]'],
['foo["42"]', ['foo', '42'], 'foo[42]'],
['foo["bar baz"]', ['foo', 'bar baz'], "foo['bar baz']"],
["foo['bar baz']", ['foo', 'bar baz'], "foo['bar baz']"],
["foo['\"\\'\"']", ['foo', '"\'"'], "foo['\"\\'\"']"],
['foo["\'\\"\'"]', ['foo', "'\"'"], 'foo["\'\\"\'"]'],
['foo.bar.baz', ['foo', 'bar', 'baz'], 'foo.bar.baz'],
['$._.__.$$', ['$', '_', '__', '$$'], '$._.__.$$'],
['foo^', ['foo', Selector.PROTOTYPE], 'foo{proto}',
'Object.getPrototypeOf(foo)', 'Object.setPrototypeOf(foo, NEW)'],
['foo{proto}.bar', ['foo', Selector.PROTOTYPE, 'bar'], 'foo{proto}.bar',
'Object.getPrototypeOf(foo).bar',
'Object.getPrototypeOf(foo).bar = NEW'],
['foo{owner}', ['foo', Selector.OWNER], 'foo{owner}',
'Object.getOwnerOf(foo)', 'Object.setOwnerOf(foo, NEW)'],
['foo{owner}.bar', ['foo', Selector.OWNER, 'bar'], 'foo{owner}.bar',
'Object.getOwnerOf(foo).bar',
'Object.getOwnerOf(foo).bar = NEW'],
];
for (const [input, parts, str, expr, setExpr] of cases) {
// Do test with selector string.
let name = util.format('new Selector(%o)', input);
let s = new Selector(input);
t.expect(name + '.length', s.length, parts.length);
for (let i = 0; i < s.length; i++) {
t.expect(util.format('%s[%d]', name, i), s[i], parts[i]);
}
t.expect(name + '.toString()', s.toString(), str);
let expectedExpr = expr || str;
t.expect(name + '.toExpr()', s.toExpr(), expectedExpr);
let expectedSetExpr = setExpr || expectedExpr + ' = NEW';
t.expect(name + '.toSetExpr()', s.toSetExpr('NEW'), expectedSetExpr);
// Repeat test using parts array.
name = util.format('new Selector(%o)', parts);
s = new Selector(parts);
t.expect(name + '.toString()', s.toString(), str);
t.expect(name + '.toExpr()', s.toExpr(), expectedExpr);
t.expect(name + '.toSetExpr()', s.toSetExpr('NEW'), expectedSetExpr);
}
const invalidCases = [
'1foo',
'foo.',
'foo["bar]',
"foo[bar']",
'foo.[42]',
'foo[42',
'foo42]',
'foo[42}',
"foo['\"'\"']",
'foo["\'"\'"]',
'foo^bar',
'^.bar',
['1foo'],
'^',
'{proto}',
[Selector.PROTOTYPE],
"foo['bar'}",
'foo{proto]',
'foo{proto',
'foo.proto}',
'foo{blah}',
'foo{}',
'{owner}',
[Selector.OWNER],
];
for (const input of invalidCases) {
// Do test with selector string.
const name = util.format('new Selector(%o)', input);
try {
new Selector(input);
t.fail(name, "didn't throw");
} catch (e) {
t.pass(name);
}
}
};
/**
* Unit tests for Selector.prototype.isVar / isProp / isProto
* @param {!T} t The test runner object.
*/
exports.testSelectorPrototypeIsWhatever = function(t) {
const cases = [
// Test cases of form [selector, isVar].
['foo', true, false, false, false],
['foo.bar', false, true, false, false],
['foo^', false, false, true, false],
['foo{proto}', false, false, true, false],
['foo{owner}', false, false, false, true],
];
for (const [input, isVar, isProp, isProto, isOwner] of cases) {
const name = util.format('new Selector(%o)', input);
const s = new Selector(input);
t.expect(name + '.isVar()', s.isVar(), isVar);
t.expect(name + '.isProp()', s.isProp(), isProp);
t.expect(name + '.isProto()', s.isProto(), isProto);
t.expect(name + '.isOwner()', s.isOwner(), isOwner);
}
};
/**
* Unit tests for Selector.partBadness
* @param {!T} t The test runner object.
*/
exports.testSelectorPartBadness = function(t) {
// Test verifies these are in monotonically increasing order of badness.
const cases = [
'bar',
'quux',
'10',
'100',
'&',
'&*',
'ridiculouslyLongIdentifier',
'2872498713723',
'#^@*%*!@#',
Selector.PROTOTYPE,
];
let previous = '(no previous)';
let previousBadness = -Infinity;
for (const part of cases) {
const badness = Selector.partBadness(part);
const name = util.format(
'Selector.partBadness(%o) (===%d) < Selector.partBadness(%o) (===%d)',
previous, previousBadness, part, badness);
t.assert(name, previousBadness < badness);
previous = part;
previousBadness = badness;
}
};
/**
* Unit tests for Selector.prototype.badness
* @param {!T} t The test runner object.
*/
exports.testSelectorPrototypeBadness = function(t) {
// Test verifies these are in monotonically increasing order of badness.
const cases = [
'foo',
'foobar',
'foo.bar',
'foo[10]',
'foo["&"]',
'foo.bar.baz.quux.quuux.quuux',
'foo{proto}',
'foo.bar.baz.quux.quuux.quuux.quuuux.quuuuux.quuuuuux.quuuuuuux',
];
let previous = '(no previous)';
let previousBadness = -Infinity;
for (const ss of cases) {
const s = new Selector(ss);
const badness = s.badness();
const name = util.format('Selector(%o).badness() < Selector(%o).badness()',
previous, ss);
t.assert(name, previousBadness < badness);
previous = ss;
previousBadness = badness;
}
};
================================================
FILE: server/tests/serialize_bench.js
================================================
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Benchmarks for JavaScript interpreter.
* @author cpcallen@google.com (Christopher Allen)
*/
'use strict';
const fs = require('fs');
const path = require('path');
const util = require('util');
const Interpreter = require('../interpreter');
const {getInterpreter, startupFiles} = require('./interpreter_common');
const Serializer = require('../serialize');
/**
* Run a benchmark of the interpreter being serialized/deserialized.
* @param {!B} b The benchmark runner object.
* @param {string} name The name of the test.
* @param {string} src The code to be evaled before roundtripping.
* @param {function(!Interpreter)=} initFunc Optional function to be
* called after creating new interpreter instance but before
* running src. Can be used to insert extra native functions into
* the interpreter. initFunc is called with the interpreter
* instance to be configured as its parameter.
*/
function runSerializationBench(b, name, src, initFunc) {
for (let i = 0; i < 4; i++) {
const intrp1 = new Interpreter();
const intrp2 = new Interpreter();
if (initFunc) {
initFunc(intrp1);
initFunc(intrp2);
}
const err = undefined;
try {
intrp1.createThreadForSrc(src);
intrp1.run();
intrp1.stop();
b.start(name, i);
let json = Serializer.serialize(intrp1);
b.end(name + ' serialize', i);
let str = JSON.stringify(json);
let len = str.length;
b.end(name + ' stringify (' + Math.ceil(len / 1024) + 'kiB)', i);
json = JSON.parse(str);
b.end(name + ' parse', i);
Serializer.deserialize(json, intrp2);
b.end(name + ' deserialize', i);
} catch (err) {
b.crash(name, util.format('%s\n%s', src, err.stack));
}
}
};
/**
* Run a benchmark of the interpreter being serialized/deserialized.
* @param {!B} b The benchmark runner object.
* @param {string} name The name of the test.
* @param {string} src The code to be evaled before roundtripping.
* @param {function(!Interpreter)=} initFunc Optional function to be
* called after creating new interpreter instance but before
* running src. Can be used to insert extra native functions into
* the interpreter. initFunc is called with the interpreter
* instance to be configured as its parameter.
*/
function runDeserializationBench(b, name, src, initFunc) {
for (var i = 0; i < 4; i++) {
const intrp1 = new Interpreter();
const intrp2 = new Interpreter();
if (initFunc) {
initFunc(intrp1);
initFunc(intrp2);
}
const err = undefined;
try {
intrp1.createThreadForSrc(src);
intrp1.run();
intrp1.stop();
b.start(name, i);
const json = Serializer.serialize(intrp1);
var len = JSON.stringify(json).length;
Serializer.deserialize(json, intrp2);
b.end(name + ' (' + Math.ceil(len / 1024) + 'kiB)', i);
} catch (err) {
b.crash(name, util.format('%s\n%s', src, err.stack));
}
}
};
/**
* Run a benchmark of the interpreter after being
* serialized/deserialized.
* @param {!B} b The benchmark runner object.
* @param {string} name The name of the test.
* @param {string} src The code to be evaled.
*/
function runInterpreterBench(b, name, src) {
for (let i = 0; i < 4; i++) {
const intrp1 = getInterpreter();
const intrp2 = new Interpreter();
try {
intrp1.createThreadForSrc(src);
intrp1.stop();
const json = Serializer.serialize(intrp1);
Serializer.deserialize(json, intrp2);
// Deserialized interpreter was stopped, but we want to be able to
// step/run it, so wake it up to PAUSED.
intrp2.pause();
b.start(name, i);
intrp2.run();
b.end(name, i);
} catch (err) {
b.crash(name, util.format('%s\n%s', src, err.stack));
} finally {
intrp2.stop();
}
}
};
/**
* Run benchmarks roundtripping the interpreter.
* @param {!B} b The test runner object.
*/
exports.benchRoundtrip = function(b) {
let name = 'Roundtrip demo';
const demoDir = path.join(__dirname, '../../core');
const filenames = fs.readdirSync(demoDir);
filenames.sort();
let src = '';
for (const filename of filenames) {
if (!(filename.match(/.js$/))) continue;
src += fs.readFileSync(String(path.join(demoDir, filename)));
}
const fakeBuiltins = function(intrp) {
// Hack to install stubs for builtins found in codecity.js.
const builtins = [
'CC.log', 'CC.checkpoint', 'CC.shutdown', 'CC.hash',
'CC.acorn.parse', 'CC.acorn.parseExpressionAt',
];
for (const bi of builtins) {
new intrp.NativeFunction({id: bi, length: 0,});
}
};
runSerializationBench(b, name, src, fakeBuiltins);
};
/**
* Run the fibbonacci10k benchmark.
* @param {!B} b The test runner object.
*/
exports.benchResurrectedFibbonacci10k = function(b) {
let name = 'ressurrectedFibonacci10k';
let src = `
var fibonacci = function(n, output) {
var a = 1, b = 1, sum;
for (var i = 0; i < n; i++) {
output.push(a);
sum = a + b;
a = b;
b = sum;
}
}
for(var i = 0; i < 10000; i++) {
var result = [];
fibonacci(78, result);
}
result;
`;
runInterpreterBench(b, name, src);
};
================================================
FILE: server/tests/serialize_test.js
================================================
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Serialization/deserialization tests for JavaScript interpreter.
* @author fraser@google.com (Neil Fraser)
*/
'use strict';
const net = require('net');
const util = require('util');
const Interpreter = require('../interpreter');
const {getInterpreter} = require('./interpreter_common');
const Serializer = require('../serialize');
const {T} = require('./testing');
///////////////////////////////////////////////////////////////////////////////
// Test helper functions.
///////////////////////////////////////////////////////////////////////////////
/**
* Serialize an interpreter to JSON, then create and return a new
* interpreter by deserializing that JSON.
* @param {!Interpreter} intrp The interpreter to be serialized.
* @return {?Interpreter} the freshly deserialized interpreter, or
* null if an error occurred.
*/
function roundTrip(intrp) {
intrp.pause(); // Save timer info.
const json = JSON.stringify(Serializer.serialize(intrp), null, ' ');
const intrp2 = new Interpreter;
Serializer.deserialize(JSON.parse(json), intrp2);
// Deserialized interpreter was stopped, but we want to be able to
// step/run it, so wake it up to PAUSED.
intrp2.pause();
return intrp2;
}
/**
* Run a (possibly multiple) roundtrip test:
* - Create an interpreter instance.
* - Create a thread to eval src1, and run it to completion.
* - Create a thread to eval src2
* - Step through src2, periodically serializing and unserializing.
* - Do a final round-trip serialization, if none done yet.
* - Create a thread to eval src3, and run it to completion.
* - Verify value of final expression evaluated is === expected.
* @param {!T} t The test runner object.
* @param {string} name The name of the test.
* @param {string} src1 The code to be evaled before any serialization.
* @param {string} src2 The code to be evaled while periodically serializing.
* @param {string} src3 The code to be evaled after final serialization.
* @param {number|string|boolean|null|undefined} expected The expected
* completion value.
* @param {!TestOptions=} options Custom test options.
*/
function runTest(t, name, src1, src2, src3, expected, options) {
options = options || {};
let intrp = getInterpreter(options.options, options.standardInit);
if (options.onCreate) {
options.onCreate(intrp);
}
let thread;
try {
if (src1) {
thread = intrp.createThreadForSrc(src1).thread;
intrp.run();
}
} catch (e) {
t.crash(name + 'Pre', e);
return;
}
try {
if (src2) {
thread = intrp.createThreadForSrc(src2).thread;
}
let trips = 0;
if (options.steps === undefined) {
intrp.run();
} else {
let s = 0;
while(intrp.step()) {
if ((++s % options.steps) === 0) {
intrp = roundTrip(intrp);
trips++;
}
}
}
if (trips === 0) {
intrp = roundTrip(intrp);
trips++;
}
} catch (e) {
t.crash(name, e);
return;
}
try {
intrp.run();
if (src3) {
thread = intrp.createThreadForSrc(src3).thread;
intrp.run();
}
} catch (e) {
t.crash(name + 'Post', e);
return;
}
const r = intrp.pseudoToNative(thread.value);
const allSrc = util.format(
'%s\n/* begin roundtrips */\n%s\n/* end roundtrips */\n%s',
src1, src2, src3);
t.expect(name, r, expected, allSrc);
};
/**
* Run a (truly) asynchronous roundtrip test of the interpreter.
* A new Interpreter instance is created for each test. Special functions
* resolve() and reject() are inserted in the global scope; they will
* end each section of the test. The caller can additionally supply a
* callback to be run before starting the interpreter.
*
* Full procedure:
* - Create and initialize an interpreter instance.
* - Call options.onCreate, if supplied, on first interpreter instance.
* - Start the interpreter and run src1 (if supplied).
* - Await a call to resolve() or reject(); abort the test if the latter occurs.
* - Stop the interpreter.
* - Serialize interpreter to JSON.
* - Create second interpreter instance. Don't initialize it.
* - Call options.onCreate, if supplied, on second interpreter instance.
* - Deserialize JSON into second interpreter instance.
* - Start the second interpreter and allow it to run to completion.
* - Run src2 (if supplied).
* - Await a call to resolve() or reject().
* - If resolve was called, verify the result is as expected.
* @param {!T} t The test runner object.
* @param {string} name The name of the test.
* @param {string} src1 The code to be evaled before serialization.
* @param {string} src2 The code to be evaled after serialization.
* @param {number|string|boolean|null|undefined} expected The expected
* completion value.
* @param {!TestOptions=} options Custom test options.
*/
async function runAsyncTest(t, name, src1, src2, expected, options) {
options = options || {};
const intrp1 = getInterpreter(options.options, options.standardInit);
if (options.onCreate) {
options.onCreate(intrp1);
}
let thread;
// Create promise to signal completion of test from within
// interpreter. Awaiting p will block until resolve or reject is
// called.
let resolve, reject, result;
let p = new Promise(function(res, rej) { resolve = res; reject = rej; });
intrp1.global.createMutableBinding(
'resolve', intrp1.createNativeFunction('resolve', resolve, false));
intrp1.global.createMutableBinding(
'reject', intrp1.createNativeFunction('reject', reject, false));
try {
intrp1.start();
if (src1) {
intrp1.createThreadForSrc(src1);
}
await p;
intrp1.pause();
} catch (e) {
t.crash(name + 'Pre', e);
return;
}
// Serialize.
let json;
try {
json = JSON.stringify(Serializer.serialize(intrp1), null, ' ');
} catch (e) {
t.crash(name + 'Serialize', e);
return;
}
intrp1.stop();
// Restore into new interpreter.
const intrp2 = getInterpreter(options.options, options.standardInit);
if (options.onCreate) {
options.onCreate(intrp2);
}
// New promise.
p = new Promise(function(res, rej) { resolve = res; reject = rej; });
intrp2.global.createMutableBinding(
'resolve', intrp2.createNativeFunction('resolve', resolve, false));
intrp2.global.createMutableBinding(
'reject', intrp2.createNativeFunction('reject', reject, false));
try {
Serializer.deserialize(JSON.parse(json), intrp2);
} catch (e) {
t.crash(name + 'Deserialize', e);
return;
}
try {
intrp2.start();
if (src2) {
intrp2.createThreadForSrc(src2);
}
result = await p;
} catch (e) {
t.crash(name + 'Post', e);
return;
} finally {
intrp2.stop();
}
const r = intrp2.pseudoToNative(result);
const allSrc = util.format('%s\n/* roundtrip */\n%s', src1, src2);
t.expect(name, r, expected, allSrc);
};
/**
* Options for runTest and runAsyncTest.
* @record
*/
const TestOptions = function() {};
/**
* Interpreter constructor options.
* @type {!Interpreter.Options|undefined}
*/
TestOptions.prototype.options;
/**
* Load the standard startup files at startup? (Default: true.)
* Setting to false speeds up tests with many roundtrips that do not
* need builtins.
* @type {boolean|undefined}
*/
TestOptions.prototype.standardInit;
/**
* Callback to be called after creating new interpreter instance (and
* running standard starup files, if not suppressed with standardInit:
* false) but before creating a thread for srcN. Can be used to
* insert extra bindings into the global scope (e.g., to create
* additional builtins).
*
* The first argument is the interpreter instance to be configured.
*
* @type {function(!Interpreter)|undefined}
*/
TestOptions.prototype.onCreate;
/**
* How many steps to run between serializations (run src1 to
* completion if unspecified).
* @type {number|undefined}
*/
TestOptions.prototype.steps;
///////////////////////////////////////////////////////////////////////////////
// Tests: serialisation
///////////////////////////////////////////////////////////////////////////////
/**
* Run a round trip serialization-deserialization.
* @param {!T} t The test runner object.
*/
exports.testRoundtripSimple = function(t) {
runTest(t, 'testRoundtripSimple', '', `
var x = 1;
for (var i = 0; i < 8; i++) {
x *= 2;
}
`, 'x;', 256, {steps: 100});
};
/**
* Run a round trip of serializing the Interpreter.SCOPE_REFERENCE
* sentinel and an Interpreter.PropertyIterator.
*
* BUG(#193): running this test causes *subsequent* benchmarks to run
* about 15% slower for no obvious reason. Investigate.
* @param {!T} t The test runner object.
*/
exports.testRoundtripScopeRefAndPropIter = function(t) {
runTest(t, 'testRoundtripScopeRefAndPropIter', `
var r = 0, o = {a: 1, b: 2};
`,`
for (var k in o) {
r += o[k];
}
`, 'r;', 3, {steps: 1, standardInit: false});
};
/**
* Run a round trip of serializing WeakMaps.
* @param {!T} t The test runner object.
*/
exports.testRoundtripWeakMap = function(t) {
runTest(t, 'testRoundtripWeakMap', `
var o1 = {};
var wm = new WeakMap;
var o2 = {};
wm.set(o1, 105);
wm.set(o2, 42);
var empty = new WeakMap;
`, '', `
(empty instanceof WeakMap) && (wm instanceof WeakMap) &&
wm.get(o1) - wm.get(o2);
`, 105 - 42);
};
/**
* Run more detailed tests of the state of the post-rountrip interpreter.
* @param {!T} t The test runner object.
*/
exports.testRoundtripDetails = function(t) {
runTest(t, 'testRoundtripPropertyAttributes', `
var obj = {};
for (var i = 0; i < 8; i++) {
var desc = {value: i,
writable: !!(i & 0x1),
enumerable: !!(i & 0x2),
configurable: !!(i & 0x4)};
Object.defineProperty(obj, i, desc);
}
`, '', `
for (var i = 0; i < 8; i++) {
desc = Object.getOwnPropertyDescriptor(obj, i);
if (desc.value !== i ||
desc.writable !== !!(i & 0x1) ||
desc.enumerable !== !!(i & 0x2) ||
desc.configurable !== !!(i & 0x4)) {
throw new Error('Roundtrip failure for property ' + i);
}
}
'All good';
`, 'All good');
runTest(t, 'testRoundtripObjectExtensibility', `
var ext = {};
var nonExt = {};
Object.preventExtensions(nonExt);
`, '', `
Object.isExtensible(ext) && !Object.isExtensible(nonExt);
`, true);
// Test preservation of prototype identity, including protypes used
// by various built-in functions.
//
// exprs is a large object literal which maps built-in constructors
// to arrays of values which should all be that constructor's
// .prototype object.
const exprs = `{
Object: [
Object.prototype,
new 'Object.prototype',
Object.getPrototypeOf(new Object),
Object.getPrototypeOf({}),
Object.getPrototypeOf(Object.getOwnPropertyDescriptor(
Object.prototype, 'constructor')),
],
Function: [
Function.prototype,
new 'Function.prototype',
Object.getPrototypeOf(new Function),
Object.getPrototypeOf(function() {}),
Object.getPrototypeOf(Function),
],
Array: [
Array.prototype,
new 'Array.prototype',
Object.getPrototypeOf(new Array),
Object.getPrototypeOf([]),
Object.getPrototypeOf([].slice(0,0)),
],
Boolean: [
Boolean.prototype,
new 'Boolean.prototype',
Object.getPrototypeOf(false),
],
Number: [
Number.prototype,
new 'Number.prototype',
Object.getPrototypeOf(0),
],
String: [
String.prototype,
new 'String.prototype',
Object.getPrototypeOf(''),
],
RegExp: [
RegExp.prototype,
new 'RegExp.prototype',
Object.getPrototypeOf(new RegExp),
Object.getPrototypeOf(/foo/),
],${['Date', 'Error', 'EvalError', 'RangeError', 'SyntaxError',
'TypeError', 'URIError', 'PermissionError'].map((c) => `
${c}: [
${c}.prototype,
new '${c}.prototype',
Object.getPrototypeOf(new ${c}),
],`).join('')}
}`;
runTest(t, 'testRoundtripBuiltinPrototypes', `
var pre = ${exprs};
`, '', `
var post = ${exprs};
try {
// Check expressions all had same value intially.
for (var key in pre) {
if (!pre.hasOwnProperty(key)) continue;
for (var i = 1; i < pre[key].length; i++) {
if (pre[key][0] !== pre[key][i]) {
throw 'pre["' + key + '"][0] !== pre["' +
key + '"][' + i + ']';
}
}
}
// Check expressions all had same value before and after.
for (var key in pre) {
if (!pre.hasOwnProperty(key)) continue;
for (var i = 0; i < pre[key].length; i++) {
if (pre[key][i] !== post[key][i]) {
throw 'pre["' + key + '"][' + i + '] !== post["' +
key + '"][' + i + ']';
}
}
}
'OK';
} catch (e) {
e;
}
`, 'OK');
runTest(t, 'testRoundtripArrayLengthRemainsMagical', `
var arr = [0, 1, 2];
`, '', `
arr[3] = 3;
arr.length;
`, 4);
};
/**
* Run tests of post-roundtrip interpreter timers & networking state.
* @param {!T} t The test runner object.
*/
exports.testRoundtripAsync = async function(t) {
// Run a test of timer preservation during serialization/deserialization.
var name = 'testRestoreTimers';
var src1 = `
var x = '';
setTimeout(function() { x += '1'; }, 0);
setTimeout(function() { resolve(); }, 10);
setTimeout(function() { x += '3'; }, 20);
setTimeout(function() { x += '4'; }, 40);
`;
var src2 = `
x += '2';
setTimeout(function() { resolve(x); }, 11);
`;
await runAsyncTest(t, name, src1, src2, '123');
// Run a test of the server re-listening to sockets after being
// deserialized.
name = 'testPostRestoreNetworkInbound';
src1 = `
var data = '', conn = {};
conn.onReceive = function(d) {
data += d;
};
conn.onEnd = function() {
CC.connectionClose(this);
CC.connectionUnlisten(8888);
resolve(data);
};
CC.connectionListen(8888, conn);
resolve();
`;
src2 = `
send();
`;
const installSend = function(intrp) {
intrp.global.createMutableBinding('send', intrp.createNativeFunction(
'send', function() {
// Send some data to server.
var client = net.createConnection({ port: 8888 }, function() {
client.write('foo');
client.write('bar');
client.end();
});
}));
};
await runAsyncTest(t, name, src1, src2, 'foobar', {
options: {noLog: ['net']},
onCreate: installSend,
});
// Run a test to verify that the connection object's .error method
// is called with a suitable Error object if the previously-listened
// port is in use when the interpreter is restarted.
name = 'testFailedRelistenFiresError';
src1 = `
var connection = {onError: function(err) {resolve(err.name);}};
CC.connectionListen(8888, connection);
resolve(); // Start serialisation roundtrip.
`;
src2 = `
suspend(); // Allow pending onError thread to run.
resolve('No error thrown');
`;
let /** number */ count = 0;
let /** ?net.Server */ server = null;
const blockPort = function(intrp) {
if (count++) { // Do only when creating post-roundtrip Interpreter.
server = new net.Server();
server.listen(8888);
}
};
await runAsyncTest(t, name, src1, src2, 'Error', {
options: {noLog: ['net']},
onCreate: blockPort,
});
server.close();
};
================================================
FILE: server/tests/testcases.js
================================================
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Test cases for JavaScript interpreter.
* @author cpcallen@google.com (Christopher Allen)
*/
'use strict';
// Testcases for testSimple in interpreter_test.js.
module.exports = [
{src: `1 + 1;`, expected: 2},
{src: `2 + 2;`, expected: 4},
{src: `6 * 7;`, expected: 42},
{src: `(3 + 12 / 4) * (10 - 3);`, expected: 42},
{src: `var x = 43; x;`, expected: 43},
{src: `true ? 'then' : 'else';`, expected: 'then'},
{src: `false ? 'then' : 'else';`, expected: 'else'},
{
name: 'if(true)',
src: `
if (true) {
'then';
} else {
'else';
}
`,
expected: 'then',
},
{
name: 'if(false)',
src: `
if (false) {
'then';
} else {
'else';
}
`,
expected: 'else',
},
{
name: 'simpleAssignment',
src: `var x = 0; x = 44; x;`,
expected: 44,
},
{
name: 'propertyAssignment',
src: `var o = {}; o.foo = 45; o.foo;`,
expected: 45,
},
{
name: 'getPropertyOnPrimitive',
src: `'foo'.length;`,
expected: 3,
},
{
name: 'setPropertyOnPrimitive',
src: `
try {
'foo'.bar = 42;
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
{src: `var x = 45; x++; x++;`, expected: 46},
{src: `var x = 45; ++x; ++x;`, expected: 47},
{src: `'foo' + 'bar';`, expected: 'foobar'},
{
name: 'Effect of += on left argument',
src: `var x = 40, y = 8; x += y; x;`,
expected: 48,
},
{
name: 'Effect of += on right argument',
src: `var x = 40, y = 8; x += y; y;`,
expected: 8,
},
{
name: 'FunctionExpression',
src: `var v, f = function() {v = 49;}; f(); v;`,
expected: 49,
},
{
name: 'variable assignment sets anonymous function name',
src: `
var myAssignedFunc;
myAssignedFunc = function() {};
myAssignedFunc.name;
`,
expected: 'myAssignedFunc',
},
{
name: 'property assignment does not set anonymous FunctionExpression name',
src: `
var obj = {};
obj.myMethod = function() {};
obj.myMethod.name;
`,
expected: '',
},
{
// This one is a CodeCity extension.
name: 'property assignment optionally sets anonymous function name',
src: `
var obj = {};
obj.myMethod = function() {};
obj.myMethod.name;
`,
options: {methodNames: true},
expected: 'myMethod',
},
{
name: 'object expression sets anonymous FunctionExpression name',
src: `({myPropFunc: function() {}}).myPropFunc.name;`,
expected: 'myPropFunc',
},
{
name: 'variable declaration sets anonymous FunctionExpression name',
src: `var myVarDeclFunc = function() {}; myVarDeclFunc.name;`,
expected: 'myVarDeclFunc',
},
{
name: 'funExpWithParameter',
src: `var v; var f = function(x) {v = x;}; f(50); v;`,
expected: 50,
},
{
name: 'funExpParameterNotShadowedByVar',
src: `var f = function(x) {var x; return x;}; f(50.1);`,
expected: 50.1,
},
{
name: 'funExpParameterNotShadowedByVar',
src: `var f = function(x) {var x = 50.2; return x;}; f(50.2);`,
expected: 50.2,
},
{
name: 'functionWithReturn',
src: `(function(x) {return x;})(51);`,
expected: 51,
},
{
name: 'functionWithoutReturn',
src: `(function() {})();`,
expected: undefined,
},
{
name: 'multipleReturn',
src: `
var f = function() {
try {
return true;
} finally {
return false;
}
}
f();
`,
expected: false,
},
{
name: 'throwCatch',
src: `
var f = function() {
throw 26;
}
try {
f();
} catch (e) {
e * 2;
}
`,
expected: 52,
},
{
name: 'throwCatchFalsey',
src: `
try {
throw null;
} catch (e) {
'caught ' + String(e);
}
`,
expected: 'caught null',
},
// N.B.: This and next tests have no equivalent in the test DB.
{
name: 'throwUnhandledError',
src: `throw new Error('not caught');`,
options: {noLog: ['unhandled']},
expected: undefined,
},
{
name: 'throwUnhandledException',
src: `throw 'not caught';`,
options: {noLog: ['unhandled']},
expected: undefined,
},
{
src: `try {throw new Error('not caught');} finally {}`,
options: {noLog: ['unhandled']},
expected: undefined,
},
{
src: `try {throw 'not caught';} finally {}`,
options: {noLog: ['unhandled']},
expected: undefined,
},
{src: `51, 52, 53;`, expected: 53},
{
name: 'sequenceExpression',
src: `
var x, y, z;
x = (y = 60, z = 5, 0.5);
x + y + z;
`,
expected: 65.5,
},
{
name: 'labeledStatement',
src: `foo: 54;`,
expected: 54,
},
{
name: 'whileLoop',
src: `
var a = 0;
while (a < 55) a++;
a;
`,
expected: 55,
},
{
name: 'while(false)',
src: `
var a = 56;
while (false) a++;
a;
`,
expected: 56,
},
{
name: 'do ... while(false)',
src: `
var a = 56;
do a++; while (false);
a;
`,
expected: 57,
},
{
name: 'do ... break ... while',
src: `
var a = 57;
do {
a++;
break;
a++;
} while (false);
a;
`,
expected: 58,
},
{
src: `foo: break foo;`,
expected: undefined, // (but legal!)
},
{
name: 'try ... break ... finally',
src: `
var a = 6;
foo: {
try {
a *= 10;
break foo;
} finally {
a--;
}
}
a;
`,
expected: 59,
},
{
name: 'do ... while with try ... continue ... finally ...',
src: `
var a = 59;
do {
try {
continue;
} finally {
a++;
}
} while (false);
a;
`,
expected: 60,
},
{
name: 'while with try ... break ... finally continue',
src: `
var a = 0;
while (a++ < 60) {
try {
break;
} finally {
continue;
}
}
a;
`,
expected: 61,
},
{
name: 'while with try ... return ... finally continue',
src: `
(function() {
var i = 0;
while (i++ < 61) {
try {
return 42;
} finally {
continue;
}
}
return i;
})();
`,
expected: 62,
},
{src: `63 || 'foo';`, expected: 63},
{src: `false || 64;`, expected: 64},
{
name: '|| short-circuit',
src: `var r = 0; true || (r++); r;`,
expected: 0,
},
{src: `({}) && 65;`, expected: 65},
{src: `0 && 65;`, expected: 0},
{
name: '&& sort-circuit',
src: `var r = 0; false && (r++); r;`,
expected: 0,
},
{
name: 'for',
src: `
var t = 0;
for (var i = 0; i < 12; i++) {
t += i;
}
t;
`,
expected: 66,
},
{
name: 'forIn',
src: `
var x = 0, a = {a: 60, b:3, c:4};
for (var i in a) {x += a[i];}
x;
`,
expected: 67,
},
{
name: 'forInMemberExp',
src: `
var x = 1, o = {foo: 'bar'}, a = {a:2, b:2, c:17};
for (o.foo in a) {x *= a[o.foo];}
x;
`,
expected: 68,
},
{
name: 'forInMembFunc',
src: `
var x = 0, o = {};
var f = function() {x += 20; return o;};
var a = {a:2, b:3, c:4};
for (f().foo in a) {x += a[o.foo];}
x;
`,
expected: 69,
},
{
name: 'forInNullUndefined',
src: `
var x = 0, o = {};
var f = function() {x++; return o;};
for (f().foo in null) {x++;}
for (f().foo in undefined) {x++;}
x;
`,
expected: 0,
},
{
name: 'switchDefaultFirst',
src: `
switch ('not found') {
default:
'OK';
break;
case 'decoy':
'fail';
};
`,
expected: 'OK',
},
{
name: 'switchDefaultOnly',
src: `
switch ('not found') {
default:
'OK';
};
`,
expected: 'OK',
},
{
name: 'switchEmptyToEnd',
src: `
'ok';
switch ('foo') {
default:
'fail';
case 'foo':
case 'bar':
};
`,
expected: 'ok',
},
{
name: 'value of this in function call',
src: `
var f = function() {return this;};
f();
`,
expected: undefined,
},
{
name: 'value of this in method call',
src: `
var obj = {method: function() {return this;}};
obj.method() === obj;
`,
expected: true,
},
{
name: 'value of this in method called as function',
src: `
var obj = {method: function() {return this;}};
var f = obj.method;
f();
`,
expected: undefined,
},
{
name: 'value of this outside function body',
src: `this === undefined;`,
expected: true,
},
{
name: 'value of this not boxed (in strict mode)',
destructive: true, // Modifies String.prototype!
src: `
String.prototype.method = function() {return typeof this;};
'a primitive string'.method();
`,
expected: 'string', // Would be an [object String] in non-strict mode.
},
{src: `[].length;`, expected: 0},
{src: `[1,,3,,].length;`, expected: 4},
{
name: 'arrayElidedNotDefinedNotUndefined',
src: `
var a = [,undefined,null,0,false];
!(0 in a) && (1 in a) && (2 in a) && (3 in a) && (4 in a);
`,
expected: true,
},
{
name: 'arrayLengthPropertyDescriptor',
src: `
var a = [1, 2, 3];
var pd = Object.getOwnPropertyDescriptor(a, 'length');
(pd.value === 3) && pd.writable && !pd.enumerable && !pd.configurable;
`,
expected: true,
},
{
name: 'arrayLength',
src: `
try {
var a;
function checkLen(exp, desc) {
if (a.length !== exp) {
var msg = 'a.length === ' + a.length + ' (expected: ' + exp + ')'
throw new Error(desc ? msg + ' ' + desc : msg);
}
}
// Empty array has length == 0
a = [];
checkLen(0, 'on empty array');
// Adding non-numeric properties does not increase length:
a['zero'] = 0;
checkLen(0, 'after setting non-index property on []');
// Adding numeric properties >= length does increase length:
for (var i = 0; i < 5; i++) {
a[i] = i;
checkLen(i + 1, 'after setting a[' + i + ']');
}
// .length works propery even for large, sparse arrays, and even
// if values are undefined:
for (i = 3; i <= 31; i++) {
var idx = (1 << i) >>> 0; // >>> 0 converts int32 to uint32
a[idx] = undefined;
checkLen(idx + 1, 'after setting a[' + idx + ']');
}
// Adding numeric properties < length does not increase length:
a[idx - 1] = 'not the largest';
checkLen(idx + 1, 'after setting non-largest element');
// Verify behaviour around largest possible index:
a[0xfffffffd] = null;
checkLen(0xfffffffe);
a[0xfffffffe] = null;
checkLen(0xffffffff);
a[0xffffffff] = null; // Not an index.
checkLen(0xffffffff); // Unchanged.
a[0x100000000] = null; // Not an index.
checkLen(0xffffffff); // Unchanged.
function checkIdx(idx, exp, desc) {
var r = a.hasOwnProperty(idx);
if (r !== exp) {
var msg = 'a.hasOwnProperty(' + idx + ') === ' + r;
throw new Error(desc ? msg + ' ' + desc : msg);
}
}
// Setting length to existing value should have no effect:
a.length = 0xffffffff;
checkIdx(0xfffffffd, true);
checkIdx(0xfffffffe, true);
checkIdx(0xffffffff, true);
checkIdx(0x100000000, true);
// Setting length one less than maximum should remove largest
// index, but leave properties with keys too large to be indexes:
a.length = 0xfffffffe;
checkIdx(0xfffffffd, true);
checkIdx(0xfffffffe, false);
checkIdx(0xffffffff, true);
checkIdx(0x100000000, true);
// Setting length to zero should remove all index properties:
a.length = 0;
for (var key in a) {
if (!a.hasOwnProperty(key)) {
continue;
}
if (String(key >>> 0) === key && (key >>> 0) !== 0xffffffff) {
throw new Error(
'Setting a.length = 0 failed to remove property ' + key);
}
}
// Make sure we didn't wipe everything!
if (Object.getOwnPropertyNames(a).length !== 4) {
throw new Error(
'Setting .length == 0 removed some non-index properties');
}
'OK';
} catch (e) {
String(e);
}
`,
expected: 'OK',
},
{
name: 'arrayLengthWithNonWritableProps',
src: `
var a = [];
Object.defineProperty(a, 0,
{value: 'hi', writable: false, configurable: true});
a.length = 0;
a[0] === undefined && a.length === 0;
`,
expected: true,
},
{
name: 'arrayLengthWithNonConfigurableProps',
src: `
var a = [];
Object.defineProperty(a, 0,
{value: 'hi', writable: false, configurable: false});
try {
a.length = 0;
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
{
name: 'compValEmptyBlock',
src: `{};`,
expected: undefined,
},
{src: `undefined;`, expected: undefined},
{
name: 'unaryVoid',
src: `var x = 70; (undefined === void x++) && x;`,
expected: 71,
},
{src: `+'72';`, expected: 72},
{src: `-73;`, expected: -73},
{src: `~0xffffffb5;`, expected: 74},
{src: `!false && (!true === false);`, expected: true},
{src: `typeof undefined;`, expected: 'undefined'},
{src: `typeof null;`, expected: 'object'},
{src: `typeof false;`, expected: 'boolean'},
{src: `typeof 0;`, expected: 'number'},
{src: `typeof '';`, expected: 'string'},
{src: `typeof {};`, expected: 'object'},
{src: `typeof [];`, expected: 'object'},
{src: `typeof function() {};`, expected: 'function'},
{
name: 'unaryTypeofUndeclared',
src: `
try {
typeof undeclaredVar;
} catch (e) {
'whoops!'
}
`,
expected: 'undefined',
},
{
name: 'binaryIn',
src: `var o = {foo: 'bar'}; 'foo' in o && !('bar' in o);`,
expected: true,
},
{
name: 'binaryInParent',
src: `
var p = {foo: 'bar'};
var o = Object.create(p);
'foo' in o && !('bar' in o);
`,
expected: true,
},
{src: `'length' in [];`, expected: true},
{
name: 'binaryInStringLength',
src: `
try {
'length' in '';
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
{
name: 'instanceofBasics',
src: `
function F(){}
var f = new F;
f instanceof F && f instanceof Object && !(f.prototype instanceof F);
`,
expected: true,
},
{
name: 'instanceofNonObjectLHS',
src: `
function F() {}
F.prototype = null;
42 instanceof F;
`,
expected: false,
},
{
name: 'instanceofNonFunctionRHS',
src: `
try {
({}) instanceof 0;
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
{
name: 'instanceofNonObjectPrototype',
src: `
function F() {};
F.prototype = 'hello';
try {
({}) instanceof F;
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
{
name: 'undefined.foo',
src: `
try {
undefined.foo;
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
{
name: 'undefined.foo = ...',
src: `
try {
var c = 0;
undefined.foo = c++;
} catch (e) {
e.name + ',' + c;
}
`,
expected: 'TypeError,0',
},
{
name: 'null.foo',
src: `
try {
null.foo;
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
{
name: 'null.foo = ...',
src: `
try {
var c = 0;
null.foo = c++;
} catch (e) {
e.name + ',' + c;
}
`,
expected: 'TypeError,0',
},
{
name: 'delete',
src: `
var o = {foo: 'bar'};
(delete o.quux) + ('foo' in o) + (delete o.foo) +
!('foo' in o) + (delete o.foo);
`,
expected: 5,
},
{
name: 'deleteNonexistentFromPrimitive',
src: `(delete false.nonexistent) && (delete (42).toString);`,
expected: true,
},
// This "actually" tries to delete the non-configurable own .length
// property from the auto-boxed String instance created by step 4a
// of algorithm in §11.4.1 of the ES 5.1 spec. We have to use a
// string here, because only String instances have own properties
// (and yes: they are all non-configurable, so delete *always*
// fails).
{
name: 'deleteOwnFromPrimitive',
src: `
try {
delete 'hello'.length;
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
{
name: 'funcDecl',
src: `
var v;
function f() {
v = 75;
}
f();
v;
`,
expected: 75,
},
{
name: 'namedFunctionExpression',
src: `
var f = function half(x) {
if (x < 100) {
return x;
}
return half(x / 2);
};
f(152)
`,
expected: 76,
},
{
name: 'namedFunExpNameBinding',
src: `var f = function foo() {return foo;}; f() === f;`,
expected: true,
},
{
name: 'namedFunExpNameBindingNoLeak',
src: `var f = function foo() {}; typeof foo;`,
expected: 'undefined',
},
{
name: 'namedFunExpNameBindingImmutable',
src: `
var f = function foo() {
try {
foo = null;
} catch (e) {
return e.name;
}
};
f();
`,
expected: 'TypeError',
},
{
name: 'namedFunExpNameBindingShadowedByParam',
src: `
var f = function foo(foo) {
foo += 0.1; // Verify mutability.
return foo;
};
f(76);
`,
expected: 76.1,
},
{
name: 'namedFunExpNameBindingShadowedByVar',
src: `
var f = function foo() {
var foo;
foo = 76.2; // Verify mutability.
return foo;
};
f();
`,
expected: 76.2,
},
{
name: 'closureIndependence',
src: `
function makeAdder(x) {
return function(y) {return x + y;};
}
var plus3 = makeAdder(3);
var plus4 = makeAdder(4);
plus3(plus4(70));
`,
expected: 77,
},
{
name: 'internalObjectToString',
src: `
var o = {};
o[{}] = null;
for(var key in o) {
key;
}
`,
expected: '[object Object]',
},
{
name: 'internalFunctionToString',
src: `
var o = {}, s, f = function(){};
o[f] = null;
for(var key in o) {
s = key;
}
/^function.*\(.*\).*{[^]*}$/.test(s);
`,
expected: true,
},
{
name: 'internalNativeFuncToString',
src: `
var o = {}, s, f = Object.create;
o[f] = null;
for(var key in o) {
s = key;
}
/^function.*\(.*\).*{[^]*}$/.test(s);
`,
expected: true,
},
{
name: 'internalArrayToString',
src: `
var o = {};
o[[1, 2, 3]] = null;
for(var key in o) {
key;
}
`,
expected: '1,2,3',
},
{
name: 'internalDateToString',
src: `
var o = {};
o[new Date(0)] = null;
for(var key in o) {
key;
}
`,
expected: (new Date(0)).toString(),
},
{
name: 'internalRegExpToString',
src: `
var o = {};
o[/foo/g] = null;
for(var key in o) {
key;
}
`,
expected: '/foo/g',
},
{
name: 'internalErrorToString',
src: `
var o = {};
o[Error('oops')] = null;
for(var key in o) {
key;
}
`,
expected: 'Error: oops',
},
{
name: 'internalArgumentsToString',
src: `
var o = {};
(function() {
o[arguments] = null;
})();
for(var key in o) {
key;
}
`,
expected: '[object Arguments]',
},
{src: `debugger;`, expected: undefined},
{
name: 'newExpression',
src: `
function T(x, y) {this.sum += x + y;};
T.prototype = {sum: 70}
var t = new T(7, 0.7);
t.sum;
`,
expected: 77.7,
},
{
name: 'newExpressionReturnObj',
src: `
function T() {return {};};
T.prototype = {p: 'the prototype'};
(new T).p;
`,
expected: undefined,
},
{
name: 'newExpressionReturnPrimitive',
src: `
function T() {return 0;};
T.prototype = {p: 'the prototype'};
(new T).p;
`,
expected: 'the prototype',
},
{src: `/foo/.test('foobar');`, expected: true},
{
name: 'evalSeeEnclosing',
src: `var n = 77.77; eval('n');`,
expected: 77.77,
},
{
name: 'evalIndirectNoSeeEnclosing',
src: `
(function() {
var n = 77.77, gEval = eval;
try {
gEval('n');
} catch (e) {
return e.name;
}
})();
`,
expected: 'ReferenceError',
},
{
name: 'evalIndirectNoSeeEnclosing2',
src: `
(function() {
var n = 77.77;
try {
(function() {return eval;})()('n');
} catch (e) {
return e.name;
}
})();
`,
expected: 'ReferenceError',
},
{
name: 'evalIndirectSeeGlobal',
src: `var gEval = eval; gEval('typeof Array');`,
expected: 'function',
},
{
name: 'evalModifyEnclosing',
src: `var n = 77.77; eval('n = 77.88'); n;`,
expected: 77.88,
},
{
name: 'evalNoLeakingDecls',
src: `eval('var n = 88.88'); typeof n;`,
expected: 'undefined',
},
// A bug in eval would cause it to return the value of the
// previously-evaluated ExpressionStatement if the eval program did
// not contain any ExpressionStatements.
{
name: 'evalEmptyBlock',
src: `'fail'; eval('{}');`,
expected: undefined,
},
{
name: 'callEvalOrder',
src: `
var r = '';
function log(x) {
r += x;
return function() {};
};
(log('f'))(log('a'), log('b'), log('c'));
r;
`,
expected: 'fabc',
},
{
name: 'callEvalArgsBeforeCallability',
src: `
try {
var invalid = undefined;
function t() {throw {name: 'args'};};
invalid(t());
} catch(e) {
e.name;
}
`,
expected: 'args',
},
{
name: 'callNonCallable',
src: `
var tests = [
undefined,
null,
false,
42,
'hello',
Object.create(Function.prototype),
];
var ok = 0;
for (var i = 0; i < tests.length; i++) {
try {
tests[i]();
} catch (e) {
var r = e;
if (e.name === 'TypeError') {
ok++;
}
}
}
(ok === tests.length) ? 'pass' : 'fail';
`,
expected: 'pass',
},
/////////////////////////////////////////////////////////////////////////////
// Object and Object.prototype
{
name: 'Object.defineProperty()',
src: `
try {
Object.defineProperty();
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
{
name: 'Object.defineProperty non-object',
src: `
try {
Object.defineProperty('not an object', 'foo', {});
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
{
name: 'Object.defineProperty bad descriptor',
src: `
var o = {};
try {
Object.defineProperty(o, 'foo', 'not an object');
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
// This also tests iteration over (non-)enumerable properties.
{
name: 'Object.defineProperty',
src: `
var o = {foo: 50}, r = 0;
Object.defineProperty(o, 'bar', {
writable: true,
enumerable: true,
configurable: true,
value: 0
});
o.bar = 20;
Object.defineProperty(o, 'baz', {
writable: true,
enumerable: true,
configurable: false
});
Object.defineProperty(o, 'baz', {
value: 4,
});
Object.defineProperty(o, 'quux', {
enumerable: false,
value: 13
});
for (var k in o) {
r += o[k];
}
r += Object.getOwnPropertyNames(o).length;
r;
`,
expected: 78,
},
{
name: 'Object.getPrototypeOf(null) and undefined',
src: `
var r = '', prims = [null, undefined];
for (var i = 0; i < prims.length; i++) {
try {
Object.getPrototypeOf(prims[i]);
} catch (e) {
r += e.name;
}
}
r;
`,
expected: 'TypeErrorTypeError',
},
// This tests for ES6 behaviour:
{
name: 'Object.getPrototypeOf primitives',
src: `
Object.getPrototypeOf(true) === Boolean.prototype &&
Object.getPrototypeOf(1337) === Number.prototype &&
Object.getPrototypeOf('hi') === String.prototype;
`,
expected: true,
},
{
name: 'Object.setPrototypeOf(null, ...) and undefined',
src: `
var r = '', prims = [null, undefined];
for (var i = 0; i < prims.length; i++) {
try {
Object.setPrototypeOf(prims[i], null);
} catch (e) {
r += e.name;
}
}
r;
`,
expected: 'TypeErrorTypeError',
},
{
name: 'Object.setPrototypeOf primitives',
src: `
Object.setPrototypeOf(true, null) === true &&
Object.setPrototypeOf(1337, null) === 1337 &&
Object.setPrototypeOf('hi', null) === 'hi';
`,
expected: true,
},
{
name: 'Object.setPrototypeOf',
src: `
var o = {parent: 'o'};
var p = {parent: 'p'};
var q = Object.create(o);
Object.setPrototypeOf(q, p) === q &&
Object.getPrototypeOf(q) === p && q.parent;
`,
expected: 'p',
},
{
name: 'Object.setPrototypeOf(..., null)',
src: `
var o = {parent: 'o'};
var q = Object.create(o);
Object.setPrototypeOf(q, null) === q && Object.getPrototypeOf(q);
`,
expected: null,
},
{
name: 'Object.setPrototypeOf circular',
src: `
var o = {};
var p = Object.create(o);
try {
Object.setPrototypeOf(o, p);
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
{
name: 'Object.create()',
src: `
try {
Object.create();
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
{
name: 'Object.create non-object prototype',
src: `
try {
Object.create(42);
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
{
name: 'Object.create(null) prototype',
src: `Object.getPrototypeOf(Object.create(null));`,
expected: null,
},
{
name: 'Object.create',
src: `
var o = Object.create({foo: 79});
delete o.foo
o.foo;
`,
expected: 79,
},
{
name: 'Object.getOwnPropertyDescriptor()',
src: `
try {
Object.getOwnPropertyDescriptor();
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
{
name: 'Object.getOwnPropertyDescriptor non-object',
src: `
try {
Object.getOwnPropertyDescriptor('not an object', 'foo');
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
{
name: 'Object.getOwnPropertyDescriptor bad key',
src: `Object.getOwnPropertyDescriptor({}, 'foo');`,
expected: undefined,
},
{
name: 'Object.getOwnPropertyDescriptor',
src: `
var o = {}, r = 0;
Object.defineProperty(o, 'foo', {value: 'bar'});
var desc = Object.getOwnPropertyDescriptor(o, 'foo');
desc.value === o.foo &&
!desc.writable && !desc.enumerable && !desc.configurable;
`,
expected: true,
},
{
name: 'Object.getOwnPropertyNames()',
src: `
try {
Object.getOwnPropertyNames();
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
{
name: 'Object.getOwnPropertyNames string',
src: `
var i, r = 0, names = Object.getOwnPropertyNames('foo');
for (i = 0; i < names.length; i++) {
if (names[i] === 'length') {
r += 10;
} else {
r += Number(names[i]) + 1;
}
}
`,
expected: 16,
},
{src: `Object.getOwnPropertyNames(42).length`, expected: 0},
{src: `Object.getOwnPropertyNames(true).length`, expected: 0},
{
name: 'Object.getOwnPropertyNames(null)',
src: `
try {
Object.getOwnPropertyNames(null).length;
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
{
name: 'Object.getOwnPropertyNames(undefined)',
src: `
try {
Object.getOwnPropertyNames(undefined).length;
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
{
name: 'Object.getOwnPropertyNames',
src: `
var o = Object.create({baz: 999});
o.foo = 42;
Object.defineProperty(o, 'bar', {value: 38});
var keys = Object.getOwnPropertyNames(o);
var r = 0;
for (var i = 0; i < keys.length; i++) {
r += o[keys[i]];
}
r;
`,
expected: 80,
},
{
name: 'Object.defineProperties()',
src: `
try {
Object.defineProperties();
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
{
name: 'Object.defineProperties non-object',
src: `
try {
Object.defineProperties('not an object', {});
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
{
name: 'Object.defineProperties non-object props',
src: `
try {
Object.defineProperties({}, undefined);
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
{
name: 'Object.defineProperties bad descriptor',
src: `
var o = {};
try {
Object.defineProperties(o, {foo: 'not an object'});
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
{
name: 'Object.defineProperties',
src: `
var o = {foo: 70}, r = 0;
Object.defineProperties(o, {
bar: {
writable: true,
enumerable: true,
configurable: true,
value: 8 },
baz: {value: 999}});
for (var k in o) {
r += o[k];
}
r + Object.getOwnPropertyNames(o).length;
`,
expected: 81,
},
{
name: 'Object.create(..., properties)',
src: `
var o = Object.create({foo: 70}, {
bar: {
writable: true,
enumerable: true,
configurable: true,
value: 10 },
baz: {value: 999}});
var r = 0;
for (var k in o) {
r += o[k];
}
r + Object.getOwnPropertyNames(o).length;
`,
expected: 82,
},
{
name: 'Object.assign',
src: `
var p = {x: 'inherited enumerable', y: 'inherited nonenumerable'};
var o = Object.create(p);
o.a = 'own enumerable';
o.b = 'own nonenumerable';
o.c = 'own enumerable';
Object.defineProperty(p, 'y', {enumerable: false});
Object.defineProperty(o, 'b', {enumerable: false});
var t = {a: 'to be overwritten', b: 'not overwritten', d: 'preserved'};
Object.assign(t, o, {e: 'extra'});
[Object.getOwnPropertyNames(t).length,
t.a, t.b, t.c, t.d, t.e].toString();
`,
expected:
'5,own enumerable,not overwritten,own enumerable,preserved,extra',
},
{
name: 'Object.getOwnPropertyNames',
src: `
var p = {x: 'inherited enumerable', y: 'inherited nonenumerable'};
var o = Object.create(p);
o.a = 'own enumerable';
o.b = 'own nonenumerable';
o.c = 'own enumerable';
Object.defineProperty(p, 'y', {enumerable: false});
Object.defineProperty(o, 'b', {enumerable: false});
Object.getOwnPropertyNames(o).toString();
`,
expected: 'a,b,c',
},
{
name: 'Object.keys',
src: `
var p = {x: 'inherited enumerable', y: 'inherited nonenumerable'};
var o = Object.create(p);
o.a = 'own enumerable';
o.b = 'own nonenumerable';
o.c = 'own enumerable';
Object.defineProperty(p, 'y', {enumerable: false});
Object.defineProperty(o, 'b', {enumerable: false});
Object.keys(o).toString();
`,
expected: 'a,c',
},
{
name: 'Object.prototype.toString',
src: `({}).toString();`,
expected: '[object Object]',
},
{
name: 'Object.protoype.hasOwnProperty',
src: `
var o = Object.create({baz: 999});
o.foo = 42;
Object.defineProperty(o, 'bar', {value: 41, enumerable: true});
var r = 0;
for (var key in o) {
if (!o.hasOwnProperty(key)) continue;
r += o[key];
}
r;
`,
expected: 83,
},
{
name: 'Object.protoype.isPrototypeOf primitives',
src: `
Boolean.prototype.isPrototypeOf(false) ||
Number.prototype.isPrototypeOf(0) ||
String.prototype.isPrototypeOf('') ||
Object.prototype.isPrototypeOf.call(false, false) ||
Object.prototype.isPrototypeOf.call(0, 0) ||
Object.prototype.isPrototypeOf.call('', '') ||
Object.prototype.isPrototypeOf.call(null, null) ||
Object.prototype.isPrototypeOf.call(undefined, undefined);
`,
expected: false,
},
{
name: 'Object.protoype.isPrototypeOf.call(null, ...)',
src: `
try {
Object.prototype.isPrototypeOf.call(null, Object.create(null));
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
{
name: 'Object.protoype.isPrototypeOf.call(undefined, ...)',
src: `
try {
Object.prototype.isPrototypeOf
.call(undefined, Object.create(undefined));
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
{
name: 'Object.protoype.isPrototypeOf self',
src: `var o = {}; o.isPrototypeOf(o);`,
expected: false,
},
{src: `Object.prototype.isPrototypeOf(Object.create(null))`, expected: false},
{
name: 'Object.protoype.isPrototypeOf related',
src: `
var g = {};
var p = Object.create(g);
var o = Object.create(p);
!o.isPrototypeOf({}) &&
g.isPrototypeOf(o) && p.isPrototypeOf(o) &&
!o.isPrototypeOf(p) && !o.isPrototypeOf(g);
`,
expected: true,
},
{
name: 'Object.protoype.propertyIsEnumerable(null)',
src: `
try {
Object.prototype.propertyIsEnumerable.call(null, '');
} catch(e) {
e.name;
}
`,
expected: 'TypeError',
},
{
name: 'ObjectProtoypePropertyIsEnumerableUndefined',
src: `
try {
Object.prototype.propertyIsEnumerable.call(undefined, '');
} catch(e) {
e.name;
}
`,
expected: 'TypeError',
},
{
name: 'Object.protoype.propertyIsEnumerable primitives',
src: `
var OppIE = Object.prototype.propertyIsEnumerable;
OppIE.call('foo', '0') && !OppIE.call('foo', 'length');
`,
expected: true,
},
{
name: 'Object.protoype.propertyIsEnumerable',
src: `
var o = {foo: 'foo'};
Object.defineProperty(o, 'bar', {value: 'bar', enumerable: false});
o.propertyIsEnumerable('foo') && !o.propertyIsEnumerable('bar') &&
!o.propertyIsEnumerable('baz');
`,
expected: true,
},
/////////////////////////////////////////////////////////////////////////////
// Function and Function.prototype
{
name: 'new Function() returns callable',
src: `new Function()();`,
expected: undefined,
},
{src: `(new Function()).length;`, expected: 0},
{src: `new Function().toString()`, expected: 'function anonymous(\n) {\n\n}'},
{
name: 'new Function(/* body */) returns callable',
src: `new Function('return 42;')();`,
expected: 42,
},
{
name: 'Function constructor accepts trailing line comments in body',
src: `typeof new Function('//');`,
expected: 'function',
},
{src: `new Function(/* body */).length;`, expected: 0},
{
src: `new Function('return 42;').toString()`,
expected: 'function anonymous(\n) {\nreturn 42;\n}'
},
{
name: 'new Function(/* args... */, /* body */) returns callable',
src: `new Function('a, b', 'c', 'return a + b * c;')(2, 3, 10);`,
expected: 32,
},
{
name: "(new Function('a, b', 'c', /* body */)).length",
src: `new Function('a, b', 'c', 'return a + b * c;').length;`,
expected: 3,
},
{
name: 'new Function(/* args... */, /* body */).toString()',
src: `new Function('a, b', 'c', 'return a + b * c;').toString()`,
expected: 'function anonymous(a, b,c\n) {\nreturn a + b * c;\n}',
},
{
name: 'Function constructor accepts non-ASCII parameter names',
src: `new Function('fußball', '').toString()`,
expected: 'function anonymous(fußball\n) {\n\n}',
},
{
name: 'Function constructor rejects non-unicode-letter parameter names',
src: `
try {
new Function('a…z', '');
} catch (e) {
e.name;
}
`,
expected: 'SyntaxError',
},
{
name: 'Function constructor accepts block comments in parameter list',
src: `new Function('a, /*test*/b', 'c', 'return a + b * c;')(2, 4, 10)`,
expected: 42,
},
{
name: 'Function constructor accepts line comments in parameter list',
src: `new Function('a, b', 'c //test', 'return a + b * c;')(2, 4, 10)`,
expected: 42,
},
{
name: 'Function constructor parameter line comments hide later parameters',
src: `new Function('dummy //', 'escape', 'return typeof escape')(0, 0);`,
expected: 'function',
},
{
name: 'Function.prototype has no .prototype',
src: `Function.prototype.hasOwnProperty('prototype');`,
expected: false,
},
{
src: `Function.prototype.toString()`,
expected: 'function () { [native code] }'
},
{
name: 'Function.prototype.toString.call(/* non-function */) throws',
src: `
try {
Function.prototype.toString.call({});
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
{
name: 'Function.prototype.toSting on NativeFunction',
src: `escape.toString();`,
expected: 'function escape() { [native code] }',
},
{
name: 'Function.prototype.toSting on modified NativeFunction',
destructive: true, // Modifies escape.
src: `
// Delete escape's original .name make it inherit a new one.
delete escape.name;
Object.setPrototypeOf(escape, function parent() {});
escape.toString();
`,
expected: 'function escape() { [native code] }',
},
{
name: 'Function.prototype.apply.call(/* non-function */) throws',
src: `
try {
Function.prototype.apply.call({});
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
{
name: 'Function.prototype.apply this',
src: `
var o = {};
function f() {return this;}
f.apply(o, []) === o;
`,
expected: true,
},
{
name: 'Function.prototype.apply(..., undefined) or null',
src: `
var n = 0;
function f() {n += arguments.length;}
f.apply(undefined, undefined);
f.apply(undefined, null);
n;
`,
expected: 0,
},
{
name: 'Function.prototype.apply(..., /* non-object */) throws',
src: `
try {
(function() {}).apply(undefined, 'not an object');
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
{
name: 'Function.prototype.apply(..., /* sparse array */)',
src: `
(function(a, b, c) {
if (!(1 in arguments)) {
throw new Error('arguments[1] missing');
}
return a + c;
}).apply(undefined, [1, , 3]);
`,
expected: 4,
},
{
name: 'Function.prototype.apply(..., /* array-like */)',
src: `
(function(a, b, c) {
return a + b + c;
}).apply(undefined, {0: 1, 1: 2, 2: 3, length: 3});
`,
expected: 6,
},
{
name: 'Function.prototype.apply(..., /* non-array-like */)',
src: `
(function(a, b, c) {
return a + b + c;
}).apply(undefined, {0: 1, 1: 2, 2: 4});
`,
expected: NaN // Because undefined + undefined === NaN.,
},
{
name: 'Function.prototype.call.call(/* non-function */) throws',
src: `
try {
Function.prototype.call.call({});
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
{
name: 'Function.prototype.call this',
src: `
var o = {};
function f() {return this;}
f.call(o) === o;
`,
expected: true,
},
{
name: 'Function.prototype.call() gives arguments.length === 0',
src: `(function() {return arguments.length;}).call();`,
expected: 0,
},
{
name: 'Function.prototype.call(..., /* sparse array */)',
src: `
(function(a, b, c) {
if (!(1 in arguments)) {
throw new Error('Argument 1 missing');
}
return a + c;
}).call(undefined, 1, 2, 3);
`,
expected: 4,
},
{
name: 'Function.prototype.bind.call(/* non-function */) throws',
src: `
try {
Function.prototype.bind.call({});
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
{
name: 'Function.prototype.bind this',
src: `
var o = {};
function f() {return this;}
f.bind(o)() === o;
`,
expected: true,
},
{
name: 'Function.prototype.bind no args',
src: `(function() {return arguments.length;}).bind()();`,
expected: 0,
},
{
name: 'Function.prototype.bind',
src: `
var d = 4;
(function(a, b, c) {
return a + b + c + d;
}).bind(undefined, 1).bind(undefined, 2)(3);
`,
expected: 10,
},
{
name: 'Function.prototype.bind call BF',
src: `
var constructed;
function Foo() {constructed = (this instanceof Foo)}
var f = Foo.bind();
f();
constructed;
`,
expected: false,
},
{
name: 'Function.prototype.bind construct BF',
src: `
var constructed;
function Foo() {constructed = (this instanceof Foo)}
var f = Foo.bind();
new f;
constructed;
`,
expected: true,
},
{
name: 'Function.prototype.call.bind construct BF',
src: `
var invoked;
function Foo() {invoked = true};
var f = Foo.call.bind(Foo);
try {
new f;
} catch (e) {
!invoked && e.name;
}
`,
expected: 'TypeError',
},
// N.B.: tests of semantics of class constructors are unavoidably ES6.
{
name: 'Function.prototype.bind class constructor w/o new',
src: `
var f = WeakMap.bind(); // Should be O.K.
try {
f();
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
// N.B.: tests of semantics of class constructors are unavoidably ES6.
{
name: 'Function.prototype.bind class constructor',
src: `String(new (WeakMap.bind()));`,
expected: '[object WeakMap]',
},
/////////////////////////////////////////////////////////////////////////////
// Array and Array.prototype
{
name: 'new Array()',
src: `var a = new Array(); Array.isArray(a) && a.length;`,
expected: 0,
},
{
name: 'newArray(/* number */)',
src: `
var a = new Array(42);
Array.isArray(a) && !(0 in a) && !(41 in a) && a.length;
`,
expected: 42,
},
{
name: 'new Array(/* non-number */)',
src: `
var a = new Array('foo');
Array.isArray(a) && a.length === 1 && a[0];
`,
expected: 'foo',
},
{
name: 'new Array(/* multiple args */)',
src: `
var a = new Array(1, 2, 3);
Array.isArray(a) && a.length === 3 && String(a);
`,
expected: '1,2,3',
},
{src: `Array.isArray(Array.prototype);`, expected: true},
{src: `Array.isArray(new Array);`, expected: true},
{src: `Array.isArray([]);`, expected: true},
{src: `Array.isArray({0: 'foo', 1: 'bar', length: 2});`, expected: false},
{
name: 'Array.prototype.concat()',
src: `
var a = ['foo', 'bar', 'baz', , 'quux', 'quuux'];
var c = a.concat();
a.length === 6 && c.length === 6 && c !== a && String(c);
`,
expected: 'foo,bar,baz,,quux,quuux',
},
{
name: 'Array.prototype.concat(...)',
src: `
var o = {0: 'quux', 1: 'quuux', length: 2};
var c = [].concat(['foo', 'bar'], 'baz', undefined, o);
c.length === 5 && '3' in c && c[3] === undefined && String(c);
`,
expected: 'foo,bar,baz,,[object Object]',
},
{
name: 'Array.prototype.concat.call(object, ...)',
src: `
var o = {0: 'foo', 1: 'bar', length: 2};
var c = Array.prototype.concat.call(o, 'baz', [, 'quux', 'quuux']);
c.length === 5 && String(c);
`,
expected: '[object Object],baz,,quux,quuux',
},
{src: `[1, 2, 3, 2, 1].includes(2);`, expected: true},
{src: `[1, 2, 3, 2, 1].includes(4);`, expected: false},
{
name: 'Array.prototype.includes fromIndex',
src: `[1, 2, 3, 2, 1].includes(2, 2);`,
expected: true,
},
{
name: 'Array.prototype.includes negative fromIndex',
src: `[1, 2, 3, 2, 1].includes(1, -3);`,
expected: true,
},
{src: `['x', NaN, 'y'].includes(NaN);`, expected: true},
{
name: 'Array.prototype.includes.call(array-like, ...)',
src: `
var o = {0: 1, 1: 2, 2: 3, 3: 2, 4: 1, length: 5};
Array.prototype.includes.call(o, 2);
`,
expected: true,
},
{
name: 'Array.prototype.indexOf',
src: `[1, 2, 3, 2, 1].indexOf(2);`,
expected: 1,
},
{
name: 'Array.prototype.indexOf not found',
src: `[1, 2, 3, 2, 1].indexOf(4);`,
expected: -1,
},
{
name: 'Array.prototype.indexOf fromIndex',
src: `[1, 2, 3, 2, 1].indexOf(2, 2);`,
expected: 3,
},
{
name: 'Array.prototype.indexOf negative fromIndex',
src: `[1, 2, 3, 2, 1].indexOf(1, -3);`,
expected: 4,
},
{
name: 'Array.prototype.indexOf NaN',
src: `['x', NaN, 'y'].indexOf(NaN);`,
expected: -1,
},
{
name: 'Array.prototype.indexOf.call(array-like, ...)',
src: `
var o = {0: 1, 1: 2, 2: 3, 3: 2, 4: 1, length: 5};
Array.prototype.indexOf.call(o, 2);
`,
expected: 1,
},
{
name: 'Array.prototype.join',
src: `[1, 2, 3].join('-');`,
expected: '1-2-3',
},
{
name: 'Array.prototype.join cycle detection',
src: `
var a = [1, , 3];
a[1] = a;
a.join('-');
"Didn't crash!";
`,
expected: 'Didn\'t crash!',
},
{
name: 'Array.prototype.lastIndexOf',
src: `[1, 2, 3, 2, 1].lastIndexOf(2);`,
expected: 3,
},
{
name: 'Array.prototype.lastIndexOf not found',
src: `[1, 2, 3, 2, 1].lastIndexOf(4);`,
expected: -1,
},
{
name: 'Array.prototype.lastIndexOf(..., +)',
src: `[1, 2, 3, 2, 1].lastIndexOf(2, 2);`,
expected: 1,
},
{
name: 'Array.prototype.lastIndexOf(..., -)',
src: `[1, 2, 3, 2, 1].lastIndexOf(1, -3);`,
expected: 0,
},
{
name: 'Array.prototype.lastIndexOf.call(array-like, ...)',
src: `
var o = {0: 1, 1: 2, 2: 3, 3: 2, 4: 1, length: 5};
Array.prototype.lastIndexOf.call(o, 2);
`,
expected: 3,
},
{
name: 'Array.prototype.pop',
src: `
var a = ['foo', 'bar', 'baz'];
var r = a.pop();
a.length === 2 && r;
`,
expected: 'baz',
},
{
name: 'Array.prototype.pop empty array',
src: `
var a = [];
var r = a.pop();
a.length === 0 && r;
`,
expected: undefined,
},
{
name: 'Array.prototype.pop.apply(array-like)',
src: `
var o = {0: 'foo', 1: 'bar', 2: 'baz', length: 3};
var r = Array.prototype.pop.apply(o);
o.length === 2 && r;
`,
expected: 'baz',
},
{
name: 'Array.prototype.pop.apply(empty array-like)',
src: `
var o = {length: 0};
var r = Array.prototype.pop.apply(o);
o.length === 0 && r;
`,
expected: undefined,
},
{
name: 'Array.prototype.pop.apply(huge array-like)',
src: `
var o = {5000000000000000: 'foo',
5000000000000001: 'quux',
length: 5000000000000002};
var r = Array.prototype.pop.apply(o);
o.length === 5000000000000001 && o[5000000000000000] === 'foo' && r;
`,
expected: 'quux',
},
{
name: 'Array.prototype.push',
src: `
var a = [];
a.push('foo') === 1 && a.push('bar') === 2 &&
a.length === 2 && a[0] === 'foo' && a[1] === 'bar';
`,
expected: true,
},
{
name: 'Array.prototype.push.call(array-like, ...)',
src: `
var o = {length: 0};
Array.prototype.push.call(o, 'foo') === 1 &&
Array.prototype.push.call(o, 'bar') === 2 &&
o.length === 2 && o[0] === 'foo' && o[1] === 'bar';
`,
expected: true,
},
{
name: 'Array.prototype.push.call(huge array-like, ...)',
src: `
var o = {length: 5000000000000000};
var o = {length: 5000000000000000};
Array.prototype.push.call(o, 'foo') === 5000000000000001 &&
Array.prototype.push.call(o, 'bar') === 5000000000000002 &&
o[5000000000000000] === 'foo' && o[5000000000000001] === 'bar' &&
o.length === 5000000000000002
`,
expected: true,
},
{
name: 'Array.prototype.reverse odd-length',
src: `
var a = [1, 2, 3];
a.reverse() === a && a.length === 3 && String(a);
`,
expected: '3,2,1',
},
{
name: 'Array.prototype.reverse even-length',
src: `
var a = [1, 2, , 4];
a.reverse() === a && a.length === 4 && String(a);
`,
expected: '4,,2,1',
},
{
name: 'Array.prototype.reverse empty',
src: `
var a = [];
a.reverse() === a && a.length;
`,
expected: 0,
},
{
name: 'Array.prototype.reverse.call(odd-length array-like)',
src: `
var o = {0: 1, 1: 2, 2: 3, length: 3};
Array.prototype.reverse.call(o) === o && o.length === 3 &&
Array.prototype.slice.apply(o).toString();
`,
expected: '3,2,1',
},
{
name: 'Array.prototype.reverse.call(even-length array-like)',
src: `
var o = {0: 1, 1: 2, 3: 4, length: 4};
Array.prototype.reverse.call(o) === o && o.length === 4 &&
Array.prototype.slice.apply(o).toString();
`,
expected: '4,,2,1',
},
{
name: 'Array.prototype.reverse.call(empty array-like)',
src: `
var o = {length: 0};
Array.prototype.reverse.call(o) === o && o.length;
`,
expected: 0,
},
{
name: 'Array.prototype.shift',
src: `
var a = ['foo', 'bar', 'baz'];
var r = a.shift();
a.length === 2 && a[0] === 'bar' && a[1] === 'baz' && r;
`,
expected: 'foo',
},
{
name: 'Array.prototype.shift empty array',
src: `
var a = [];
var r = a.shift();
a.length === 0 && r;
`,
expected: undefined,
},
{
name: 'Array.prototype.shift.apply(array-like)',
src: `
var o = {0: 'foo', 1: 'bar', 2: 'baz', length: 3};
var r = Array.prototype.shift.apply(o);
o.length === 2 && o[0] === 'bar' && o[1] === 'baz' && r;
`,
expected: 'foo',
},
{
name: 'Array.prototype.shift.apply(empty array-like)',
src: `
var o = {length: 0};
var r = Array.prototype.shift.apply(o);
o.length === 0 && r;
`,
expected: undefined,
},
{
name: 'Array.prototype.shift.apply(huge array-like)',
src: `
var o = {5000000000000000: 'foo',
5000000000000001: 'quux',
length: 5000000000000002};
var r = Array.prototype.shift.apply(o);
o.length === 5000000000000001 && o[5000000000000000] === 'quux' && r;
`,
// SKIP until more efficient shift implementation available.
/* expected: 'foo' */
},
{
name: 'Array.prototype.slice()',
src: `
var a = ['foo', 'bar', 'baz', , 'quux', 'quuux'];
var s = a.slice();
a.length === 6 && s.length === 6 && String(s);
`,
expected: 'foo,bar,baz,,quux,quuux',
},
{
name: 'Array.prototype.slice(-)',
src: `
var a = ['foo', 'bar', 'baz', , 'quux', 'quuux'];
var s = a.slice(-2);
a.length === 6 && s.length === 2 && String(s);
`,
expected: 'quux,quuux',
},
{
name: 'Array.prototype.slice(+, +)',
src: `
var a = ['foo', 'bar', 'baz', , 'quux', 'quuux'];
var s = a.slice(1, 4);
a.length === 6 && s.length === 3 && !('2' in s) && String(s);
`,
expected: 'bar,baz,',
},
{
name: 'Array.prototype.slice(+, -)',
src: `
var a = ['foo', 'bar', 'baz', , 'quux', 'quuux'];
var s = a.slice(1, -2);
a.length === 6 && s.length === 3 && !('2' in s) && String(s);
`,
expected: 'bar,baz,',
},
{
name: 'Array.prototype.slice.call(array-like, -, +)',
src: `
var o = {
0: 'foo', 1: 'bar', 2: 'baz', 4: 'quux', 5: 'quuux', length: 6
};
var s = Array.prototype.slice.call(o, -5, 4);
!Array.isArray(o) && o.length === 6 &&
Array.isArray(s) && s.length === 3 && !('2' in s) && String(s);
`,
expected: 'bar,baz,',
},
{
name: 'Array.prototype.slice.call(huge array-like, -, -)',
src: `
var o = {
5000000000000000: 'foo', 5000000000000001: 'bar',
5000000000000002: 'baz', 5000000000000004: 'quux',
5000000000000005: 'quuux', length: 5000000000000006
};
var s = Array.prototype.slice.call(o, -5, -2);
!Array.isArray(o) && o.length === 5000000000000006 &&
Array.isArray(s) && s.length === 3 && !('2' in s) && String(s);
`,
expected: 'bar,baz,',
},
{
name: 'Array.prototype.sort()',
src: `[5, 2, 3, 1, 4].sort().join(); // Sorts ASCIIbetically.`,
expected: '1,2,3,4,5',
},
{
name: 'Array.prototype.sort() compaction',
src: `
['z', undefined, 10, , 'aa', null, 'a', 5, NaN, , 1].sort()
.map(String).join();
`,
expected: '1,10,5,NaN,a,aa,null,z,undefined,,',
},
{
name: 'Array.prototype.sort(/* comparefn */)',
src: `
[99, 9, 10, 11, 1, 0, 5]
.sort(function(a, b) {return a - b;}).join();
`,
expected: '0,1,5,9,10,11,99',
},
{
name: 'Array.prototype.sort(/* comparefn */) compaction',
src: `
['z', undefined, 10, , 'aa', null, 'a', 5, NaN, , 1]
.sort(function(a, b) {
// Try to put undefineds first - should not succeed.
if (a === undefined) return b === undefined ? 0 : -1;
if (b === undefined) return 1;
// Reverse order of ususal sort.
a = String(a);
b = String(b);
if (a > b) return -1;
if (b > a) return 1;
return 0;
}).map(String).join();
`,
expected: 'z,null,aa,a,NaN,5,10,1,undefined,,',
},
{
name: 'Array.prototype.splice()',
src: `
var a = ['foo', 'bar', 'baz', , 'quux', 'quuux'];
var s = a.splice();
a.length === 6 && s.length === 0 && String(a) + ':' + String(s);
`,
expected: 'foo,bar,baz,,quux,quuux:',
},
{
name: 'Array.prototype.splice(-)',
src: `
var a = ['foo', 'bar', 'baz', , 'quux', 'quuux'];
var s = a.splice(-2);
a.length === 4 && s.length === 2 && String(a) + ':' + String(s);
`,
expected: 'foo,bar,baz,:quux,quuux',
},
{
name: 'Array.prototype.splice(+, +, ...)',
src: `
var a = ['foo', 'bar', 'baz', , 'quux', 'quuux'];
var s = a.splice(1, 3, 'bletch');
a.length === 4 && s.length === 3 && String(a) + ':' + String(s);
`,
expected: 'foo,bletch,quux,quuux:bar,baz,',
},
{
name: 'Array.prototype.splice.call(array-like, 0, large, ...)',
src: `
var o = {
0: 'foo', 1: 'bar', 2: 'baz', 4: 'quux', 5: 'quuux', length: 6
};
var s = Array.prototype.splice.call(o, 0, 100, 'bletch');
!Array.isArray(o) && o.length === 1 && Object.keys(o).length === 2 &&
o[0] === 'bletch' &&
Array.isArray(s) && s.length === 6 && !('3' in s) && String(s);
`,
expected: 'foo,bar,baz,,quux,quuux',
},
{
name: 'Array.prototype.splice.call(huge array-like, -, -, many...)',
src: `
var o = {
5000000000000000: 'foo', 5000000000000001: 'bar',
5000000000000002: 'baz', 5000000000000004: 'quux',
5000000000000005: 'quuux', length: 5000000000000006
};
var s = Array.prototype.splice.call(o, -2, -999, 'bletch', 'qux');
!Array.isArray(o) && o.length === 5000000000000008 &&
o[5000000000000004] === 'bletch' && o[5000000000000005] === 'qux' &&
o[5000000000000006] === 'quux' && o[5000000000000007] === 'quuux' &&
Array.isArray(s) && s.length === 0;
`,
expected: true,
},
{
name: 'Array.prototype.toString cycle detection',
src: `
var a = [1, , 3];
a[1] = a;
a.toString();
"Didn't crash!";
`,
expected: 'Didn\'t crash!',
},
{
name: 'Array.prototype.toString.call(obj-w/join)',
src: `Array.prototype.toString.apply({join: function() {return 'OK';}});`,
expected: 'OK',
},
{
name: 'Array.prototype.toString.call(array-like)',
src: `Array.prototype.toString.apply({0: 'foo', 1: 'bar', length: 2});`,
expected: '[object Object]',
},
{
name: 'Array.prototype.unshift',
src: `
var a = [];
a.unshift('foo') === 1 && a.unshift('bar') === 2 &&
a.length === 2 && a[0] === 'bar' && a[1] === 'foo';
`,
expected: true,
},
{
name: 'Array.prototype.unshift.call(array-like, ...)',
src: `
var o = {length: 0};
Array.prototype.unshift.call(o, 'foo') === 1 &&
Array.prototype.unshift.call(o, 'bar') === 2 &&
o.length === 2 && o[0] === 'bar' && o[1] === 'foo';
`,
expected: true,
},
{
name: 'Array.prototype.unshift.call(huge array-like, ...)',
src: `
var o = {length: 5000000000000000};
var o = {length: 5000000000000000};
Array.prototype.unshift.call(o, 'foo') === 5000000000000001 &&
Array.prototype.push.call(o, 'bar') === 5000000000000002 &&
o[5000000000000000] === 'bar' && o[5000000000000001] === 'foo' &&
o.length === 5000000000000002
`,
// SKIP until more efficient unshift implementation available.
/* expected: true */
},
/////////////////////////////////////////////////////////////////////////////
// Boolean and Boolean.prototype
{src: `Boolean(undefined);`, expected: false},
{src: `Boolean(null);`, expected: false},
{src: `Boolean(false);`, expected: false},
{src: `Boolean(true);`, expected: true},
{src: `Boolean(NaN);`, expected: false},
{src: `Boolean(0);`, expected: false},
{src: `Boolean(1);`, expected: true},
{src: `Boolean('');`, expected: false},
{src: `Boolean('foo');`, expected: true},
{src: `Boolean({});`, expected: true},
{src: `Boolean([]);`, expected: true},
{src: `Boolean(function() {});`, expected: true},
{src: `Boolean.prototype.toString();`, expected: 'false'},
{src: `Boolean.prototype.toString.call(true);`, expected: 'true'},
{src: `Boolean.prototype.toString.call(false);`, expected: 'false'},
{
name: 'Boolean.prototype.toString.call non-Boolean object',
src: `
try {
Boolean.prototype.toString.call({});
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
{src: `Boolean.prototype.valueOf();`, expected: false},
{src: `Boolean.prototype.valueOf.call(true);`, expected: true},
{src: `Boolean.prototype.valueOf.call(false);`, expected: false},
{
name: 'Boolean.prototype.valueOf.call non-Boolean object',
src: `
try {
Boolean.prototype.valueOf.call({});
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
/////////////////////////////////////////////////////////////////////////////
// Number and Number.prototype
{src: `Number();`, expected: 0},
{src: `Number(undefined);`, expected: NaN},
{src: `Number(null);`, expected: 0},
{src: `Number(true);`, expected: 1},
{src: `Number(false);`, expected: 0},
{src: `Number('42');`, expected: 42},
{src: `Number('');`, expected: 0},
{src: `Number({});`, expected: NaN},
{src: `Number([]);`, expected: 0},
{src: `Number([42]);`, expected: 42},
{src: `Number([1,2,3]);`, expected: NaN},
{src: `Number(function() {});`, expected: NaN},
{
name: 'Number.MAX_SAFE_INTEGER',
src: `
Number.MAX_SAFE_INTEGER + 1 === Math.pow(2, 53) &&
Number.isSafeInteger(Number.MAX_SAFE_INTEGER) &&
!Number.isSafeInteger(Number.MAX_SAFE_INTEGER + 1);
`,
expected: true,
},
{src: `Number.prototype.toString();`, expected: '0'},
{src: `Number.prototype.toString.call(84);`, expected: '84'},
{
name: 'Number.prototype.toString.call non-Number object',
src: `
try {
Number.prototype.toString.call({});
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
{src: `Number.prototype.valueOf();`, expected: 0},
{src: `Number.prototype.valueOf.call(85);`, expected: 85},
{
name: 'Number.prototype.valueOf.call non-Number object',
src: `
try {
Number.prototype.valueOf.call({});
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
/////////////////////////////////////////////////////////////////////////////
// String and String.prototype
{src: `String();`, expected: ''},
{src: `String(undefined);`, expected: 'undefined'},
{src: `String(null);`, expected: 'null'},
{src: `String(true);`, expected: 'true'},
{src: `String(false);`, expected: 'false'},
{src: `String(0);`, expected: '0'},
{src: `String(-0);`, expected: '0'},
{src: `String(Infinity);`, expected: 'Infinity'},
{src: `String(-Infinity);`, expected: '-Infinity'},
{src: `String(NaN);`, expected: 'NaN'},
{src: `String({});`, expected: '[object Object]'},
{src: `String([1, 2, 3,,5]);`, expected: '1,2,3,,5'},
{
name: 'String calls valueOf',
src: `
var o = Object.create(null);
o.valueOf = function() {return 'OK';};
String(o);
`,
expected: 'OK',
},
{
name: 'String calling valueOf returns string',
src: `
var o = Object.create(null);
o.valueOf = function() {return 42;};
String(o);
`,
expected: '42',
},
{
name: 'String calling valueOf throws',
src: `
var o = Object.create(null);
o.valueOf = function() {return {};};
try {
String(o);
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
{
name: 'String calls toString',
src: `
var o = Object.create(null);
o.valueOf = function() {return 'Whoops: called valueOf';};
o.toString = function() {return 'OK';};
String(o);
`,
expected: 'OK',
},
{
name: 'String calling toString returns string',
src: `
var o = Object.create(null);
o.valueOf = function() {return 42;};
String(o);
`,
expected: '42',
},
{
name: 'String calling toString throws',
src: `
var o = Object.create(null);
o.valueOf = function() {return {};};
o.toString = function() {return {};};
try {
String(o);
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
{src: `String.prototype.length;`, expected: 0},
{
name: 'String.prototype.replace(string, string)',
src: `'xxxx'.replace('xx', 'y');`,
expected: 'yxx',
},
{
name: 'String.prototype.replace(regexp, string)',
src: `'xxxx'.replace(/(X)\\1/ig, 'y');`,
expected: 'yy',
},
{
name: 'String.prototype.replace(string, function)',
src: `
'xxxx'.replace('xx', function() {
return '[' + Array.prototype.join.apply(arguments) + ']';
});
`,
expected: '[xx,0,xxxx]xx',
},
{
name: 'String.prototype.replace(regexp, function)',
src: `
'xxxx'.replace(/(X)\\1/ig, function() {
return '[' + Array.prototype.join.apply(arguments) + ']';
});
`,
expected: '[xx,x,0,xxxx][xx,x,2,xxxx]',
},
{
name: 'String.prototype.search(string) not found',
src: `'hello'.search('H')`,
expected: -1,
},
{
name: 'String.prototype.search(string) found',
src: `'hello'.search('ll')`,
expected: 2,
},
{
name: 'String.prototype.search(regexp) not found',
src: `'hello'.search(/H/)`,
expected: -1,
},
{
name: 'String.prototype.search(regexp) found',
src: `'hello'.search(/(.)\\1/)`,
expected: 2,
},
{src: `String.prototype.toString();`, expected: ''},
{
name: 'String.prototype.toString.call primitive',
src: `String.prototype.toString.call('a string');`,
expected: 'a string',
},
{
name: 'String.prototype.toString.call non-String object',
src: `
try {
String.prototype.toString.call({});
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
{src: `String.prototype.valueOf();`, expected: ''},
{
name: 'String.prototype.valueOf.call primitive',
src: `String.prototype.valueOf.call('a string');`,
expected: 'a string',
},
{
name: 'String.prototype.valueOf.call non-String object',
src: `
try {
String.prototype.valueOf.call({});
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
/////////////////////////////////////////////////////////////////////////////
// RegExp
{src: `new RegExp(undefined).source`, expected: '(?:)'},
{src: `new RegExp(null).source`, expected: 'null'},
{src: `new RegExp(true).source`, expected: 'true'},
{src: `new RegExp(false).source`, expected: 'false'},
{src: `new RegExp('').source`, expected: '(?:)'},
{src: `new RegExp('foo').source`, expected: 'foo'},
{src: `new RegExp('0').source`, expected: '0'},
{src: `new RegExp({}).source`, expected: '[object Object]'},
{src: `new RegExp([]).source`, expected: '(?:)'},
{src: `RegExp(undefined).source`, expected: '(?:)'},
{src: `RegExp(null).source`, expected: 'null'},
{src: `RegExp(true).source`, expected: 'true'},
{src: `RegExp(false).source`, expected: 'false'},
{src: `RegExp('').source`, expected: '(?:)'},
{src: `RegExp('foo').source`, expected: 'foo'},
{src: `RegExp('0').source`, expected: '0'},
{src: `RegExp({}).source`, expected: '[object Object]'},
{src: `RegExp([]).source`, expected: '(?:)'},
// TODO(ES6):
// {src: `new RegExp('foo', '').flags`, expected: ''},
// {src: `new RegExp('foo', 'g').flags`, expected: 'g'},
// {src: `new RegExp('foo', 'i').flags`, expected: 'i'},
// {src: `new RegExp('foo', 'gi').flags`, expected: 'gi'},
// {src: `new RegExp('foo', 'm').flags`, expected: 'm'},
// {src: `new RegExp('foo', 'gm').flags`, expected: 'gm'},
// {src: `new RegExp('foo', 'im').flags`, expected: 'im'},
// {src: `new RegExp('foo', 'gim').flags`, expected: 'gim'},
{src: `new RegExp('foo', '').global`, expected: false},
{src: `new RegExp('foo', 'g').global`, expected: true},
{src: `new RegExp('foo', '').ignoreCase`, expected: false},
{src: `new RegExp('foo', 'i').ignoreCase`, expected: true},
{src: `new RegExp('foo', '').multiline`, expected: false},
{src: `new RegExp('foo', 'm').multiline`, expected: true},
{
name: "new RegExp('', 'x') throws",
src: `
try {
new RegExp('', 'x');
} catch (e) {
e.name;
}
`,
expected: 'SyntaxError',
},
{
name: "new RegExp('', 'gg') throws",
src: `
try {
new RegExp('', 'gg');
} catch (e) {
e.name;
}
`,
expected: 'SyntaxError',
},
// Check behaviour of RegExp when called with and without new, when
// pattern is itself a RegExp, and flags are or are not supplied.
{src: `var re = /foo/; new RegExp(re) === re;`, expected: false},
{src: `var re = /foo/; RegExp(re) === re;`, expected: true},
{src: `var re = /foo/; RegExp(re, 'm') === re;`, expected: false},
{src: `var re = /foo/m; RegExp(re, 'm') === re;`, expected: false},
{src: `var re = /foo/m; RegExp(re) === re;`, expected: true},
{
name: 'RegExp called as function checks .constructor',
src: `
function SubClass() {};
Object.setPrototypeOf(SubClass, RegExp);
Object.setPrototypeOf(SubClass.prototype, RegExp.prototype);
var re = /foo/;
re.constructor = SubClass;
RegExp(re) === re;
`,
expected: false,
},
// TODO(ES6):
// {src: `var re = /foo/m; RegExp(re, 'i').flags;`, expected: 'i'},
{src: `var re = /foo/m; RegExp(re, 'i').multiline;`, expected: false},
{src: `var re = /foo/m; RegExp(re, 'i').ignoreCase;`, expected: true},
// Check behaviour of RegExp.prototype methods.
{
name: 'RegExp.prototype.exec.call(undefined) throws',
src: `
try {
RegExp.prototype.exec.call(undefined, 'foo');
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
{
name: 'RegExp.prototype.exec.call(non-regexp) throws',
src: `
try {
RegExp.prototype.exec.call({}, 'foo');
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
{src: `/undefined/.exec(undefined).length;`, expected: 1},
{src: `/null/.exec(null).length;`, expected: 1},
{
name: 'RegExp.prototype.test.call(undefined) throws',
src: `
try {
RegExp.prototype.test.call(undefined);
} catch (e) {
e.name;
}
`,
expected: 'TypeError'
},
{
name: 'RegExp.prototype.test.call(/* non-regexp */) throws',
src: `
try {
RegExp.Prototype.test.call({}, 'foo');
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
/////////////////////////////////////////////////////////////////////////////
// Error and Error.prototype (and all the other native error types too)
{
name: 'new Error has .stack',
src: `
// Use eval to make parsing .stack easier.
var e = eval('new Error;');
var lines = e.stack.split('\\n');
lines[0].trim();
`,
expected: 'at "new Error;" 1:1',
},
{
name: 'thrown Error has .stack',
src: `
try {
(function buggy() {1 instanceof 2;})();
} catch (e) {
var lines = e.stack.split('\\n');
}
lines[0].trim();
`,
expected: 'at buggy 1:19',
},
{
name: 'Error .stack correctly reports anonymous function',
src: `
// Use eval to make parsing .stack easier.
var e = eval('(function() {return new Error;})()');
var lines = e.stack.split('\\n');
lines[0].trim();
`,
expected: 'at anonymous function 1:20',
},
// Bug #241.
{
name: 'Error .stack correctly blames MemberExpression',
src: `
function foo() {
switch (1) {
case 1:
return undefined.hasNoProperties;
}
}
try {
foo();
} catch (e) {
var lines = e.stack.split('\\n');
}
lines[0].trim();
`,
expected: 'at foo 4:20',
},
{
name: 'Error .stack correctly blames Identifier',
src: `
function foo() {
return undefinedVariable;
}
try {
foo();
} catch (e) {
var lines = e.stack.split('\\n');
}
lines[0].trim();
`,
expected: 'at foo 2:16',
},
/////////////////////////////////////////////////////////////////////////////
// JSON
{
name: 'JSON.parse(undefined) throws',
src: `
try {
JSON.parse(undefined);
} catch (e) {
e.name;
}
`,
expected: 'SyntaxError',
},
{src: `JSON.parse(null);`, expected: null},
{src: `JSON.parse(true);`, expected: true},
{src: `JSON.parse(false);`, expected: false},
{src: `JSON.parse(42);`, expected: 42},
{
name: "JSON.parse('') throws",
src: `
try {
JSON.parse('');
} catch (e) {
e.name;
}
`,
expected: 'SyntaxError',
},
{
name: 'JSON.parse([]) throws',
src: `
try {
JSON.parse([]); // Equivalent to JSON.parse('');
} catch (e) {
e.name;
}
`,
expected: 'SyntaxError',
},
{
name: 'JSON.parse({}) throws',
src: `
try {
JSON.parse({}); // Equivalent to JSON.parse('[object Object]');
} catch (e) {
e.name;
}
`,
expected: 'SyntaxError',
},
{src: `JSON.stringify(undefined);`, expected: undefined},
{src: `JSON.stringify(null);`, expected: 'null'},
{src: `JSON.stringify(true);`, expected: 'true'},
{src: `JSON.stringify(false);`, expected: 'false'},
{src: `JSON.stringify(42);`, expected: '42'},
{src: `JSON.stringify('string');`, expected: '"string"'},
{src: `JSON.stringify([1,2,,4]);`, expected: '[1,2,null,4]'},
{
name: 'JSON.stringify({...})',
src: `
JSON.stringify({
string: 'foo', number: 42, true: true, false: false, null: null,
object: {obj: {}, arr: []}, array: [{}, []] });
`,
expected: '{"string":"foo","number":42,"true":true,"false":false,' +
'"null":null,"object":{"obj":{},"arr":[]},"array":[{},[]]}',
},
{src: `JSON.stringify(function(){});`, expected: undefined},
{src: `JSON.stringify([function(){}]);`, expected: '[null]'},
{src: `JSON.stringify({f: function(){}});`, expected: '{}'},
{
name: 'JSON.stringify({...}, [/* filter array */])',
src: `
JSON.stringify({
string: 'foo', number: 42, true: true, false: false, null: null,
object: {obj: {}, arr: []}, array: [{}, []] },
['string', 'number']);
`,
expected: '{"string":"foo","number":42}',
},
{
name: 'JSON.stringify({...}, [...], /* space number */)',
src: `
JSON.stringify({
string: 'foo', number: 42, true: true, false: false, null: null,
object: {obj: {}, arr: []}, array: [{}, []] },
['string', 'number'], 2);
`,
expected: '{\n "string": "foo",\n "number": 42\n}',
},
{
name: 'JSON.stringify({...}, [...], /* space string */)',
src: `
JSON.stringify({
string: 'foo', number: 42, true: true, false: false, null: null,
object: {obj: {}, arr: []}, array: [{}, []] },
['string', 'number'], '--');
`,
expected: '{\n--"string": "foo",\n--"number": 42\n}',
},
{
name: 'JSON.stringify ignores nonenumerable properties',
src: `
var obj = {e: 'enumerable', ne: 'nonenumerable'};
Object.defineProperty(obj, 'ne', {enumerable: false});
JSON.stringify(obj);
`,
expected: '{"e":"enumerable"}',
},
{
name: 'JSON.stringify ignores inherited properties',
src: `JSON.stringify(Object.create({foo: 'bar'}));`,
expected: '{}',
},
{
name: 'JSON.stringify throws when value is cyclic',
src: `
var obj = {};
obj.circular = obj;
try {
JSON.stringify(obj);
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
/////////////////////////////////////////////////////////////////////////////
// Other built-in functions
{
name: 'decodeURI throws',
src: `
try {
decodeURI('%xy');
} catch (e) {
e.name;
}
`,
expected: 'URIError',
},
/////////////////////////////////////////////////////////////////////////////
// WeakMap
{
name: 'WeakMap',
src: `
var w = new WeakMap;
var p = {};
var o = Object.create(p);
var fails = 0;
!w.has(p) || fails++;
!w.delete(p) || fails++;
w.set(o, 'o') === w || fails++;
w.get(o) === 'o' || fails++;
w.get(p) === undefined || fails++;
w.has(o) || fails++;
w.delete(o) || fails++;
!w.has(o) || fails++;
fails;
`,
expected: 0,
},
{
name: 'WeakMap.prototype methods reject non-WeakMap this',
src: `
var w = new WeakMap;
var fails = 0;
function expectError(method, thisVal, args) {
try {
w[method].apply(thisVal, args);
fails++;
} catch (e) {
if (e.name !== 'TypeError') fails++;
}
}
var methods = ['delete', 'get', 'has', 'set'];
var values = [null, undefined, true, false, 0, 42, '', 'hi'];
for (var i = 0; i < methods.length; i++) {
var method = methods[i];
for (var j = 0; j < values.length; j++) {
var value = values[j];
expectError(method, value, [{}]); // Can't call method on non-WeakMap.
expectError(method, w, [value]); // Can't store non-object in WeakMap.
}
// WeakMap.prototype is an ordinary object, not a WeakMap.
expectError(method, WeakMap.prototpye, [{}]);
}
fails;
`,
expected: 0,
},
{
name: 'WeakMap',
src: `
var w = new WeakMap;
var p = {};
var o = Object.create(p);
var fails = 0;
!w.has(p) || fails++;
!w.delete(p) || fails++;
w.set(o, 'o') === w || fails++;
w.get(o) === 'o' || fails++;
w.get(p) === undefined || fails++;
w.has(o) || fails++;
w.delete(o) || fails++;
!w.has(o) || fails++;
fails;
`,
expected: 0,
},
/////////////////////////////////////////////////////////////////////////////
// Thread and Thread.prototype:
// TODO(cpallen): change .eval to .program when test harness no
// longer relies on eval.
{
name: 'Thread.callers() ownership',
src: `
var owner = {};
setPerms(owner);
var callers = Thread.callers();
Object.getOwnerOf(callers) === owner &&
Object.getOwnerOf(callers[0]) === owner;
`,
expected: true,
},
{
name: 'Thread.callers()[0].eval',
src: `Thread.callers()[0].eval`,
expected: 'Thread.callers()[0].eval',
},
{
name: 'Thread.callers()[0].line & .col',
src: `var frame = Thread.callers()[0]; frame.line + "," + frame.col;`,
expected: '1,13',
},
{
name: 'Thread.callers()[/* last */].program',
src: `
var callers = Thread.callers();
typeof callers[callers.length - 1].program;
`,
expected: 'string',
},
{
name: 'Thread.callers()[0].callerPerms',
src: `
CC.root.name = 'root';
var user = {name: 'user'};
function f() {
return Thread.callers()[0].callerPerms.name;
}
setPerms(user);
f();
`,
expected: 'user',
},
// Time limit tests. Actual enforcement is tested in
// interpreter_tests.js; this is just checking behaviour of get/set
// builtins.
{
name: 'Thread.prototype.getTimeLimit() initially 0',
src: `Thread.current().getTimeLimit();`,
expected: 0,
},
{
name: 'Thread.prototype.setTimeLimit()',
src: `
Thread.current().setTimeLimit(1000);
Thread.current().getTimeLimit();
`,
expected: 1000,
},
{
name: 'Thread.prototype.setTimeLimit(...)',
src: `
Thread.current().setTimeLimit(1000);
Thread.current().getTimeLimit();
`,
expected: 1000,
},
// Check invalid time limits are rejected.
{
name: 'Thread.prototype.setTimeLimit(/* invalid value */) throws',
src: `
Thread.current().setTimeLimit(1000);
var invalid = [0, 1001, NaN, 'foo', true, {}];
var failures = [];
for (var i = 0; i < invalid.length; i++) {
try {
Thread.current().setTimeLimit(invalid[i]);
failures.push(invalid[i]);
} catch (e) {
}
}
(failures.length === 0) ? 'OK' : String(failures);
`,
expected: 'OK',
},
/////////////////////////////////////////////////////////////////////////////
// Permissions system:
{
name: 'perms returns root',
src: `perms() === CC.root;`,
expected: true,
},
{
name: 'setPerms',
src: `
CC.root.name = 'Root';
var bob = {};
bob.name = 'Bob';
var r = '';
r += perms().name;
(function() {
setPerms(bob);
r += perms().name;
// Perms revert at end of scope.
})();
r += perms().name;
r;
`,
expected: 'RootBobRoot',
},
{
name: 'getOwnerOf',
src: `
var bob = {};
var roots = {};
setPerms(bob);
var bobs = new Object;
Object.getOwnerOf(Object) === CC.root &&
Object.getOwnerOf(roots) === CC.root &&
Object.getOwnerOf(bobs) === bob
`,
expected: true,
},
{
name: 'setOwnerOf',
src: `
var bob = {};
var obj = {};
Object.setOwnerOf(obj, bob) === obj && Object.getOwnerOf(obj) === bob;
`,
expected: true,
},
/////////////////////////////////////////////////////////////////////////////
// Other tests:
{
name: 'new hack',
src: `(new 'Array.prototype.push') === Array.prototype.push`,
expected: true,
},
{
name: 'new hack with unkown builtin',
src: `
try {
new 'nonexistent-builtin-name';
} catch (e) {
e.name;
}
`,
expected: 'ReferenceError',
},
{
name: 'new hack with other than string literal',
src: `
try {
var builtin = 'Object.prototype';
new builtin;
} catch (e) {
e.name;
}
`,
expected: 'TypeError',
},
{
name: 'ES6 causes syntax errors',
src: `
var tests = [
// Class statements & expressions
'class Foo{};',
'false && class Foo{};',
// Arrow functions.
'false && [].map((item) => String(item));',
// For-of statement.
'for (var x of [1, 2, 3]) {};',
// Let & const.
'let x;',
'const x;',
];
var failed = [];
for (var i = 0; i < tests.length; i++) {
try {
eval(tests[i]);
failed.push("Didn't throw: " + tests[i]);
} catch (e) {
if (e.name !== 'SyntaxError') {
failed.push('Wrong error: ' + tests[i] + ' threw ' + String(e));
}
}
}
failed.length ? failed.join('\\n') : 'OK';
`,
expected: 'OK',
},
{
name: 'Strict mode syntax errors',
src: `
var tests = [
// With statement.
'var o = {foo: 42}; var f = function() {with (o) {foo;}};',
// Binding eval in global scope, or arguments in a function.
'var eval = "rebinding eval?!?";',
'(function() {arguments = undefined;});',
// Duplicate argument names.
'(function(a, a) {});',
"new Function('a', 'a', '');",
// Octal numeric literals.
'0777;',
// Delete of unqualified or undeclared identifier.
'var foo; delete foo;',
'delete foo;',
];
var failed = [];
for (var i = 0; i < tests.length; i++) {
try {
eval(tests[i]);
failed.push("Didn't throw: " + tests[i]);
} catch (e) {
if (e.name !== 'SyntaxError') {
failed.push('Wrong error: ' + tests[i] + ' threw ' + String(e));
}
}
}
failed.length ? failed.join('\\n') : 'OK';
`,
expected: 'OK',
},
{
name: 'Stack overflow errors',
src: `
try {
(function f() {f();})();
} catch (e) {
e.name;
}
`,
options: {stackLimit: 100},
expected: 'RangeError',
},
{
name: 'Minimum stack depth limit',
src: `
function f() {
try {
return f() + 1;
} catch (e) {
return 1;
}
}
var limit = f();
limit > 100 ? 'OK' : limit;
`,
options: {stackLimit: 1000},
expected: 'OK',
},
];
================================================
FILE: server/tests/testing.js
================================================
/**
* @license
* Copyright 2018 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview General-purpose test infrastructure.
* @author cpcallen@google.com (Christopher Allen)
*/
'use strict';
const util = require('util');
///////////////////////////////////////////////////////////////////////////////
/**
* Class that records benchmark results; much like Go's testing.B type.
* @constructor
*/
function B() {
this.results = {};
}
/**
* Report a benchmark or test result.
* @param {string} status The test result status (e.g., 'OK', 'FAIL', 'SKIP').
* @param {string} name Name of test.
* @param {string=} message Additional information to lot about result.
*/
B.prototype.result = function(status, name, message) {
console.log('%s\t%s', status, name);
if (message) {
console.log(message);
}
this.results[status] = this.results[status] + 1 || 1;
};
/**
* Report a benchmark start.
* @param {string} name Name of test. (Not used.)
* @param {number} run Which run is this? (Run 0 is warm-up run.)
*/
B.prototype.start = function(name, run) {
const r = (run === 0) ? 'WARMUP' : ('RUN ' + run);
this.startTime = Date.now();
};
/**
* Report a benchmark end.
* @param {string} name Name of test.
* @param {number} run Which run is this? (Run 0 is warm-up run.)
*/
B.prototype.end = function(name, run) {
const endTime = Date.now();
const r = (run === 0) ? 'WARMUP' : ('RUN ' + run);
console.log('%s\t%s: %d ms', r, name, endTime - this.startTime);
this.startTime = Date.now();
};
/**
* Report a benchmark or test failure due to crash.
* @param {string} name Name of test.
* @param {string=} message Additional info (e.g., stack trace) to log.
*/
B.prototype.crash = function(name, message) {
this.result('CRASH', name, message);
};
/**
* Report a bench or test skip.
* @param {string} name Name of test.
* @param {string=} message Additional info to log.
*/
B.prototype.skip = function(name, message) {
this.result('SKIP', name, message);
};
/**
* Return results as string.
* @return {string}
*/
B.prototype.toString = function() {
const lines = ['Totals:'];
for (const status in this.results) {
lines.push(util.format('%s\t%d tests', status, this.results[status]));
}
return lines.join('\n');
};
///////////////////////////////////////////////////////////////////////////////
/**
* Class that records test results; much like Go's testing.T type.
* @constructor
* @extends {B}
*/
function T() {
B.call(this);
this.results['OK'] = 0;
this.results['FAIL'] = 0;
}
T.prototype = Object.create(B.prototype);
T.prototype.constructor = T;
/**
* Report a test result.
* @param {string} status The test result status (e.g., 'OK', 'FAIL', 'SKIP').
* @param {string} name Name of test.
* @param {string=} message Additional info to log.
*/
T.prototype.result = function(status, name, message) {
status === 'OK' || console.log('%s:\t%s', status, name);
if (message) {
console.log(message);
}
this.results[status] = this.results[status] + 1 || 1;
};
/**
* Report a test pass.
* @param {string} name Name of test.
* @param {string=} message Additional info to log.
*/
T.prototype.pass = function(name, message) {
this.result('OK', name, message);
};
/**
* Report a test failure.
* @param {string} name Name of test.
* @param {string=} message Additional info to log.
*/
T.prototype.fail = function(name, message) {
this.result('FAIL', name, message);
};
/**
* Check if assertion is true and nd record test pass if so or test
* failure otherwise.
* @param {string} name The name of the test.
* @param {*} assertion Condition to verify.
* @param {string=} message Additional info to log on failure only.
*/
T.prototype.assert = function(name, assertion, message) {
if (assertion) {
this.pass(name);
} else {
this.fail(name, message);
}
};
/**
* Check if Object.is(got, want) and record test pass if so or test
* failure otherwise.
* @param {string} name The name of the test.
* @param {*} got The actual result of the test.
* @param {*} want The expected result of the test.
* @param {string=} message Additional info to log on failure only.
*/
T.prototype.expect = function(name, got, want, message) {
if (Object.is(got, want)) {
this.pass(name);
} else {
message = message ? message + '\n' : '';
// Are they both strings, and at least one has multiple lines?
if (typeof(got) === 'string' && typeof(want) === 'string' &&
(got.trimRight().split('\n').length > 1 ||
want.trimRight().split('\n').length > 1)) {
message = util.format('%sgot:\n%s\nwant:\n%s', message, got, want);
} else {
message = util.format('%sgot %o want %o', message, got, want);
}
this.fail(name, message);
}
};
exports.B = B;
exports.T = T;
================================================
FILE: server/tests/tinycore/README
================================================
A very tiny database, just big enough to run an eval server.
================================================
FILE: server/tests/tinycore/core_00_es_minimal.js
================================================
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Polyfills to bring the server's partial JavaScript
* implementation up to JavaScript 5.1 (or close to it).
* @author fraser@google.com (Neil Fraser)
*/
// Global functions.
var parseInt = new 'parseInt';
var parseFloat = new 'parseFloat';
var isNaN = new 'isNaN';
var isFinite = new 'isFinite';
// Global objects.
var Object = new 'Object';
var Function = new 'Function';
var Array = new 'Array';
var String = new 'String';
var Boolean = new 'Boolean';
var Number = new 'Number';
var Date = new 'Date';
var RegExp = new 'RegExp';
var Error = new 'Error';
var EvalError = new 'EvalError';
var RangeError = new 'RangeError';
var ReferenceError = new 'ReferenceError';
var SyntaxError = new 'SyntaxError';
var TypeError = new 'TypeError';
var URIError = new 'URIError';
var Math = {};
var JSON = {};
// Bootstrap the defineProperty function in two steps.
Object.defineProperty = new 'Object.defineProperty';
Object.defineProperty(Object, 'defineProperty', {enumerable: false});
(function() {
// Hack to work around restriction that the 'new hack' only works on
// literal strings. Note name must not contain any double quotes or
// backslashes, because we have no easy way to escape them yet!
var builtin = function(name) {
return eval('new "' + name + '"');
};
var classes = ['Object', 'Function', 'Array', 'String', 'Boolean', 'Number',
'Date', 'RegExp', 'Error', 'EvalError', 'RangeError',
'ReferenceError', 'SyntaxError', 'TypeError', 'URIError'];
// Prototypes of global constructors.
for (var i = 0; i < classes.length; i++) {
var constructor = builtin(classes[i]);
Object.defineProperty(constructor, 'prototype', {
configurable: false,
enumerable: false,
writable: false,
value: builtin(classes[i] + '.prototype')
});
Object.defineProperty(constructor.prototype, 'constructor', {
configurable: true,
enumerable: false,
writable: true,
value: constructor
});
}
// Configure Error and its subclasses.
var errors = ['Error', 'EvalError', 'RangeError', 'ReferenceError',
'SyntaxError', 'TypeError', 'URIError'];
for (var i = 0; i < errors.length; i++) {
var constructor = builtin(errors[i]);
Object.defineProperty(constructor.prototype, 'name', {
configurable: true,
enumerable: false,
writable: true,
value: errors[i]
});
}
Object.defineProperty(Error.prototype, 'message', {
configurable: true,
enumerable: false,
writable: true,
value: ''
});
// Struct is a list of tuples:
// [Object, 'Object', [static methods], [instance methods]]
var struct = [
[Object, 'Object',
['create', 'getOwnPropertyNames', 'keys', 'getOwnPropertyDescriptor',
'getPrototypeOf', 'isExtensible', 'preventExtensions'],
['toString', 'toLocaleString', 'valueOf', 'hasOwnProperty',
'propertyIsEnumerable', 'isPrototypeOf']],
[Function, 'Function',
[],
['apply', 'bind', 'call', 'toString']],
[Array, 'Array',
['isArray'],
['toString', 'pop', 'push', 'shift', 'unshift', 'reverse', 'splice',
'slice', 'concat', 'indexOf', 'lastIndexOf']],
[String, 'String',
['fromCharCode'],
['trim', 'toLowerCase', 'toUpperCase', 'toLocaleLowerCase',
'toLocaleUpperCase', 'charAt', 'charCodeAt', 'substring', 'slice',
'substr', 'indexOf', 'lastIndexOf', 'concat', 'localeCompare', 'replace',
'split', 'match', 'search', 'replace', 'toString', 'valueOf']],
[Boolean, 'Boolean',
[],
['toString', 'valueOf']],
[Number, 'Number',
[],
['toExponential', 'toFixed', 'toLocaleString', 'toPrecision', 'toString',
'valueOf']],
[Date, 'Date',
['now', 'parse', 'UTC'],
['toString', 'getDate', 'getDay', 'getFullYear', 'getHours',
'getMilliseconds', 'getMinutes', 'getMonth', 'getSeconds', 'getTime',
'getTimezoneOffset', 'getUTCDate', 'getUTCDay', 'getUTCFullYear',
'getUTCHours', 'getUTCMilliseconds', 'getUTCMinutes', 'getUTCMonth',
'getUTCSeconds', 'getYear', 'setDate', 'setFullYear', 'setHours',
'setMilliseconds', 'setMinutes', 'setMonth', 'setSeconds', 'setTime',
'setUTCDate', 'setUTCFullYear', 'setUTCHours', 'setUTCMilliseconds',
'setUTCMinutes', 'setUTCMonth', 'setUTCSeconds', 'setYear',
'toDateString', 'toISOString', 'toJSON', 'toGMTString', 'toTimeString',
'toUTCString', 'toLocaleDateString', 'toLocaleString',
'toLocaleTimeString']],
[RegExp, 'RegExp',
[],
['toString', 'test', 'exec']],
[Error, 'Error',
[],
['toString']],
[Math, 'Math',
['abs', 'acos', 'asin', 'atan', 'atan2', 'ceil', 'cos', 'exp', 'floor',
'log', 'max', 'min', 'pow', 'random', 'round', 'sin', 'sqrt', 'tan'],
[]],
[JSON, 'JSON',
['parse', 'stringify'],
[]]
];
for (var i = 0; i < struct.length; i++) {
var obj = struct[i][0];
var objName = struct[i][1];
var staticMethods = struct[i][2];
var instanceMethods = struct[i][3];
for (var j = 0; j < staticMethods.length; j++) {
var member = staticMethods[j];
Object.defineProperty(obj, member,
{configurable: true,
enumerable: false,
writable: true,
value: builtin(objName + '.' + member)});
}
for (var j = 0; j < instanceMethods.length; j++) {
var member = instanceMethods[j];
Object.defineProperty(obj.prototype, member,
{configurable: true,
enumerable: false,
writable: true,
value: builtin(objName + '.prototype.' + member)});
}
}
})();
Object.defineProperty(Number, 'MAX_VALUE', {
configurable: false,
enumerable: false,
writable: false,
value: 1.7976931348623157e+308
});
Object.defineProperty(Number, 'MIN_VALUE', {
configurable: false,
enumerable: false,
writable: false,
value: 5e-324
});
Object.defineProperty(Number, 'NaN', {
configurable: false,
enumerable: false,
writable: false,
value: NaN
});
Object.defineProperty(Number, 'NEGATIVE_INFINITY', {
configurable: false,
enumerable: false,
writable: false,
value: -Infinity
});
Object.defineProperty(Number, 'POSITIVE_INFINITY', {
configurable: false,
enumerable: false,
writable: false,
value: Infinity
});
Object.defineProperty(Math, 'E', {
configurable: false,
enumerable: false,
writable: false,
value: 2.718281828459045
});
Object.defineProperty(Math, 'LN2', {
configurable: false,
enumerable: false,
writable: false,
value: 0.6931471805599453
});
Object.defineProperty(Math, 'LN10', {
configurable: false,
enumerable: false,
writable: false,
value: 2.302585092994046
});
Object.defineProperty(Math, 'LOG2E', {
configurable: false,
enumerable: false,
writable: false,
value: 1.4426950408889634
});
Object.defineProperty(Math, 'LOG10E', {
configurable: false,
enumerable: false,
writable: false,
value: 0.4342944819032518
});
Object.defineProperty(Math, 'PI', {
configurable: false,
enumerable: false,
writable: false,
value: 3.141592653589793
});
Object.defineProperty(Math, 'SQRT1_2', {
configurable: false,
enumerable: false,
writable: false,
value: 0.7071067811865476
});
Object.defineProperty(Math, 'SQRT2', {
configurable: false,
enumerable: false,
writable: false,
value: 1.4142135623730951
});
Object.defineProperty(RegExp.prototype, 'global', {
configurable: false,
enumerable: false,
writable: false,
value: undefined
});
Object.defineProperty(RegExp.prototype, 'ignoreCase', {
configurable: false,
enumerable: false,
writable: false,
value: undefined
});
Object.defineProperty(RegExp.prototype, 'multiline', {
configurable: false,
enumerable: false,
writable: false,
value: undefined
});
Object.defineProperty(RegExp.prototype, 'source', {
configurable: false,
enumerable: false,
writable: false,
value: '(?:)'
});
///////////////////////////////////////////////////////////////////////////////
// Array.prototype polyfills
///////////////////////////////////////////////////////////////////////////////
(function() {
// For cycle detection in array to string and error conversion; see
// spec bug github.com/tc39/ecma262/issues/289.
var visited = [];
Object.defineProperty(Array.prototype, 'join', {value: function(separator) {
// This implements Array.prototype.join from ES5 §15.4.4.5, with
// the addition of cycle detection as discussed in
// https://github.com/tc39/ecma262/issues/289.
//
// Variable names reflect those in the spec.
//
// N.B. This function is defined in a closure!
var isObj = (typeof this === 'object' || typeof this === 'function') &&
this !== null;
if (isObj) {
if (visited.indexOf(this) !== -1) {
return '';
}
visited.push(this);
}
try {
// TODO(cpcallen): setPerms(callerPerms());
var len = this.length >>> 0;
var sep = (separator === undefined) ? ',' : String(separator);
if (!len) {
return '';
}
var r = '';
for (var k = 0; k < len; k++) {
if (k > 0) r += sep;
var element = this[k];
if (element !== undefined && element !== null) {
r += String(element);
}
}
return r;
} finally {
if (isObj) visited.pop();
}
}, configurable: true, writable: true});
})();
///////////////////////////////////////////////////////////////////////////////
// String.prototype polyfills
///////////////////////////////////////////////////////////////////////////////
// String.prototype.length is always 0.
Object.defineProperty(String.prototype, 'length', {value: 0});
================================================
FILE: server/tests/tinycore/core_10_base.js
================================================
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Demonstration database for Code City.
* @author fraser@google.com (Neil Fraser)
*/
var $ = function() {
throw new Error('not implemented');
};
// System object: $.system
$.system = {};
$.system.connectionListen = new 'CC.connectionListen';
$.system.connectionUnlisten = new 'CC.connectionUnlisten';
$.system.connectionWrite = new 'CC.connectionWrite';
$.system.connectionClose = new 'CC.connectionClose';
$.system.xhr = new 'CC.xhr';
// Utility object: $.utils
$.utils = {};
$.connection = {};
$.connection.onConnect = function() {
this.user = null;
this.buffer = '';
};
$.connection.onReceive = function(text) {
this.buffer += text.replace(/\r/g, '');
var lf;
while ((lf = this.buffer.indexOf('\n')) !== -1) {
var line = this.buffer.substring(0, lf);
this.buffer = this.buffer.substring(lf + 1);
this.onReceiveLine(line);
}
};
$.connection.onReceiveLine = function(text) {
// Override this on child classes.
};
$.connection.onEnd = function() {
// Override this on child classes.
};
$.connection.write = function(text) {
$.system.connectionWrite(this, text);
};
$.connection.close = function() {
$.system.connectionClose(this);
};
$.servers = {};
================================================
FILE: server/tests/tinycore/core_13_$.utils.code.js
================================================
/**
* @license
* Copyright 2018 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Code utilities for Code City.
* @author fraser@google.com (Neil Fraser)
*/
$.utils.code = {};
$.utils.code.toSource = function(value, opt_seen) {
// Given an arbitrary value, produce a source code representation.
// Primitive values are straightforward: "42", "'abc'", "false", etc.
// Functions, RegExps, Dates, Arrays, and errors are returned as their
// definitions.
// Other objects and symbols are returned as selector expression.
// Throws if a code representation can't be made.
var type = typeof value;
if (value === undefined || value === null ||
type === 'number' || type === 'boolean') {
if (Object.is(value, -0)) {
return '-0';
}
return String(value);
} else if (type === 'string') {
return JSON.stringify(value);
} else if (type === 'function') {
return Function.prototype.toString.call(value);
} else if (type === 'object') {
// TODO: Replace opt_seen with Set, once available.
if (opt_seen) {
if (opt_seen.includes(value)) {
throw new RangeError('[Recursive data structure]');
}
opt_seen.push(value);
} else {
opt_seen = [value];
}
var proto = Object.getPrototypeOf(value);
if (proto === RegExp.prototype) {
return String(value);
} else if (proto === Date.prototype) {
return 'Date(\'' + value.toJSON() + '\')';
} else if (proto === Array.prototype && Array.isArray(value) &&
value.length <= 100) {
var props = Object.getOwnPropertyNames(value);
var data = [];
for (var i = 0; i < value.length; i++) {
if (props.includes(String(i))) {
try {
data[i] = $.utils.code.toSource(value[i], opt_seen);
} catch (e) {
// Recursive data structure. Bail.
data = null;
break;
}
} else {
data[i] = '';
}
}
if (data) {
return '[' + data.join(', ') + ']';
}
} else if (value instanceof Error) {
var constructor;
if (proto === Error.prototype) {
constructor = 'Error';
} else if (proto === EvalError.prototype) {
constructor = 'EvalError';
} else if (proto === RangeError.prototype) {
constructor = 'RangeError';
} else if (proto === ReferenceError.prototype) {
constructor = 'ReferenceError';
} else if (proto === SyntaxError.prototype) {
constructor = 'SyntaxError';
} else if (proto === TypeError.prototype) {
constructor = 'TypeError';
} else if (proto === URIError.prototype) {
constructor = 'URIError';
} else if (proto === PermissionError.prototype) {
constructor = 'PermissionError';
}
var msg;
if (value.message === undefined) {
msg = '';
} else {
try {
msg = $.utils.code.toSource(value.message, opt_seen);
} catch (e) {
// Leave msg undefined.
}
}
if (constructor && msg !== undefined) {
return constructor + '(' + msg + ')';
}
}
}
if (type === 'object' || type === 'symbol') {
// No Selectors in this tiny db, so just toString it.
return Object.prototype.toString.call(value);
}
// Can't happen.
throw new TypeError('[' + type + ']');
};
$.utils.code.eval = function(src, evalFunc) {
// Eval src and attempt to print the resulting value readably.
//
// Evaluation is done by calling evalFunc (passing src) if supplied,
// or by calling the eval built-in function (under a different name,
// so it operates in the global scope). Unhandled exceptions are
// caught and converted to a string.
//
// Caller may wish to transform input with
// $.utils.code.rewriteForEval before passing it to this function.
evalFunc = evalFunc || eval;
var out;
try {
out = evalFunc(src);
try {
// Attempt to print a source-legal representation.
out = $.utils.code.toSource(out);
} catch (e) {
try {
// Maybe it's something JSON can deal with (like an array).
out = JSON.stringify(out);
} catch (e) {
try {
// Maybe it's a recursive data structure.
out = String(out);
} catch (e) {
// Maybe it's Object.create(null).
out = '[Unprintable value]';
}
}
}
} catch (e) {
// Exception thrown. Use built-in ToString via + to avoid calling
// String, least it call a .toString method that itself throws.
// TODO(cpcallen): find an alternative way of doing this safely
// once the interpreter calls String for all string conversions.
if (e instanceof Error) {
out = 'Unhandled error: ' + e.name;
if (e.message) {
out += ': ' + e.message;
}
if (e.stack) {
out += '\n' + e.stack;
}
} else {
out = 'Unhandled exception: ' + e;
}
}
return out;
};
================================================
FILE: server/tests/tinycore/core_35_$.servers.eval.js
================================================
/**
* @license
* Copyright 2020 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Eval server for Code City.
* @author cpcallen@google.com (Christopher Allen)
*/
$.servers.eval = {};
$.servers.eval.connected = null;
$.servers.eval.connection = Object.create($.connection);
$.servers.eval.connection.onConnect = function() {
$.connection.onConnect.apply(this, arguments);
if ($.servers.eval.connected) {
$.servers.eval.connected.close();
}
$.servers.eval.connected = this;
this.write('eval> ');
};
$.servers.eval.connection.onReceiveLine = function(text) {
if (this !== $.servers.eval.connected) {
this.close();
return;
}
this.write('⇒ ' + $.utils.code.eval(text) + '\n');
this.write('eval> ');
};
$.servers.eval.connection.onEnd = function() {
$.servers.eval.connected = null;
return $.connection.onEnd.apply(this, arguments);
};
$.servers.eval.connection.close = function() {
this.write('This session has been terminated.\n');
return $.connection.close.apply(this, arguments);
};
$.system.connectionListen(9999, $.servers.eval.connection, 100);
================================================
FILE: server/tests/tinycore/dump_spec.json
================================================
[
{
"filename": "core_00_es_minimal.js",
"contents": [
{"path": "Object", "do": "SET"},
{"path": "Function", "do": "SET"},
{"path": "Object.defineProperty", "do": "ATTR"},
"Object",
"Function",
"Array",
"String",
"Boolean",
"Number",
"Date",
"RegExp",
"Error",
"EvalError",
"RangeError",
"ReferenceError",
"SyntaxError",
"TypeError",
"URIError",
"Math",
"JSON",
"isFinite",
"isNaN",
"parseFloat",
"parseInt"
]
}, {
"filename": "core_10_base.js",
"contents": [
{"path": "$", "do": "SET"},
"$.system",
"$.utils",
"$.connection",
"$.servers"
]
}, {
"filename": "core_13_$.utils.code.js",
"contents": [
"$.utils.code"
]
}, {
"filename": "core_35_$.servers.eval.js",
"contents": [
"$.servers.eval"
]
}, {
"options": {"treeOnly": false}
}, {
"filename": "core_99_rest.js",
"rest": true
}
]
================================================
FILE: server/tests/tinycore/tiny.cfg
================================================
{
"databaseDirectory": "./",
"checkpointInterval": 0,
"checkpointAtShutdown": false,
"checkpointMinFiles": 0,
"checkpointMaxDirectorySize": 0
}
================================================
FILE: static/503.html
================================================
503 - Code City
Uh oh…
For some reason the Code City server is not
responding to HTTP connections. Could be that it has crashed,
overloaded, or down for maintenance—or it could be that we've
accidentally broken the internal web server ($.servers.http ). In
the latter case you might still be able
to login via the telnet interface as usual.
In any case the problem is likely to be temporary so do please
come back later and try again!
================================================
FILE: static/code/code.js
================================================
/**
* @license
* Copyright 2018 Google LLC
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @fileoverview Integrated Development Environment for Code City.
* @author fraser@google.com (Neil Fraser)
*/
'use strict';
/**
* If not otherwise specified, what should /code point at?
*/
Code.DEFAULT = '$';
/**
* Raw string of selector.
* E.g. '$.foo["bar"]'
*/
Code.selector = location.search ?
decodeURIComponent(location.search.substring(1)) : Code.DEFAULT;
/**
* Got a ping from someone. Check sessionStorage to see if selector has
* changed and, if so, propagate ping to subframes.
* @param {?Event} event Message event, or null if called from popState.
*/
Code.receiveMessage = function(event) {
// Check to see if the stored values have changed.
var selector = sessionStorage.getItem(Code.Common.SELECTOR);
if (selector === Code.selector) {
return;
}
Code.selector = selector;
if (event) {
// Change the URL if this is NOT the result of a forwards/back navigation.
var query = encodeURIComponent(selector);
query = query.replace(/%24/g, '$'); // No need to encode $.
history.pushState(selector, selector, '?' + query);
}
// Propagate the ping down the tree of frames.
try {
document.getElementById('explorer').contentWindow.postMessage('ping', '*');
} catch (e) {
// Maybe explorer frame hasn't loaded yet.
}
try {
document.getElementById('editor').contentWindow.postMessage('ping', '*');
} catch (e) {
// Maybe editor frame hasn't loaded yet.
}
Code.setTitle();
};
/**
* User has navigated forwards or backwards.
* @param {!Event} event History change event.
*/
Code.popState = function(event) {
var selector = event.state || Code.DEFAULT;
sessionStorage.setItem(Code.Common.SELECTOR, selector);
// Attempt to pull the focus away from the explorer's input field.
// This will allow it to update the displayed selector.
try {
document.getElementById('explorer').contentDocument
.getElementById('input').blur();
} catch (e) {
console.log('Unable to blur input: ' + e);
}
Code.receiveMessage(null);
};
/**
* Set the code editor's title.
*/
Code.setTitle = function() {
var title = Code.selector;
if (title.length > 36) {
// Max title length in Chrome is 36 before truncation.
title = '…' + title.substr(-35);
}
document.title = title;
};
if (!window.TEST) {
Code.setTitle();
sessionStorage.setItem(Code.Common.SELECTOR, Code.selector);
window.addEventListener('message', Code.receiveMessage, false);
window.addEventListener('popstate', Code.popState, false);
}
////////////////////////////////////////////
// Add bridge for SVG editor's clipboard. This copy allows the clipboard to
// sync across all /code tabs even if the SVG editor isn't currently loaded.
// Copied from /code/SVG-Edit/svgcanvas.js
const CLIPBOARD_ID = 'svgedit_clipboard';
/**
* Flash the clipboard data momentarily on localStorage so all tabs can see.
* @returns {void}
*/
function flashStorage () {
const data = sessionStorage.getItem(CLIPBOARD_ID);
localStorage.setItem(CLIPBOARD_ID, data);
setTimeout(function () {
localStorage.removeItem(CLIPBOARD_ID);
}, 1);
}
/**
* Transfers sessionStorage from one tab to another.
* @param {!Event} ev Storage event.
* @returns {void}
*/
function storageChange(ev) {
if (!ev.newValue) return; // This is a call from removeItem.
if (ev.key === CLIPBOARD_ID + '_startup') {
// Another tab asked for our sessionStorage.
localStorage.removeItem(CLIPBOARD_ID + '_startup');
flashStorage();
} else if (ev.key === CLIPBOARD_ID) {
// Another tab sent data.
sessionStorage.setItem(CLIPBOARD_ID, ev.newValue);
}
}
// Listen for changes to localStorage.
window.addEventListener('storage', storageChange, false);
// Ask other tabs for sessionStorage (this is ONLY to trigger event).
localStorage.setItem(CLIPBOARD_ID + '_startup', Math.random());
// End of bridge for SVG editor's clipboard.
////////////////////////////////////////////
================================================
FILE: static/code/common.js
================================================
/**
* @license
* Copyright 2018 Google LLC
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @fileoverview Integrated Development Environment for Code City.
* @author fraser@google.com (Neil Fraser)
*/
'use strict';
var Code = {};
Code.Common = {};
// Keys for the sessionStorage.
Code.Common.SELECTOR = 'code selector';
// Set containing all supported {xyz} names.
Code.Common.KEYWORD_TYPES =
new Set(['{proto}', '{owner}', '{children}', '{owned}', '{keys}', '{values}']);
/**
* Tokenize a string such as '$.foo["bar"]' into tokens:
* {type: "id", raw: "$", valid: true, index: 0, value: "$"}
* {type: ".", raw: ".", valid: true, index: 1}
* {type: "id", raw: "foo", valid: true, index: 2, value: "foo"}
* {type: "[", raw: "[", valid: true, index: 5}
* {type: "str", raw: ""bar"", valid: true, index: 6, value: "bar"}
* {type: "]", raw: "]", valid: true, index: 11}
* Other tokens include:
* {type: "num", raw: "42", valid: true, index: 2, value: 42}
* {type: "keyword", raw: "{proto}", valid: true, index: 5, value: '{proto}'}
* {type: "keyword", raw: "{owner}", valid: true, index: 5, value: '{owner}'}
* {type: "keyword", raw: "{children}", valid: true, index: 5, value: '{children}'}
* {type: "keyword", raw: "{owned}", valid: true, index: 5, value: '{owned}'}
* {type: "keyword", raw: "{keys}", valid: true, index: 5, value: '{keys}'}
* {type: "keyword", raw: "{values}", valid: true, index: 5, value: '{values}'}
* If the string is permanently invalid, the last token is:
* {type: "?", raw: "", valid: false}
* A temporary token is used internally during parsing:
* {type: "unparsed", raw: "[42].foo", index: 8}
* @param {string} text Selector string.
* @return {!Array} Array of tokens.
*/
Code.Common.tokenizeSelector = function(text) {
// Trim left whitespace.
var trimText = text.replace(/^[\s\xa0]+/, '');
if (!trimText) {
return [];
}
var whitespaceLength = text.length - trimText.length;
text = trimText;
// Split the text into an array of tokens.
// First step is to create two types of tokens: 'str' and 'unparsed'.
var state = null;
// null - non-string state
// 'sqStr' - single quote string
// 'dqStr' - double quote string
// 'sqSlash' - backslash in single quote string
// 'dqSlash' - backslash in double quote string
var tokens = [];
var buffer = [];
for (var i = 0; i < text.length; i++) {
var char = text[i];
var index = whitespaceLength + i;
if (state === null) {
if (char === "'") {
Code.Common.pushUnparsed_(buffer, index, tokens);
state = 'sqStr';
} else if (char === '"') {
Code.Common.pushUnparsed_(buffer, index, tokens);
state = 'dqStr';
} else {
buffer.push(char);
}
} else if (state === 'sqStr') {
if (char === "'") {
Code.Common.pushString_("'", buffer, index, tokens);
state = null;
} else {
buffer.push(char);
if (char === '\\') {
state = 'sqSlash';
}
}
} else if (state === 'dqStr') {
if (char === '"') {
Code.Common.pushString_('"', buffer, index, tokens);
state = null;
} else {
buffer.push(char);
if (char === '\\') {
state = 'dqSlash';
}
}
} else if (state === 'sqSlash') {
buffer.push(char);
state = 'sqStr';
} else if (state === 'dqSlash') {
buffer.push(char);
state = 'dqStr';
}
}
if (state !== null) {
// Convert state into quote type.
var quotes = (state === 'sqStr' || state === 'sqSlash') ? "'" : '"';
Code.Common.pushString_(quotes, buffer, index + 1, tokens);
} else if (buffer.length) {
Code.Common.pushUnparsed_(buffer, index + 1, tokens);
}
// Second step is to parse each 'unparsed' token and split out '[', and ']'
// tokens.
for (var i = tokens.length - 1; i >= 0; i--) {
var token = tokens[i];
if (token.type === 'unparsed') {
var index = token.index + token.raw.length;
// Split string on brackets.
var split = token.raw.split(/(\s*[\[\]]\s*)/);
for (var j = split.length - 1; j >= 0; j--) {
var raw = split[j];
index -= raw.length;
var rawTrim = raw.trim();
if (raw === '') {
split.splice(j, 1); // Delete the empty string.
continue;
} else if (rawTrim === '[' || rawTrim === ']') {
split[j] = {type: rawTrim, valid: true};
} else {
split[j] = {type: 'unparsed'};
}
split[j].raw = raw;
split[j].index = index;
}
// Replace token with split array.
split.unshift(i, 1);
Array.prototype.splice.apply(tokens, split);
}
}
// Third step is to parse each 'unparsed' token and split out '{xxx}' tokens.
for (var i = tokens.length - 1; i >= 0; i--) {
var token = tokens[i];
if (token.type === 'unparsed') {
var index = token.index + token.raw.length;
var split = token.raw.split(/(\s*{\s*\w*\s*(?:}\s*|$))/);
for (var j = split.length - 1; j >= 0; j--) {
var raw = split[j];
index -= raw.length;
var rawTrim = raw.trim();
if (raw === '') {
split.splice(j, 1); // Delete the empty string.
continue;
}
var m = rawTrim.match(/{\s*(\w*)\s*(}|$)/);
if (m) {
var keywordToken = {type: 'keyword', value: '{' + m[1] + m[2]};
keywordToken.complete =
Code.Common.KEYWORD_TYPES.has(keywordToken.value);
if (keywordToken.complete) {
keywordToken.valid = true;
} else {
keywordToken.valid = false;
for (var validKeyword of Code.Common.KEYWORD_TYPES) {
if (validKeyword.startsWith(keywordToken.value)) {
keywordToken.valid = true;
break;
}
}
}
split[j] = keywordToken;
} else {
split[j] = {type: 'unparsed'};
}
split[j].raw = raw;
split[j].index = index;
}
// Replace token with split array.
split.unshift(i, 1);
Array.prototype.splice.apply(tokens, split);
}
}
// Fourth step is to parse each 'unparsed' token as a number, if it is
// preceded by a '[' token. If the result is NaN (e.g. in the case it is an
// unquoted identifier) mark the token as invalid.
for (var i = 1; i < tokens.length; i++) {
var token = tokens[i];
if (tokens[i - 1].type === '[' && token.type === 'unparsed') {
token.type = 'num';
token.value = NaN;
token.valid = false;
// Does not support E-notation or NaN.
if (/^\s*[-+]?(\d*\.?\d*|Infinity)\s*$/.test(token.raw)) {
token.value = Number(token.raw);
token.valid = !isNaN(token.value);
token.value = String(token.value);
}
}
}
// Fifth step is to split remaining 'unparsed' tokens into 'id' and '.'
// tokens. The '.' tokens could not be split out before numbers were parsed,
// since numbers have decimal points.
var unicodeRegex = /\\u([0-9A-F]{4})/ig;
function decodeUnicode(m, p1) {
return String.fromCodePoint(parseInt(p1, 16));
}
for (var i = tokens.length - 1; i >= 0; i--) {
var token = tokens[i];
if (token.type !== 'unparsed') {
continue;
}
var index = token.index + token.raw.length;
// Split string on periods.
var split = token.raw.split(/(\s*\.\s*)/);
for (var j = split.length - 1; j >= 0; j--) {
var raw = split[j];
index -= raw.length;
if (raw === '') {
split.splice(j, 1); // Delete the empty string.
continue;
} else if (raw.trim() === '.') {
split[j] = {
type: '.',
valid: true
};
} else {
// Parse Unicode escapes in identifiers.
var valid = true;
var value = split[j];
while (true) {
var test = value.replace(unicodeRegex, '');
if (!test.includes('\\')) {
break;
}
// Invalid escape found. Trim off last char and try again.
value = value.substring(0, value.length - 1);
valid = false;
}
// Decode Unicode.
value = value.replace(unicodeRegex, decodeUnicode);
split[j] = {type: 'id', value: value, valid: valid};
}
split[j].raw = raw;
split[j].index = index;
}
// Replace token with split array.
split.unshift(i, 1);
Array.prototype.splice.apply(tokens, split);
}
// Finally, validate order of tokens. Only check for permanent errors.
// E.g. '$..foo' can never be legal.
// E.g. '$["foo' isn't legal now, but could become legal after more typing.
var state = 0;
// 0 - Start or after '.'. Expecting 'id'.
// 1 - After 'id' or ']' or 'keyword'.
// Expecting '.' or '[' or 'keyword'.
// 2 - After '['. Expecting 'str' or 'num'.
// 3 - After 'str' or 'num'. Expecting ']'.
for (var i = 0; i < tokens.length; i++) {
var token = tokens[i];
if (state === 0) {
if (token.type === 'id') {
state = 1;
} else {
break;
}
} else if (state === 1) {
if (token.type === '.') {
state = 0;
} else if (token.type === 'keyword') {
state = 1;
} else if (token.type === '[') {
state = 2;
} else {
break;
}
} else if (state === 2) {
if (token.type === 'str' || token.type === 'num') {
state = 3;
} else {
break;
}
} else if (state === 3) {
if (token.type === ']') {
state = 1;
} else {
break;
}
} else {
break;
}
}
// Remove any illegal tokens.
if (i < tokens.length) {
tokens = tokens.slice(0, i);
// Add fail token to prevent autocompletion.
tokens.push({type: '?', raw: '', valid: false});
}
return tokens;
};
/**
* Push a 'str' token type onto the list of tokens.
* Handles invalid strings, e.g. 'abc \u---- xyz'
* @param {string} quotes Quote type (' vs ").
* @param {!Array} buffer Array of chars that make the string.
* @param {number} index Char index of start of this token in original input.
* @param {!Array} tokens List of tokens.
* @private
*/
Code.Common.pushString_ = function(quotes, buffer, index, tokens) {
var token = {
type: 'str',
raw: quotes + buffer.join('') + quotes,
valid: true
};
token.index = index - (token.raw.length - 1);
do {
var raw = quotes + buffer.join('') + quotes;
// Attempt to parse a string.
try {
var str = eval(raw);
break;
} catch (e) {
// Invalid escape found. Trim off last char and try again.
buffer.pop();
token.valid = false;
}
} while (true);
buffer.length = 0;
token.value = str;
tokens.push(token);
};
/**
* Push an 'unparsed' token type onto the list of tokens.
* @param {!Array} buffer Array of chars that make the value.
* @param {number} index Character index of this token in original input.
* @param {!Array} tokens List of tokens.
* @private
*/
Code.Common.pushUnparsed_ = function(buffer, index, tokens) {
var raw = buffer.join('');
buffer.length = 0;
if (raw) {
var token = {
type: 'unparsed',
raw: raw,
index: index - raw.length
};
tokens.push(token);
}
};
/**
* Split a path selector into a list of parts.
* E.g. '${proto}.foo' ->
* [{type: 'id', value: '$'}, {type: 'keyword', value: '{proto}'}, {type: 'id', value: 'foo'}]
* @param {string} text Selector string.
* @return {?Array} Array of parts or null if invalid.
*/
Code.Common.selectorToParts = function(text) {
// TODO: Try caching the results for performance.
var tokens = Code.Common.tokenizeSelector(text);
var parts = [];
for (var token of tokens) {
if (!token.valid) {
return null;
}
if (['id', 'str', 'num'].includes(token.type)) {
parts.push({type: 'id', value: token.value});
} else if (token.type === 'keyword') {
parts.push({type: token.type, value: token.value});
}
}
return parts;
};
/**
* Join a list of parts into a path selector.
* E.g. [{type: 'id', value: '$'}, {type: 'keyword', value: '{proto}'}, {type: 'id', value: 'foo'}] ->
* '${proto}.foo'
* @param {!Array} parts Array of parts.
* @return {string} Selector string.
*/
Code.Common.partsToSelector = function(parts) {
var text = '';
for (var i = 0; i < parts.length; i++) {
var part = parts[i];
if (part.type === 'id') {
var value = part.value;
if (/^[A-Z_$][0-9A-Z_$]*$/i.test(value)) {
if (i !== 0) {
text += '.';
}
text += value;
} else {
text += '[';
if (/^-?\d{1,15}$/.test(value)) {
text += value;
} else {
text += JSON.stringify(value);
}
text += ']';
}
} else if (part.type === 'keyword') {
text += part.value;
}
}
return text;
};
/**
* Turn a selector string into a valid code reference.
* E.g. "$.foo" -> "$.foo"
* E.g. "${proto}.foo" -> "$('${proto}.foo')"
* Join a list of parts into a valid code reference.
* @param {string} selector Selector string.
* @return {string} Code reference.
*/
Code.Common.selectorToReference = function(selector) {
var noStrings = selector.replace(/(["'])(?:[^\1\\]|\\.)*?\1/g, '');
if (noStrings.includes('{')) {
return "$('" + selector + "')";
}
return selector;
};
/**
* Comparison function to sort strings A-Z without regard to case.
* @param {string} a One string.
* @param {string} b Another string.
* @return {number} -1/0/1 comparator value.
*/
Code.Common.caseInsensitiveComp = function(a, b) {
a = a.toLowerCase();
b = b.toLowerCase();
var aNum = parseFloat(a);
var bNum = parseFloat(b);
if (!isNaN(aNum) && !isNaN(bNum) && aNum !== bNum) {
// Numeric.
return (aNum < bNum) ? -1 : 1;
}
// ASCIIbetical.
return (a < b) ? -1 : ((a > b) ? 1 : 0);
};
// Set background colour to differentiate server vs local copy.
if (location.hostname === 'localhost') {
window.addEventListener('load', function() {
document.body.style.backgroundColor = '#ffe';
});
}
================================================
FILE: static/code/diff.css
================================================
body {
white-space: pre-wrap;
}
ins {
background: #e6ffe6;
}
del {
background: #ffe6e6;
}
================================================
FILE: static/code/diff.js
================================================
/**
* @license
* Copyright 2018 Google LLC
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @fileoverview Diff Editor.
* @author fraser@google.com (Neil Fraser)
*/
'use strict';
var diffEditor = {};
/**
* Diff Match Patch object.
*/
diffEditor.dmp = new diff_match_patch();
/**
* Current source.
*/
diffEditor.source = '';
/**
* Check to see if the parent window left us an initial source to render.
*/
diffEditor.init = function() {
var newSource = window.initialSource;
var oldSource = window.originalSource;
if (newSource && oldSource) {
diffEditor.setString(newSource, oldSource);
delete window.initialSource;
delete window.originalSource;
}
};
/**
* Set the strings for a new diff.
* @param {string} newString Current source.
* @param {string} oldString Source as of last save.
*/
diffEditor.setString = function(newString, oldString) {
this.source = newString;
var diff = this.dmp.diff_main(oldString, newString);
this.dmp.diff_cleanupSemantic(diff);
diffEditor.render(diff, document.body);
};
/**
* Return the current source.
* @return {string} Source.
*/
diffEditor.getString = function() {
return this.source;
};
/**
* Convert a diff array into a pretty HTML report and inject it on the page.
* @param {!Array.} diffs Array of diff tuples.
* @param {!Element} container HTML element into which to render the diff.
*/
diffEditor.render = function(diffs, container) {
container.innerHTML = '';
for (var i = 0; i < diffs.length; i++) {
var op = diffs[i][0]; // Operation (insert, delete, equal)
var text = diffs[i][1]; // Text of change.
var el = document.createElement(diffEditor.tagMap[op]);
el.appendChild(document.createTextNode(text));
container.appendChild(el);
}
};
/**
* Mapping from diff operation to relevant tag.
*/
diffEditor.tagMap = {};
diffEditor.tagMap[DIFF_INSERT] = 'ins';
diffEditor.tagMap[DIFF_DELETE] = 'del';
diffEditor.tagMap[DIFF_EQUAL] = 'span';
window.addEventListener('load', diffEditor.init);
================================================
FILE: static/code/editor.css
================================================
#editorButter {
display: none;
left: 0;
position: absolute;
right: 0;
top: 0;
pointer-events: none;
z-index: 10;
}
#editorButter>div {
text-align: center;
}
#editorButterText {
background: #f9edbe;
border: 1px solid #f0c36d;
border-radius: 0 0 2px 2px;
border-top: 0;
box-shadow: 0 2px 4px rgba(0,0,0,0.2);
display: inline-block;
padding: 0 10px;
pointer-events: auto;
}
#valueEditor {
position: absolute;
top: 60px;
bottom: 20px;
left: 10px;
right: 20px
}
#functionEditor {
position: absolute;
top: 60px;
bottom: 45px;
left: 10px;
right: 20px
}
#jsspEditor {
position: absolute;
top: 60px;
bottom: 45px;
left: 10px;
right: 20px
}
.editorBigQuotes {
font-family: serif;
font-size: 48pt;
position: absolute;
}
================================================
FILE: static/code/editor.js
================================================
/**
* @license
* Copyright 2018 Google LLC
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @fileoverview Integrated Development Environment for Code City.
* @author fraser@google.com (Neil Fraser)
*/
'use strict';
Code.Editor = {};
/**
* List of complete object selector parts.
* @type {Array}
*/
Code.Editor.parts = null;
/**
* Currently selected editor.
* @type {?Code.GenericEditor}
*/
Code.Editor.currentEditor = null;
/**
* Current source code for editors that haven't yet been created.
* @type {string}
*/
Code.Editor.uncreatedEditorSource = '';
/**
* URL of this script.
* Might be with or without subdomains:
* https://static.google.codecity.world/code/editor.js
* http://localhost:8080/static/code/editor.js
* @type {string}
*/
Code.Editor.mySource = document.getElementById('editor_js').src;
/**
* Got a ping from someone. Something might have changed and need updating.
*/
Code.Editor.receiveMessage = function() {
if (Code.Editor.isSaveDialogVisible) {
return; // Ignore messages if the modal save dialog is up.
}
var selector = sessionStorage.getItem(Code.Common.SELECTOR);
var parts = Code.Common.selectorToParts(selector);
if (!parts || !parts.length) {
return; // Invalid parts, ignore.
}
if (parts === Code.Editor.parts) {
return; // No change.
}
if (Code.Editor.parts === null) {
Code.Editor.load(); // Initial load of content.
} else {
Code.Editor.updateCurrentSource();
if (Code.Editor.currentSource === Code.Editor.originalSource) {
Code.Editor.reload(); // Reload to load different content.
} else {
Code.Editor.showSave(); // User needs to save/discard/cancel.
}
}
};
/**
* Page has loaded, initialize the editor.
*/
Code.Editor.init = function() {
// Initialize button handlers.
document.getElementById('editorConfirmDiscard').addEventListener('click',
Code.Editor.reload);
document.getElementById('editorConfirmCancel').addEventListener('click',
Code.Editor.hideDialog);
document.getElementById('editorConfirmSave').addEventListener('click',
Code.Editor.save);
document.getElementById('editorSave').addEventListener('click',
Code.Editor.save);
document.getElementById('editorShare').addEventListener('click',
Code.Editor.showShare);
document.getElementById('editorShareOk').addEventListener('click',
Code.Editor.hideDialog);
document.getElementById('editorShareCheck').addEventListener('change',
Code.Editor.checkShare);
// Create the tabs.
var tabRow = document.getElementById('editorTabs');
var containerRow = document.getElementById('editorContainers');
for (var i = 0, editor; (editor = Code.Editor.editors[i]); i++) {
var span = document.createElement('span');
span.className = 'jfk-button';
span.appendChild(document.createTextNode(editor.name));
span.setAttribute('role', 'button');
span.setAttribute('tabindex', i);
span.addEventListener('click', Code.Editor.tabClick);
tabRow.appendChild(span);
var spacer = document.createElement('span');
spacer.className = 'spacer';
tabRow.appendChild(spacer);
var div = document.createElement('div');
containerRow.appendChild(div);
// Cross-link span/div to editor.
span.editor = editor;
div.editor = editor;
editor.tabElement = span;
editor.containerElement = div;
}
document.addEventListener('keydown', Code.Editor.keyDown);
Code.Editor.receiveMessage();
// Defer loading of JSHint to get editors running faster.
setTimeout(Code.Editor.importJSHint, 1);
};
/**
* Load content into the editors.
*/
Code.Editor.load = function() {
var selector = sessionStorage.getItem(Code.Common.SELECTOR);
var parts = Code.Common.selectorToParts(selector);
if (!parts) {
return; // Invalid parts, ignore.
}
Code.Editor.parts = parts.slice(); // Shallow copy, since it's popped below.
// Request data from Code City server.
Code.Editor.key = undefined;
Code.Editor.sendXhr();
// Set the header.
var header = document.getElementById('editorHeader');
header.innerHTML = '';
if (parts.length < 2) {
// Global object.
var reference = Code.Common.partsToSelector(parts) + ' = ';
} else {
// Remove the last part.
var lastPart = parts.pop();
var selector = Code.Common.partsToSelector(parts);
var reference = Code.Common.selectorToReference(selector);
// Put the last part back on.
// Render as '.foo' or '[42]' or '["???"]' or '{xxx}'.
if (lastPart.type === 'id') {
var mockParts = [{type: 'id', value: 'X'}, lastPart];
reference += Code.Common.partsToSelector(mockParts).substring(1) + ' = ';
} else if (lastPart.type === 'keyword') {
if (lastPart.value === '{proto}') {
reference = 'Object.setPrototypeOf(' + reference + ', ...) ';
} else if (lastPart.value === '{owner}') {
reference = 'Object.setOwnerOf(' + reference + ', ...) ';
} else {
throw new TypeError('Unknown keyword value: ' + lastPart.value);
}
} else {
throw new TypeError('Unknown part type: ' + lastPart.type);
}
}
header.appendChild(document.createTextNode(reference));
};
/**
* Check the currently active editor and update Code.Editor.currentSource
* if there has been a change.
*/
Code.Editor.updateCurrentSource = function() {
if (Code.Editor.currentEditor && !Code.Editor.currentEditor.isSaved()) {
Code.Editor.currentSource = Code.Editor.currentEditor.getSource();
}
if (!Code.Editor.isSaveDialogVisible) {
Code.Editor.saturateSave(
Code.Editor.currentSource !== Code.Editor.originalSource);
}
};
/**
* Keydown handler for the editor frame.
* @param {!KeyboardEvent} e Keydown event.
*/
Code.Editor.keyDown = function(e) {
// Save the editor if ⌘-s or Ctrl-s is pressed.
if (e.key === 's' && (e.metaKey || e.ctrlKey)) {
Code.Editor.save();
e.preventDefault();
e.stopPropagation();
}
// Before starting a search, render the editors' entire document.
if ((e.key === 'f' || e.key === 'g') && (e.metaKey || e.ctrlKey)) {
if (Code.Editor.currentEditor) {
var cm = Code.Editor.currentEditor.getCodeMirror();
if (cm) {
cm.setOption('viewportMargin', Infinity);
}
}
}
};
/**
* Save the current editor content.
*/
Code.Editor.save = function() {
Code.Editor.updateCurrentSource();
Code.Editor.sendXhr();
// Prevent the user from interacting with the editor during an async save.
// TODO: Implement merging.
var mask = document.getElementById('editorSavingMask');
mask.style.display = 'block';
Code.Editor.saveMaskPid = setTimeout(function() {
mask.style.opacity = 0.2;
}, 1000); // Wait a second before starting visible transition.
};
/**
* Force a reload of this editor. Used to switch to edit something else.
*/
Code.Editor.reload = function() {
Code.Editor.hideDialog();
Code.Editor.beforeUnload.disabled = true;
location.reload();
};
/**
* Issue a warning if the user has unsaved changes and is attempting to leave
* the code editor (e.g. typing a new URL). This is not triggered due to
* in-editor navigation.
* @param {!Event} e A beforeunload event.
*/
Code.Editor.beforeUnload = function(e) {
if (Code.Editor.isSaveDialogVisible) {
// The user has already got a warning but is ignoring it. Just leave.
Code.Editor.hideDialog();
return;
}
Code.Editor.updateCurrentSource();
if (!Code.Editor.beforeUnload.disabled &&
Code.Editor.currentSource !== Code.Editor.originalSource) {
e.returnValue = 'You have unsaved changes.';
e.preventDefault();
}
};
/**
* Flag to allow navigation away from current page, despite unsaved changes.
*/
Code.Editor.beforeUnload.disabled = false;
/**
* Asynchronously load MobWrite's JavaScript files.
* @param {!Function} callback Function to call when MobWrite is loaded.
*/
Code.Editor.loadMobWrite = function(callback) {
if (!Code.Editor.waitMobWrite_.isLoaded) {
var files = ['dmp.js', 'mobwrite_core.js', 'mobwrite_cc.js'];
for (var file of files) {
var script = document.createElement('script');
script.src = Code.Editor.mySource.replace('editor.js', 'mobwrite/' + file);
document.head.appendChild(script);
}
}
Code.Editor.waitMobWrite_(callback);
};
/**
* Wait for MobWrite to load. Initialize it, then run the callback.
* @param {!Function} callback Function to call when MobWrite is loaded.
* @private
*/
Code.Editor.waitMobWrite_ = function(callback) {
if (typeof diff_match_patch === 'undefined' ||
typeof mobwrite === 'undefined' ||
typeof Code.MobwriteShare === 'undefined') {
// Not loaded, try again later.
setTimeout(Code.Editor.waitMobWrite_, 50, callback);
} else {
if (!Code.Editor.waitMobWrite_.isLoaded) {
Code.MobwriteShare.init();
// Point MobWrite at the daemon on Code City.
var url = Code.Editor.mySource.replace('/code/editor.js', '');
if (url.endsWith('/static')) {
// http://localhost:8080/static
mobwrite.syncGateway = url.replace(/\/static$/, '/mobwrite');
} else if (/:\/\/static\./.test(url)) {
// https://static.google.codecity.world
mobwrite.syncGateway = url.replace('://static.', '://mobwrite.');
} else {
throw Error('Source does not match known pattern: ' + url);
}
Code.Editor.waitMobWrite_.isLoaded = true;
}
callback();
}
};
Code.Editor.waitMobWrite_.isLoaded = false;
/**
* When a tab is clicked, highlight it and show its container.
* @param {!Event|!Object} e Click event or object pretending to be an event.
*/
Code.Editor.tabClick = function(e) {
if (Code.Editor.tabClick.disabled) {
return;
}
// Unhighlight all tabs, hide all containers.
var tab = document.querySelector('#editorTabs>.highlighted');
tab && tab.classList.remove('highlighted');
var containers = document.querySelectorAll('#editorContainers>div');
for (var container of containers) {
container.style.display = 'none';
}
Code.Editor.updateCurrentSource();
// Highlight one tab, show one container.
var tab = e.target;
tab.classList.add('highlighted');
var editor = tab.editor;
Code.Editor.currentEditor = editor;
var container = editor.containerElement;
if (!editor.created) {
editor.createDom(container);
editor.created = true;
}
container.style.display = 'block';
Code.Editor.setSourceToAllEditors(Code.Editor.currentSource);
// If e is an event, then this click is the result of a user's direct action.
// If not, then it's a fake event as a result of page load.
var userAction = e instanceof Event;
editor.focus(userAction);
};
/**
* Don't allow clicking of tabs before data is received from Code City.
*/
Code.Editor.tabClick.disabled = true;
/**
* Send a request to Code City's code editor service.
*/
Code.Editor.sendXhr = function() {
var selector = Code.Common.partsToSelector(Code.Editor.parts);
var xhr = Code.Editor.codeRequest_;
xhr.abort();
xhr.open('POST', 'editorXhr');
xhr.setRequestHeader('Content-type', 'application/x-www-form-urlencoded');
xhr.onload = Code.Editor.receiveXhr;
var src = Code.Editor.currentSource || '';
var data =
'key=' + encodeURIComponent(Code.Editor.key) +
'&selector=' + encodeURIComponent(selector);
if (src) {
data += '&src=' + encodeURIComponent(src);
}
xhr.send(data);
};
/**
* Reusable XHR object for server pings.
*/
Code.Editor.codeRequest_ = new XMLHttpRequest();
/**
* Got a response from Code City's code editor service.
*/
Code.Editor.receiveXhr = function() {
var xhr = Code.Editor.codeRequest_;
if (xhr.status !== 200) {
Code.Editor.clearSaveMask();
Code.Editor.showButter('Save failed: Status ' + xhr.status, 5000);
return;
}
var data = JSON.parse(xhr.responseText);
if (data.hasOwnProperty('key')) {
Code.Editor.key = data.key;
}
if (data.hasOwnProperty('src')) {
Code.Editor.originalSource = data.src;
// Only update the displayed source if a) this is the initial load,
// or b) the previous save was successful.
if (Code.Editor.currentSource === null || data.saved) {
Code.Editor.currentSource = data.src;
Code.Editor.setSourceToAllEditors(data.src);
}
}
Code.Editor.clearSaveMask();
if (data.saved === false && !data.login) {
// Save was requested, but failed due to lack of a login.
// Open login window.
var loginWindow = open('login', 'login', 'height=600,width=500');
if (loginWindow) {
window.addEventListener('message', function(event) {
if (event.data === 'closeMe') {
loginWindow.close();
Code.Editor.save();
}
}, false);
} else {
alert('Your browser has blocked the opening of the page you requested.\n' +
'Please allow pop-ups on this domain. ✓️');
}
}
// While a save is in-flight, the user might have navigated away and be
// currently blocked by a warning dialog regarding unsaved work.
if (Code.Editor.isSaveDialogVisible) {
if (data.saved) {
// If the save was successful, then proceed with the requested navigation.
Code.Editor.reload();
} else {
// If the save was not successful, close the dialog and hope there's some
// butter to show.
Code.Editor.hideDialog();
}
}
// If there's a message, show it in the butter.
if (data.butter) {
Code.Editor.showButter(data.butter, 5000);
}
Code.Editor.ready && Code.Editor.ready();
};
/**
* Remove saving mask that prevents UI interaction.
*/
Code.Editor.clearSaveMask = function() {
clearTimeout(Code.Editor.saveMaskPid);
var mask = document.getElementById('editorSavingMask');
mask.style.display = 'none';
mask.style.opacity = 0;
};
/**
* The original source text from the server.
* @type {?string}
*/
Code.Editor.originalSource = null;
/**
* Current source text from the most recent active editor.
* @type {?string}
*/
Code.Editor.currentSource = null;
/**
* Data has been received, ready to allow the user to edit.
*/
Code.Editor.ready = function() {
// Configure tabs.
document.getElementById('editorTabs').classList.remove('disabled');
Code.Editor.tabClick.disabled = false;
// Switch tabs to show the highest confidence editor.
var bestEditor = Code.Editor.mostConfidentEditor();
if (bestEditor) {
var fakeEvent = {target: bestEditor.tabElement};
Code.Editor.tabClick(fakeEvent);
}
// Remove the loading animation.
var header = document.getElementById('editorHeader');
header.className = '';
// Update the save button's saturation state once a second.
setInterval(Code.Editor.updateCurrentSource, 1000);
var hash = parent && parent.location && parent.location.hash;
if (hash.length > 1) {
Code.Editor.loadMobWrite(function() {
mobwrite.share('Code');
});
}
// Only run this code once.
Code.Editor.ready = undefined;
};
/**
* Find the editor with the highest confidence for the current text.
* Confidence levels are recorded when text is set in each editor.
* @return {Code.GenericEditor} Best editor, or null if none.
*/
Code.Editor.mostConfidentEditor = function() {
var bestEditor = null;
var bestConfidence = -Infinity;
for (var editor of Code.Editor.editors) {
if (bestConfidence < editor.confidence) {
bestConfidence = editor.confidence;
bestEditor = editor;
}
}
return bestEditor;
};
/**
* Set the values of all the editors.
* @param {string} src Plain text contents.
*/
Code.Editor.setSourceToAllEditors = function(src) {
if (typeof src !== 'string') {
throw TypeError(src);
}
Code.Editor.uncreatedEditorSource = src;
for (var editor of Code.Editor.editors) {
editor.setSource(src);
// Round-trip version of the source.
editor.unmodifiedSource = editor.getSource();
}
};
/**
* Show the save dialog.
*/
Code.Editor.showSave = function() {
Code.Editor.showDialog('editorConfirmBox');
// Desaturate save button. Don't visually conflict with the 'save' button
// in save dialog.
Code.Editor.saturateSave(false);
Code.Editor.isSaveDialogVisible = true;
};
/**
* Show the share dialog.
*/
Code.Editor.showShare = function() {
Code.Editor.showDialog('editorShareBox');
document.body.style.cursor = 'wait';
Code.Editor.loadMobWrite(Code.Editor.populateShare);
};
/**
* Show the share dialog.
*/
Code.Editor.populateShare = function() {
document.body.style.cursor = '';
document.getElementById('editorShareBox').className = '';
var check = document.getElementById('editorShareCheck');
check.disabled = '';
check.checked = !!Object.keys(mobwrite.shared).length;
Code.Editor.checkShare();
};
/**
* Called when the sharing checkbox is ticked or unticked.
*/
Code.Editor.checkShare = function() {
var check = document.getElementById('editorShareCheck');
var input = document.getElementById('editorShareAddress');
input.disabled = !check.checked;
var shared = !!Object.keys(mobwrite.shared).length;
var hash = '#';
if (check.checked) {
if (!shared) {
mobwrite.share('Code');
}
hash += Code.MobwriteShare.id;
} else if (!check.checked) {
if (shared) {
mobwrite.unshare('Code');
}
}
if (parent && parent.history) {
// Update the URL on the parent frame.
parent.history.replaceState(undefined, undefined, hash);
// Update the address field the user can copy from.
input.value = check.checked ? parent.location : '';
input.select();
}
};
/**
* Show a dialog.
* @param {string} contentId ID of dialog's content div.
*/
Code.Editor.showDialog = function(contentId) {
// Clean up and hide existing things that might be visible.
clearTimeout(Code.Editor.dialogAnimationPid);
Code.Editor.hideButter();
document.getElementById('editorConfirmBox').style.display = 'none';
document.getElementById('editorShareBox').style.display = 'none';
// Show the requested dialog.
document.getElementById(contentId).style.display = 'block';
document.getElementById('editorDialog').style.display = 'block';
var mask = document.getElementById('editorDialogMask');
var box = document.getElementById('editorDialogBox');
box.style.display = 'block';
mask.style.transitionDuration = '.4s';
box.style.transitionDuration = '.4s';
// Add a little bounce at the end of the animation.
box.style.transitionTimingFunction = 'cubic-bezier(.6,1.36,.75,1)';
Code.Editor.dialogAnimationPid = setTimeout(function() {
mask.style.opacity = 0.2;
box.style.top = '-10px';
}, 100); // Firefox requires at least 10ms to process this timing function.
};
/**
* Hide the dialog.
*/
Code.Editor.hideDialog = function() {
clearTimeout(Code.Editor.dialogAnimationPid);
var mask = document.getElementById('editorDialogMask');
var box = document.getElementById('editorDialogBox');
mask.style.transitionDuration = '.2s';
box.style.transitionDuration = '.2s';
box.style.transitionTimingFunction = 'ease-in';
mask.style.opacity = 0;
box.style.top = '-120px';
Code.Editor.dialogAnimationPid = setTimeout(function() {
document.getElementById('editorDialog').style.display = 'none';
box.style.display = 'none';
document.getElementById('editorConfirmBox').style.display = 'none';
document.getElementById('editorShareBox').style.display = 'none';
}, 250);
// Resaturate the save button.
Code.Editor.saturateSave(true);
Code.Editor.isSaveDialogVisible = false;
};
/**
* Is the save dialog currently visible?
*/
Code.Editor.isSaveDialogVisible = false;
/**
* PID of any animation task. Allows animations to be canceled so that two
* near-simultaneous actions don't collide.
*/
Code.Editor.dialogAnimationPid = 0;
/**
* Saturate or desaturate the editor's save button.
* @param {boolean} saturated True if button should be saturated.
*/
Code.Editor.saturateSave = function(saturated) {
var button = document.getElementById('editorSave');
button.className = saturated ? 'jfk-button jfk-button-submit' : 'jfk-button';
};
/**
* Show the text in the butter bar for a period of time.
* Clobber any existing display.
* @param {string} text Text to display.
* @param {number} time Number of milliseconds to display butter.
*/
Code.Editor.showButter = function(text, time) {
clearTimeout(Code.Editor.showButter.pid_);
var textDiv = document.getElementById('editorButterText');
textDiv.innerHTML = '';
textDiv.appendChild(document.createTextNode(text));
document.getElementById('editorButter').style.display = 'block';
Code.Editor.showButter.pid_ = setTimeout(Code.Editor.hideButter, time);
};
Code.Editor.showButter.pid_ = 0;
/**
* Hide the butter bar.
*/
Code.Editor.hideButter = function() {
document.getElementById('editorButter').style.display = 'none';
};
/**
* Create a CodeMirror editor.
* @param {!Element} container HTML element to hold the editor.
* @param {!Object} extraOptions Editor configuration.
* @return {!Object} CodeMirron editor.
*/
Code.Editor.newCodeMirror = function(container, extraOptions) {
var options = {
extraKeys: {
Tab: function(cm) {
if (cm.somethingSelected()) {
cm.indentSelection('add');
} else {
cm.replaceSelection(' ');
}
},
'Shift-Tab': function(cm) {
cm.indentSelection('subtract');
}
},
gutters: ['CodeMirror-lint-markers'],
lineNumbers: true,
matchBrackets: true,
tabSize: 2,
undoDepth: 1024
};
// Merge extraOptions into default options.
Object.assign(options, extraOptions);
var editor = CodeMirror(container, options);
editor.setSize('100%', '100%');
return editor;
};
/**
* Has the JSHint library loaded yet?
*/
Code.Editor.JSHintReady = false;
/**
* Load the JSHint library.
* Defer loading until page is loaded and responsive.
*/
Code.Editor.importJSHint = function() {
//
var script = document.createElement('script');
script.type = 'text/javascript';
script.src = Code.Editor.mySource.replace('code/editor.js', 'JSHint/jshint.js');
script.onload = function() {
Code.Editor.JSHintReady = true;
// Activate linting for any editor that's loaded and waiting.
for (var i = 0, editor; (editor = Code.Editor.editors[i]); i++) {
var cm = editor.getCodeMirror();
if (cm && editor.useJSHint) {
cm.setOption('lint', true);
}
}
};
document.head.appendChild(script);
};
if (!window.TEST) {
window.addEventListener('load', Code.Editor.init);
window.addEventListener('message', Code.Editor.receiveMessage, false);
window.addEventListener('beforeunload', Code.Editor.beforeUnload);
}
Code.Editor.editors = [];
/**
* Base class for editors.
* @param {string} name User-facing name of editor (used in tab).
* @constructor
*/
Code.GenericEditor = function(name) {
/**
* Human-readable name of editor.
* @type {string}
*/
this.name = name;
/**
* A float from 0 (bad) to 1 (perfect) indicating the editor's fitness to
* edit the given content.
*/
this.confidence = 0;
/**
* Has the DOM for this editor been created yet?
*/
this.created = false;
/**
* Span that forms the tab button.
* @type {?Element}
*/
this.tabElement = null;
/**
* Div that forms the editor's container.
* @type {?Element}
*/
this.containerElement = null;
/**
* Plain text representation of this editor's contents as of load or last save.
* @type {?string}
*/
this.unmodifiedSource = null;
/**
* Should this editor use JSHint for syntax checking?
*/
this.useJSHint = false;
// Register this editor.
Code.Editor.editors.push(this);
};
/**
* Create the DOM for this editor.
* @param {!Element} container DOM should be appended to this containing div.
*/
Code.GenericEditor.prototype.createDom = function(container) {
var text = 'TODO: Implement createDom for ' + this.name + ' editor.';
container.appendChild(document.createTextNode(text));
};
/**
* Get the contents of the editor.
* @return {string} Plain text contents.
*/
Code.GenericEditor.prototype.getSource = function() {
throw new ReferenceError('getSource not implemented on editor');
};
/**
* Set the contents of the editor.
* @param {string} source Plain text contents.
*/
Code.GenericEditor.prototype.setSource = function(source) {
throw new ReferenceError('setSource not implemented on editor');
};
/**
* Is the user's work in this editor saved?
* @return {boolean} True if work is saved.
*/
Code.GenericEditor.prototype.isSaved = function() {
return this.getSource() === this.unmodifiedSource;
};
/**
* Return this editor's CodeMirror instance.
* @return {Object} Defaults to null.
*/
Code.GenericEditor.prototype.getCodeMirror = function() {
return null;
};
/**
* Notification that this editor has just been displayed.
* @param {boolean} userAction True if user clicked on a tab.
*/
Code.GenericEditor.prototype.focus = function(userAction) {
};
////////////////////////////////////////////////////////////////////////////////
Code.valueEditor = new Code.GenericEditor('Value');
// The value editor can handle any content, but express a low confidence in
// order to defer to more specialized editors.
Code.valueEditor.confidence = 0.1;
Code.valueEditor.useJSHint = true;
/**
* CodeMirror editor. Does not exist until tab is selected.
* @type {Object}
* @private
*/
Code.valueEditor.editor_ = null;
/**
* Return this editor's CodeMirror instance.
* @return {Object} Defaults to null.
*/
Code.valueEditor.getCodeMirror = function() {
return this.editor_;
};
/**
* Create the DOM for this editor.
* @param {!Element} container DOM should be appended to this containing div.
*/
Code.valueEditor.createDom = function(container) {
container.id = 'valueEditor';
// Use different theme in value editor to distinguish it from other editors.
var options = {
continueComments: {continueLineComment: false},
lint: Code.Editor.JSHintReady,
mode: 'text/javascript',
theme: 'default'
};
this.editor_ = Code.Editor.newCodeMirror(container, options);
};
/**
* Get the contents of the editor.
* @return {string} Plain text contents.
*/
Code.valueEditor.getSource = function() {
return this.created ?
this.editor_.getValue() : Code.Editor.uncreatedEditorSource;
};
/**
* Set the contents of the editor.
* @param {string} source Plain text contents.
*/
Code.valueEditor.setSource = function(source) {
if (this.created) {
this.editor_.setValue(source);
}
};
/**
* Notification that this editor has just been displayed.
* @param {boolean} userAction True if user clicked on a tab.
*/
Code.valueEditor.focus = function(userAction) {
this.editor_.refresh();
if (userAction) {
this.editor_.focus();
}
};
////////////////////////////////////////////////////////////////////////////////
Code.functionEditor = new Code.GenericEditor('Function');
Code.functionEditor.useJSHint = true;
/**
* CodeMirror editor. Does not exist until tab is selected.
* @type {Object}
* @private
*/
Code.functionEditor.editor_ = null;
/**
* Return this editor's CodeMirror instance.
* @return {Object} Defaults to null.
*/
Code.functionEditor.getCodeMirror = function() {
return this.editor_;
};
/**
* Create the DOM for this editor.
* @param {!Element} container DOM should be appended to this containing div.
*/
Code.functionEditor.createDom = function(container) {
container.innerHTML = `
Verb:
none
this
something
any
none
any
with/using
at/to
in front of
in/inside/into
on top of/on/onto/upon
out of/from inside/from
over
through
under/underneath/beneath
behind
beside
for/about
is
as
off/off of
none
this
something
any
`;
container.id = 'functionEditor';
var options = {
continueComments: {continueLineComment: false},
lint: Code.Editor.JSHintReady,
mode: 'text/javascript',
rulers: [{color: '#ddd', column: 80, lineStyle: 'dashed'}],
theme: 'eclipse'
};
this.editor_ = Code.Editor.newCodeMirror(container, options);
this.isVerbElement_ = document.getElementById('isVerb');
this.verbElement_ = document.getElementById('verb');
this.dobjElement_ = document.getElementById('dobj');
this.prepElement_ = document.getElementById('prep');
this.iobjElement_ = document.getElementById('iobj');
};
// Matches the signature of a function declaration.
// Split the source into leading meta-data comments and function body.
Code.functionEditor.functionRegex_ =
/^((?:[ \t]*(?:\/\/[^\n]*)?\n)*)\s*(function[\S\s]*)$/;
/**
* Enable or disable the verb UI elements based on the isVerb checkbox.
*/
Code.functionEditor.updateDisabled = function() {
var disabled = this.isVerbElement_.checked ? '' : 'disabled';
this.verbElement_.disabled = disabled;
this.dobjElement_.disabled = disabled;
this.prepElement_.disabled = disabled;
this.iobjElement_.disabled = disabled;
};
/**
* Get the contents of the editor.
* @return {string} Plain text contents.
*/
Code.functionEditor.getSource = function() {
if (!this.created) {
return Code.Editor.uncreatedEditorSource;
}
var source = this.editor_.getValue();
// Trim trailing whitespace.
source = source.replace(/[ \t]+(?=\n)/g, '').replace(/[ \t]+$/, '');
var verb = '@delete_prop verb';
var dobj = '@delete_prop dobj';
var prep = '@delete_prop prep';
var iobj = '@delete_prop iobj';
if (this.isVerbElement_.checked) {
verb = '@set_prop verb = ' + JSON.stringify(this.verbElement_.value);
dobj = '@set_prop dobj = ' + JSON.stringify(this.dobjElement_.value);
prep = '@set_prop prep = ' + JSON.stringify(this.prepElement_.value);
iobj = '@set_prop iobj = ' + JSON.stringify(this.iobjElement_.value);
}
return `
${this.metaExtra_.join('\n').trim()}
// ${verb}
// ${dobj}
// ${prep}
// ${iobj}
${source}
`.trim();
};
/**
* Set the contents of the editor.
* @param {string} source Plain text contents.
*/
Code.functionEditor.setSource = function(source) {
var m = source.match(Code.functionEditor.functionRegex_);
this.confidence = m ? 0.5 : 0;
if (this.created) {
this.metaExtra_ = [];
var meta;
if (m) {
meta = m[1].split(/\n/);
source = m[2];
} else {
meta = '';
source = 'function() {\n}';
}
var props = {
'verb': '',
'dobj': 'none',
'prep': 'none',
'iobj': 'none'
};
var isVerb = false;
for (var line of meta) {
var m = line.match(Code.functionEditor.setSource.metaSetRegex_);
if (m) {
try {
props[m[1]] = JSON.parse(m[2]);
isVerb = true;
} catch (e) {
console.log('Ignoring invalid ' + m[1] + ': ' + m[2]);
}
} else if (!Code.functionEditor.setSource.metaDeleteRegex_.test(line)) {
// Not a meta value we recognize. Preserve it.
this.metaExtra_.push(line);
}
}
this.verbElement_.value = props['verb'];
this.dobjElement_.value = props['dobj'];
this.prepElement_.value = props['prep'];
this.iobjElement_.value = props['iobj'];
this.isVerbElement_.checked = isVerb;
this.updateDisabled();
this.editor_.setValue(source);
}
};
// Matches one meta-data comment: // @set_prop verb = "foobar"
Code.functionEditor.setSource.metaSetRegex_ =
/^\s*\/\/\s*@set_prop\s+(verb|dobj|prep|iobj)\s*=\s*(.+)$/;
// Matches one meta-data comment: // @delete_prop verb
Code.functionEditor.setSource.metaDeleteRegex_ =
/^\s*\/\/\s*@delete_prop\s+(verb|dobj|prep|iobj)$/;
Code.functionEditor.metaExtra_ = [];
/**
* Notification that this editor has just been displayed.
* @param {boolean} userAction True if user clicked on a tab.
*/
Code.functionEditor.focus = function(userAction) {
this.editor_.refresh();
if (userAction) {
this.editor_.focus();
}
};
////////////////////////////////////////////////////////////////////////////////
Code.jsspEditor = new Code.GenericEditor('JSSP');
/**
* JavaScript Server Page editor. Does not exist until tab is selected.
* @type {Object}
* @private
*/
Code.jsspEditor.editor_ = null;
/**
* Return this editor's CodeMirror instance.
* @return {Object} Defaults to null.
*/
Code.jsspEditor.getCodeMirror = function() {
return this.editor_;
};
/**
* Create the DOM for this editor.
* @param {!Element} container DOM should be appended to this containing div.
*/
Code.jsspEditor.createDom = function(container) {
container.id = 'jsspEditor';
var options = {
continueComments: 'Enter',
lint: false, // CodeMirror doesn't understand <% %>.
mode: 'application/x-ejs',
theme: 'eclipse'
};
this.editor_ = Code.Editor.newCodeMirror(container, options);
};
/**
* Get the contents of the editor.
* @return {string} Plain text contents.
*/
Code.jsspEditor.getSource = function() {
if (!this.created) {
return Code.Editor.uncreatedEditorSource;
}
var source = this.editor_.getValue();
return JSON.stringify(source);
};
/**
* Set the contents of the editor.
* @param {string} source Plain text contents.
*/
Code.jsspEditor.setSource = function(source) {
var str;
try {
str = JSON.parse(source);
} catch (e) {}
if (typeof str !== 'string') {
str = '';
this.confidence = 0;
} else {
if (str.includes('<%') && str.includes('%>')) {
this.confidence = 0.95;
} else {
this.confidence = 0.8;
}
}
if (this.created) {
this.editor_.setValue(str);
}
};
/**
* Notification that this editor has just been displayed.
* @param {boolean} userAction True if user clicked on a tab.
*/
Code.jsspEditor.focus = function(userAction) {
this.editor_.refresh();
if (userAction) {
this.editor_.focus();
}
};
////////////////////////////////////////////////////////////////////////////////
Code.svgEditor = new Code.GenericEditor('SVG');
/**
* DOMParser used to determine if the source is SVG.
*/
Code.svgEditor.parser = new DOMParser();
/**
* Create the DOM for this editor.
* @param {!Element} container DOM should be appended to this containing div.
*/
Code.svgEditor.createDom = function(container) {
container.innerHTML = `
`;
this.frameWindow_ = container.querySelector('iframe').contentWindow;
};
/**
* Get the contents of the editor.
* @return {string} Plain text contents.
*/
Code.svgEditor.getSource = function() {
if (!this.created) {
return Code.Editor.uncreatedEditorSource;
}
var xmlString = this.frameWindow_.hasOwnProperty('initialSource') ?
this.frameWindow_.initialSource :
this.frameWindow_.svgEditor.getString();
return JSON.stringify(xmlString);
};
/**
* Set the contents of the editor.
* @param {string} text Plain text contents.
*/
Code.svgEditor.setSource = function(source) {
var str = undefined;
this.confidence = 0;
try {
str = JSON.parse(source);
} catch (e) {}
if (typeof str === 'string') {
// DOMParser needs contents wrapped in a parent SVG node.
var dom = Code.svgEditor.parser.parseFromString('' + str + ' ',
'text/xml');
// Let's see if this DOM contains only SVG tags.
var nodes = dom.documentElement.querySelectorAll('*');
var isSvg = nodes.length > 0;
for (var node of nodes) {
if (!Code.svgEditor.ELEMENT_NAMES.has(node.tagName)) {
isSvg = false;
break;
}
}
if (isSvg) {
this.confidence = 0.95;
} else {
str = '';
}
} else {
str = '';
}
if (this.created) {
if (this.frameWindow_.svgEditor) {
this.frameWindow_.svgEditor.setString(str);
} else {
// The iframe exists, but the editor hasn't loaded yet.
// Save the source in a property on the iframe, so it can load when ready.
this.frameWindow_.initialSource = str;
}
}
};
/**
* Notification that this editor has just been displayed.
* @param {boolean} userAction True if user clicked on a tab.
*/
Code.svgEditor.focus = function(userAction) {
if (userAction && this.frameWindow_.svgEditor) {
// Window may have resized since this tab was last visible.
this.frameWindow_.svgEditor.resize();
}
};
/**
* Whitelist of all allowed SVG element names.
* Try to keep this list in sync with CCC.World.xmlToSvg.ELEMENT_NAMES.
*/
Code.svgEditor.ELEMENT_NAMES = new Set([
'circle',
'desc',
'ellipse',
'g',
'line',
'path',
'polygon',
'polyline',
'rect',
'svg',
'text',
'title',
'tspan',
]);
////////////////////////////////////////////////////////////////////////////////
Code.stringEditor = new Code.GenericEditor('String');
/**
* Create the DOM for this editor.
* @param {!Element} container DOM should be appended to this containing div.
*/
Code.stringEditor.createDom = function(container) {
container.innerHTML = `
“
”
`;
this.textarea_ = container.querySelector('textarea');
};
/**
* Get the contents of the editor.
* @return {string} Plain text contents.
*/
Code.stringEditor.getSource = function() {
return this.created ?
JSON.stringify(this.textarea_.value) :
Code.Editor.uncreatedEditorSource;
};
/**
* Set the contents of the editor.
* @param {string} text Plain text contents.
*/
Code.stringEditor.setSource = function(source) {
var str;
try {
str = Code.stringEditor.parseString(source.trim());
this.confidence = 0.9;
} catch (e) {
str = '';
this.confidence = 0;
}
if (this.created) {
this.textarea_.value = str;
}
};
/**
* Convert a string representation of a string literal to a string.
* Basically does eval(s), but safely and only if s is a string
* literal.
* Copied from $.utils.code.parseString
* @param {string} s Candidate string literal.
* @retun {string} String value.
*/
Code.stringEditor.parseString = function(s) {
if (!Code.stringEditor.stringExact_.test(s)) {
throw new TypeError('Not a string literal');
}
return s.slice(1, -1).replace(Code.stringEditor.stringEscapes_, function(esc) {
switch (esc[1]) {
case "'":
case '"':
case '/':
case '\\':
return esc[1];
case '0':
return '\0';
case 'b':
return '\b';
case 'f':
return '\f';
case 'n':
return '\n';
case 'r':
return '\r';
case 't':
return '\t';
case 'v':
return '\v';
case 'u':
case 'x':
return String.fromCharCode(parseInt(esc.slice(2), 16));
default:
// RegExp in call to replace has accepted something we
// don't know how to decode.
throw new Error('unknown escape sequence "' + esc + '"??');
}
});
};
/**
* Tests if a valid string literal.
* Copied from $.utils.code.regexps.stringExact
*/
Code.stringEditor.stringExact_ = /^(?:'(?:[^'\\\r\n\u2028\u2029]|\\(?:["'\\\/0bfnrtv]|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{2}))*'|"(?:[^"\\\r\n\u2028\u2029]|\\(?:["'\\\/0bfnrtv]|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{2}))*")$/;
/**
* Finds escape sequences in string literals.
* Copied from $.utils.code.regexps.escapes
*/
Code.stringEditor.stringEscapes_ = /\\(?:["'\\\/0bfnrtv]|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{2})/g;
/**
* Notification that this editor has just been displayed.
* @param {boolean} userAction True if user clicked on a tab.
*/
Code.stringEditor.focus = function(userAction) {
if (userAction) {
this.textarea_.focus();
}
};
////////////////////////////////////////////////////////////////////////////////
//Code.regExpEditor = new Code.GenericEditor('RegExp');
////////////////////////////////////////////////////////////////////////////////
//Code.dateEditor = new Code.GenericEditor('Date');
////////////////////////////////////////////////////////////////////////////////
Code.diffEditor = new Code.GenericEditor('Diff');
/**
* Create the DOM for this editor.
* @param {!Element} container DOM should be appended to this containing div.
*/
Code.diffEditor.createDom = function(container) {
container.innerHTML = `
`;
this.frameWindow_ = container.querySelector('iframe').contentWindow;
};
/**
* Get the contents of the editor.
* @return {string} Plain text contents.
*/
Code.diffEditor.getSource = function() {
if (!this.created) {
return Code.Editor.uncreatedEditorSource;
}
if (this.frameWindow_.hasOwnProperty('initialSource')) {
return this.frameWindow_.initialSource;
}
return this.frameWindow_.diffEditor.getString();
};
/**
* Set the contents of the editor.
* @param {string} source Plain text contents.
*/
Code.diffEditor.setSource = function(source) {
if (this.created) {
if (this.frameWindow_.diffEditor) {
this.frameWindow_.diffEditor.setString(source, Code.Editor.originalSource);
} else {
// The iframe exists, but the editor hasn't loaded yet.
// Save the source in a property on the iframe, so it can load when ready.
this.frameWindow_.initialSource = source;
this.frameWindow_.originalSource = Code.Editor.originalSource;
}
}
};
================================================
FILE: static/code/explorer.js
================================================
/**
* @license
* Copyright 2018 Google LLC
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @fileoverview Integrated Development Environment for Code City.
* @author fraser@google.com (Neil Fraser)
*/
'use strict';
Code.Explorer = {};
/**
* Width in pixels of each monospaced character in the input.
* Used to line up the autocomplete menu.
* TODO: If the menu starts getting out of alignment, measure the text instead.
*/
Code.Explorer.SIZE_OF_INPUT_CHARS = 8.8;
/**
* Offset in pixels of start of first character in the input.
* Used to line up the autocomplete menu.
* TODO: If the menu starts getting out of alignment, measure the text instead.
*/
Code.Explorer.LEFT_OF_INPUT_CHARS = 6;
/**
* Value of the input field last time it was processed.
* @type {?string}
*/
Code.Explorer.oldInputValue = null;
/**
* JSON-encoded list of complete object selector parts.
* @type {string}
*/
Code.Explorer.partsJSON = '[]';
/**
* Final token which may not be complete and isn't included in the parts list.
* E.g. '$.foo.bar' the 'bar' might become 'bart' or 'barf'.
* @type {?Object}
*/
Code.Explorer.lastNameToken = null;
/**
* PID of task polling for changes to the input field.
*/
Code.Explorer.inputPollPid = 0;
/**
* Is it ok to normalize the input? False if the user is typing.
*/
Code.Explorer.inputUpdatable = true;
/**
* The last set of autocompletion options from Code City.
* The 'properties' property is an array of arrays of strings. The first array
* contains the properties on the object, the second array contains the
* properties on the object's prototype, and so on.
* The 'keywords' property is an array of strings. E.g. ['{proto}', '{owner}']
* @type {Object}
*/
Code.Explorer.autocompleteData = null;
/**
* The type of the autocomplete menu, 'id' or 'keyword'.
* @type {string}
*/
Code.Explorer.autocompleteType = '';
/**
* Got a ping from someone. Something might have changed and need updating.
*/
Code.Explorer.receiveMessage = function() {
var selector = sessionStorage.getItem(Code.Common.SELECTOR);
// Propagate the ping down the tree of frames.
var parts = Code.Common.selectorToParts(selector);
if (parts) {
if (Code.Explorer.inputUpdatable) {
// Valid parts, set the input to be canonical version.
Code.Explorer.setInput(parts);
}
Code.Explorer.loadPanels(parts);
} else {
// Invalid parts, set the input to the raw string.
// Can be caused by going to: /code?$.foo...bar
var input = document.getElementById('input');
input.value = selector;
Code.Explorer.inputChange();
input.focus();
}
};
/**
* Handle any changes to the input field.
*/
Code.Explorer.inputChange = function() {
var input = document.getElementById('input');
if (Code.Explorer.oldInputValue === input.value) {
return; // No change.
}
Code.Explorer.oldInputValue = input.value;
var parsed = Code.Explorer.parseInput(input.value);
if (Code.Explorer.lastNameToken === null && parsed.lastNameToken) {
// Look for cases where a deletion has resulted in a valid parts list.
// E.g. $.foo.bar. -> $.foo.bar
// Without this check, 'bar' would be considered a lastNameToken fragment
// and the object panels would back-slide one step to $.foo
var partsCopy = parsed.parts.slice();
partsCopy.push(
{type: parsed.lastNameToken.type, value: parsed.lastNameToken.value});
var oldParts = JSON.parse(Code.Explorer.partsJSON);
if (oldParts) {
oldParts.length = partsCopy.length;
}
if (JSON.stringify(partsCopy) === JSON.stringify(oldParts)) {
// Rewrite the parsed input to be complete.
parsed = {
lastNameToken: null,
lastToken: null,
parts: partsCopy,
valid: true
};
}
}
Code.Explorer.lastNameToken = parsed.lastNameToken;
var partsJSON = JSON.stringify(parsed.parts);
if (Code.Explorer.partsJSON === partsJSON) {
Code.Explorer.updateAutocompleteMenu();
} else {
Code.Explorer.hideAutocompleteMenu();
Code.Explorer.setParts(parsed.parts, false);
}
input.classList.toggle('invalid', !parsed.valid);
};
/**
* Parse the input value.
* @param {string} inputValue Selector string from input field.
* @return {!Object} Object with four fields:
* parts: Array of selector parts.
* lastNameToken: Last token that was an id, str, num, or keyword.
* lastToken: Last token. Null if no tokens.
* valid: True if all tokens are valid (or could become valid).
*/
Code.Explorer.parseInput = function(inputValue) {
var tokens = Code.Common.tokenizeSelector(inputValue);
var parts = [];
var token = null;
var lastNameToken = null;
var valid = true;
for (token of tokens) {
if (lastNameToken) {
parts.push({type: 'id', value: lastNameToken.value});
lastNameToken = null;
}
if (!token.valid) {
valid = false;
break;
}
if (token.type === 'keyword' && token.complete) {
parts.push({type: 'keyword', value: token.value});
} else if (['id', 'str', 'num', 'keyword'].includes(token.type)) {
lastNameToken = token;
}
}
return {
parts: parts,
lastNameToken: lastNameToken,
lastToken: token,
valid: valid
};
};
/**
* Check to see if there's any autocomplete data, and if so update the menu.
*/
Code.Explorer.loadAutocomplete = function() {
var parts = JSON.parse(Code.Explorer.partsJSON);
var selector = Code.Common.partsToSelector(parts);
var data = Code.Explorer.getPanelData(selector);
if (data) {
Code.Explorer.autocompleteData = {};
// Flatten the data into a sorted list of options.
var set = new Set();
if (data.properties) {
for (var obj of data.properties) {
for (var prop of obj) {
set.add(prop.name);
}
}
}
if (data.roots) {
for (var root of data.roots) {
set.add(root.name);
}
}
Code.Explorer.autocompleteData.properties =
Array.from(set.keys()).sort(Code.Common.caseInsensitiveComp);
set.clear();
if (data.keywords) {
for (var word of data.keywords) {
set.add(word);
}
}
Code.Explorer.autocompleteData.keywords =
Array.from(set.keys()).sort();
} else {
Code.Explorer.autocompleteData = null;
}
// If the input value is unchanged, display the autocompletion menu.
var input = document.getElementById('input');
if (Code.Explorer.oldInputValue === input.value) {
Code.Explorer.updateAutocompleteMenu();
}
};
/**
* Given a partial prefix, filter the autocompletion menu and display
* all matching options.
*/
Code.Explorer.updateAutocompleteMenu = function() {
if (!Code.Explorer.autocompleteData) return;
var parsed = Code.Explorer.parseInput(input.value);
var token = parsed.lastToken;
// If the lastToken is part of the submitted parts, no menu.
if (token) {
parsed.parts.push({'type': token.type, 'value': token.value});
}
if (JSON.stringify(parsed.parts) === Code.Explorer.partsJSON) {
Code.Explorer.hideAutocompleteMenu();
return;
}
// Otherwise, show a menu filtered on the partial token.
var options = [];
var index = token ? token.index : 0;
if (token.type === 'keyword') {
var prefix = token.value;
// Filter the keywords.
for (var option of Code.Explorer.autocompleteData.keywords) {
if (option.substring(0, prefix.length).toLowerCase() === prefix) {
options.push(option);
}
}
Code.Explorer.autocompleteType = 'keyword';
} else {
// Property.
var prefix = '';
if (token) {
if (token.type === 'id' || token.type === 'str') {
prefix = token.value.toLowerCase();
}
if ((token.type === 'num') && !isNaN(token.value)) {
prefix = String(token.value);
}
if (token.type === '.' || token.type === '[') {
index += token.raw.length;
}
}
if (!token || token.type === '.' || token.type === 'id' ||
token.type === '[' || token.type === 'str' || token.type === 'num') {
// Filter the properties.
for (var option of Code.Explorer.autocompleteData.properties) {
if (option.substring(0, prefix.length).toLowerCase() === prefix) {
options.push(option);
}
}
}
Code.Explorer.autocompleteType = 'id';
}
if (!options.length ||
(options.length === 1 && options[0].length === prefix.length)) {
// Length equality above is needed since prefix is lowercased.
Code.Explorer.hideAutocompleteMenu();
} else {
Code.Explorer.showAutocompleteMenu(options, index);
}
};
/**
* Hide any autocompletions if the cursor isn't at the end.
* @return {boolean} True if cursor is not at the end.
*/
Code.Explorer.autocompleteCursorMonitor = function() {
var input = document.getElementById('input');
if (typeof input.selectionStart === 'number' &&
input.selectionStart !== input.value.length) {
Code.Explorer.hideAutocompleteMenu();
return true;
}
return false;
};
/**
* Display the autocomplete menu, populated with the provided options.
* @param {!Array} options Array of options.
* @param {number} index Left offset (in characters) to position menu.
*/
Code.Explorer.showAutocompleteMenu = function(options, index) {
if (Code.Explorer.autocompleteCursorMonitor()) {
return;
}
var scrollDiv = document.getElementById('autocompleteMenuScroll');
scrollDiv.innerHTML = '';
for (var option of options) {
var div = document.createElement('div');
div.appendChild(document.createTextNode(option));
div.addEventListener('mouseover', Code.Explorer.autocompleteMouseOver);
div.addEventListener('mouseout', Code.Explorer.autocompleteMouseOut);
div.setAttribute('data-option', option);
scrollDiv.appendChild(div);
}
var menuDiv = document.getElementById('autocompleteMenu');
menuDiv.style.display = 'block';
menuDiv.scrollTop = 0;
var left = Math.round(index * Code.Explorer.SIZE_OF_INPUT_CHARS -
Code.Explorer.LEFT_OF_INPUT_CHARS);
var maxLeft = window.innerWidth - menuDiv.offsetWidth;
menuDiv.style.left = Math.min(left, maxLeft) + 'px';
var maxHeight = window.innerHeight - menuDiv.offsetTop - 12;
menuDiv.style.maxHeight = maxHeight + 'px';
};
/**
* Stop displaying the autocomplete menu.
*/
Code.Explorer.hideAutocompleteMenu = function() {
document.getElementById('autocompleteMenu').style.display = 'none';
Code.Explorer.autocompleteSelect(null);
Code.Explorer.autocompleteType = '';
};
/**
* Date/time of last keyboard navigation.
* Don't allow mouse movements to change the autocompletion selection
* Right after a keyboard navigation. Otherwise an arrow keypress could cause
* a scroll which could cause an apparent mouse move, which could cause an
* unwanted selection change.
*/
Code.Explorer.keyNavigationTime = 0;
/**
* Highlight one autocomplete option.
* @param {!Event} e Mouse over event.
*/
Code.Explorer.autocompleteMouseOver = function(e) {
if (Date.now() - Code.Explorer.keyNavigationTime > 250) {
Code.Explorer.autocompleteSelect(e.target);
}
};
/**
* Remove highlighting from autocomplete option.
* @param {!Event} e Mouse out event.
*/
Code.Explorer.autocompleteMouseOut = function() {
if (Date.now() - Code.Explorer.keyNavigationTime > 250) {
Code.Explorer.autocompleteSelect(null);
}
};
/**
* Highlight one option. Unhighlight all other options.
* @param {?Element} div Option to highlight or null for none.
*/
Code.Explorer.autocompleteSelect = function(div) {
// There should only be zero or one option selected, but deselect them
// all in case there was a UI bug.
var selections =
document.querySelectorAll('#autocompleteMenuScroll>.selected');
for (var selected of selections) {
selected.className = '';
}
if (div) {
div.className = 'selected';
}
};
/**
* An autocompletion option has been clicked by the user.
* @param {!Event} e Click event.
*/
Code.Explorer.autocompleteClick = function(e) {
var option = e.target.getAttribute('data-option');
var parts = JSON.parse(Code.Explorer.partsJSON);
parts.push({type: Code.Explorer.autocompleteType, value: option});
Code.Explorer.setParts(parts, true);
};
/**
* Set the currently specified path.
* Notify the parent frame.
* @param {!Array} parts List of parts.
* @param {boolean} updateInput Normalize the input if true.
*/
Code.Explorer.setParts = function(parts, updateInput) {
Code.Explorer.partsJSON = JSON.stringify(parts);
Code.Explorer.inputUpdatable = updateInput;
Code.Explorer.hideAutocompleteMenu();
Code.Explorer.loadAutocomplete();
var selector = Code.Common.partsToSelector(parts);
sessionStorage.setItem(Code.Common.SELECTOR, selector);
window.parent.postMessage('ping', '*');
};
/**
* Set the input to be the specified path.
* @param {!Array} parts List of parts.
*/
Code.Explorer.setInput = function(parts) {
Code.Explorer.hideAutocompleteMenu();
var value = Code.Common.partsToSelector(parts);
var input = document.getElementById('input');
input.value = value;
input.classList.remove('invalid');
input.focus();
Code.Explorer.oldInputValue = value; // Don't autocomplete this value.
};
/**
* Start polling for changes.
*/
Code.Explorer.inputFocus = function() {
clearInterval(Code.Explorer.inputPollPid);
Code.Explorer.inputPollPid = setInterval(Code.Explorer.inputChange, 10);
Code.Explorer.inputUpdatable = false;
};
/**
* Stop polling for changes and hide the autocomplete menu.
*/
Code.Explorer.inputBlur = function() {
if (Code.Explorer.inputBlur.disable_) {
Code.Explorer.inputBlur.disable_ = false;
return;
}
clearInterval(Code.Explorer.inputPollPid);
Code.Explorer.hideAutocompleteMenu();
Code.Explorer.inputUpdatable = true;
};
Code.Explorer.inputBlur.disable_ = false;
/**
* When clicking on the autocomplete menu, disable the blur
* (which would otherwise close the menu).
*/
Code.Explorer.autocompleteMouseDown = function() {
Code.Explorer.inputBlur.disable_ = true;
};
/**
* Intercept some control keys to control the autocomplete menu.
* @param {!Event} e Keypress event.
*/
Code.Explorer.inputKey = function(e) {
var key = {
TAB: 9,
ENTER: 13,
ESC: 27,
UP: 38,
DOWN: 40
};
if (e.keyCode === key.ESC) {
Code.Explorer.hideAutocompleteMenu();
}
Code.Explorer.autocompleteCursorMonitor();
var scrollDiv = document.getElementById('autocompleteMenuScroll');
var selected = scrollDiv.querySelector('.selected');
var menuDiv = document.getElementById('autocompleteMenu');
var hasMenu = menuDiv.style.display !== 'none';
if (e.keyCode === key.ENTER) {
var parts = JSON.parse(Code.Explorer.partsJSON);
if (selected) {
// Add the selected autocomplete option to the input.
var option = selected.getAttribute('data-option');
parts.push({type: Code.Explorer.autocompleteType, value: option});
} else if (Code.Explorer.lastNameToken &&
Code.Explorer.lastNameToken.valid) {
// The currently typed input should be considered complete.
// E.g. $.foo is not waiting to become $.foot
parts.push({type: 'id', value: Code.Explorer.lastNameToken.value});
Code.Explorer.lastNameToken = null;
}
Code.Explorer.setParts(parts, true);
e.preventDefault();
}
if (e.keyCode === key.TAB) {
if (hasMenu) {
// Extract all options from the menu.
var options = [];
for (var i = 0, option; (option = scrollDiv.childNodes[i]); i++) {
options[i] = option.getAttribute('data-option');
}
var prefix = '';
if (Code.Explorer.lastNameToken &&
Code.Explorer.lastNameToken.type === 'id') {
prefix = Code.Explorer.lastNameToken.value;
}
var tuple = Code.Explorer.autocompletePrefix(options, prefix);
if (tuple.terminal) {
// There was only one option. Choose it.
var parts = JSON.parse(Code.Explorer.partsJSON);
parts.push({type: Code.Explorer.autocompleteType, value: tuple.prefix});
Code.Explorer.setParts(parts, true);
} else {
// Append the common prefix to the existing input.
var input = document.getElementById('input');
if (Code.Explorer.lastNameToken) {
input.value = input.value.substring(0,
Code.Explorer.lastNameToken.index) + tuple.prefix;
} else {
input.value += tuple.prefix;
}
// TODO: Tab-completion of partial strings and numbers.
}
}
e.preventDefault();
}
if (hasMenu && (e.keyCode === key.UP || e.keyCode === key.DOWN)) {
Code.Explorer.keyNavigationTime = Date.now();
var newSelected;
if (e.keyCode === key.UP) {
if (!selected) {
newSelected = scrollDiv.lastChild;
} else if (selected.previousSibling) {
newSelected = selected.previousSibling;
}
} else if (e.keyCode === key.DOWN) {
if (!selected) {
newSelected = scrollDiv.firstChild;
} else if (selected.nextSibling) {
newSelected = selected.nextSibling;
}
}
if (newSelected) {
Code.Explorer.autocompleteSelect(newSelected);
if (newSelected.scrollIntoView) {
newSelected.scrollIntoView({block: 'nearest', inline: 'nearest'});
}
}
e.preventDefault();
}
};
/**
* Given a list of options, and an existing prefix, return the common prefix.
* E.g. (['food', 'foot'], 'f') -> {prefix: 'foo', terminal: false}
* @param {!Array} options Array of autocompleted strings.
* @param {string} prefix Any existing prefix.
* @return {{prefix: string, terminal: boolean}} Tuple with the maximum common
* prefix, and whether this completion is terminal (true), or if there's the
* option of continuing (false).
*/
Code.Explorer.autocompletePrefix = function(options, prefix) {
// Filter out only those completions that case-sensitively match the prefix.
var optionsCase = options.filter(
function(option) {return option.startsWith(prefix);});
if (optionsCase.length) {
return {prefix: Code.Explorer.getPrefix(optionsCase),
terminal: optionsCase.length === 1};
}
// Find completions that don't match the prefix's case.
var common = Code.Explorer.getPrefix(options);
if (common.length > prefix.length) {
var optionsCommon = options.filter(
function(option) {return option.startsWith(common);});
return {prefix: common, terminal: optionsCommon.length === 1};
}
return {prefix: prefix, terminal: false};
};
/**
* Compute and return the common prefix of n (relatively short) strings.
* @param {!Array} strs Array of string.
* @return {string} Common prefix.
*/
Code.Explorer.getPrefix = function(strs) {
if (strs.length === 0) {
return '';
}
var i = 0;
while (true) {
var letter = strs[0][i];
for (var j = 0; j < strs.length; j++) {
if (strs[j].length <= i) {
return strs[j];
}
if (strs[j][i] !== letter) {
return strs[j].substring(0, i);
}
}
i++;
}
};
/**
* If a mouse-click caused the cursor to move away from the end,
* close the autocomplete menu.
*/
Code.Explorer.inputMouseDown = function() {
setTimeout(Code.Explorer.autocompleteCursorMonitor, 1);
};
/**
* Number of object panels.
*/
Code.Explorer.panelCount = 0;
/**
* Size of temporary spacer margin for smooth scrolling after deletion.
*/
Code.Explorer.panelSpacerMargin = 0;
/**
* Update the panels with the specified list of parts.
* @param {!Array} parts List of parts.
*/
Code.Explorer.loadPanels = function(parts) {
for (var i = 0; i <= parts.length; i++) {
var selector = Code.Common.partsToSelector(parts.slice(0, i));
var iframe = document.getElementById('objectPanel' + i);
if (iframe) {
if (iframe.getAttribute('data-selector') === selector) {
// Highlight current item.
iframe.contentWindow.postMessage('ping', '*');
continue;
} else {
while (Code.Explorer.panelCount > i) {
Code.Explorer.removePanel();
}
}
}
iframe = Code.Explorer.addPanel(selector);
}
while (Code.Explorer.panelCount > i) {
Code.Explorer.removePanel();
}
};
/**
* Add an object panel to the right.
* @param {string} selector Selector string.
*/
Code.Explorer.addPanel = function(selector) {
var panelsScroll = document.getElementById('panelsScroll');
var iframe = document.createElement('iframe');
iframe.addEventListener('load', Code.Explorer.loadAutocomplete);
iframe.id = 'objectPanel' + Code.Explorer.panelCount;
iframe.src = 'objectPanel?' + encodeURIComponent(selector);
iframe.setAttribute('data-selector', selector);
var spacer = document.getElementById('panelSpacer');
panelsScroll.insertBefore(iframe, spacer);
Code.Explorer.panelCount++;
Code.Explorer.panelSpacerMargin =
Math.max(0, Code.Explorer.panelSpacerMargin - iframe.offsetWidth);
Code.Explorer.scrollPanel();
};
/**
* Remove the right-most panel.
*/
Code.Explorer.removePanel = function() {
Code.Explorer.panelCount--;
var iframe = document.getElementById('objectPanel' +
Code.Explorer.panelCount);
Code.Explorer.panelSpacerMargin += iframe.offsetWidth;
iframe.parentNode.removeChild(iframe);
Code.Explorer.scrollPanel();
};
/**
* After addition, quickly scroll the panels all the way to see the right edge.
* After deletion, reduce the spacer so that the panels scroll to the edge.
*/
Code.Explorer.scrollPanel = function() {
var spacer = document.getElementById('panelSpacer');
var speed = 20;
clearTimeout(Code.Explorer.scrollPid_);
if (Code.Explorer.panelSpacerMargin > 0) {
// Reduce spacer.
Code.Explorer.panelSpacerMargin =
Math.max(0, Code.Explorer.panelSpacerMargin - speed);
spacer.style.marginRight = Code.Explorer.panelSpacerMargin + 'px';
if (Code.Explorer.panelSpacerMargin > 0) {
Code.Explorer.scrollPid_ = setTimeout(Code.Explorer.scrollPanel, 10);
}
} else {
spacer.style.marginRight = 0;
// Scroll right.
var panels = document.getElementById('panels');
var oldScroll = panels.scrollLeft;
panels.scrollLeft += speed;
if (panels.scrollLeft > oldScroll) {
Code.Explorer.scrollPid_ = setTimeout(Code.Explorer.scrollPanel, 10);
}
}
};
/**
* PID of currently executing scroll animation.
* @private
*/
Code.Explorer.scrollPid_ = 0;
/**
* Get the data blob from the specified object panel.
* @param {string} selector Selector string.
* @return {!Object|undefined} Data blob, or undefined if data is not
* currently available.
*/
Code.Explorer.getPanelData = function(selector) {
// Find the object panel that contains the needed data.
for (var iframe of document.getElementsByTagName('iframe')) {
if (iframe.getAttribute('data-selector') === selector) {
try {
// Risky: Content may not have loaded yet.
var data = iframe.contentWindow.Code.ObjectPanel.data;
} catch (e) {}
break;
}
}
return data;
};
/**
* Keydown handler for the explorer frame.
* @param {!KeyboardEvent} e Keydown event.
*/
Code.Explorer.keyDown = function(e) {
// The editor frame may have strong opinions about key presses.
try {
parent.frames[1].Code.Editor.keyDown(e);
} catch (ex) {
// Frame might not be loaded yet.
}
};
/**
* Page has loaded, initialize the explorer.
*/
Code.Explorer.init = function() {
var input = document.getElementById('input');
input.addEventListener('focus', Code.Explorer.inputFocus);
input.addEventListener('blur', Code.Explorer.inputBlur);
input.addEventListener('keydown', Code.Explorer.inputKey);
input.addEventListener('mousedown', Code.Explorer.inputMouseDown);
document.addEventListener('keydown', Code.Explorer.keyDown);
var scrollDiv = document.getElementById('autocompleteMenuScroll');
scrollDiv.addEventListener('mousedown', Code.Explorer.autocompleteMouseDown);
scrollDiv.addEventListener('click', Code.Explorer.autocompleteClick);
Code.Explorer.receiveMessage();
};
if (!window.TEST) {
window.addEventListener('load', Code.Explorer.init);
window.addEventListener('message', Code.Explorer.receiveMessage, false);
}
================================================
FILE: static/code/mobwrite/demo/editor.html
================================================
MobWrite as a Collaborative Editor
================================================
FILE: static/code/mobwrite/demo/form.html
================================================
MobWrite as a Collaborative Form
MobWrite as a Collaborative Form
================================================
FILE: static/code/mobwrite/demo/mobwrite_form.js
================================================
/**
* @license
* Copyright 2008 Google LLC
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @fileoverview This client-side code interfaces with form elements.
* @author fraser@google.com (Neil Fraser)
*/
/**
* Checks to see if the provided node is still part of the DOM.
* @param {Node} node DOM node to verify.
* @return {boolean} Is this node part of a DOM?
* @private
*/
mobwrite.validNode_ = function(node) {
while (node.parentNode) {
node = node.parentNode;
}
// The topmost node should be type 9, a document.
return node.nodeType == 9;
};
// FORM
/**
* Handler to accept forms as elements that can be shared.
* Share each of the form's elements.
* @param {Object|string} form Form or ID of form to share
* @return {Object?} A sharing object or null.
*/
mobwrite.shareHandlerForm = function(form) {
if (typeof form == 'string') {
form = document.getElementById(form) || document.forms[form];
}
if (form && 'tagName' in form && form.tagName == 'FORM') {
for (var x = 0, el; el = form.elements[x]; x++) {
mobwrite.share(el);
}
}
return null;
};
// Register this shareHandler with MobWrite.
mobwrite.shareHandlers.push(mobwrite.shareHandlerForm);
// HIDDEN
/**
* Constructor of shared object representing a hidden input.
* @param {Node} node A hidden element.
* @constructor
*/
mobwrite.shareHiddenObj = function(node) {
// Call our prototype's constructor.
mobwrite.shareObj.apply(this, [node.id]);
this.element = node;
};
// The hidden input's shared object's parent is a shareObj.
mobwrite.shareHiddenObj.prototype = new mobwrite.shareObj('');
/**
* Retrieve the user's content.
* @return {string} Plaintext content.
*/
mobwrite.shareHiddenObj.prototype.getClientText = function() {
if (!mobwrite.validNode_(this.element)) {
mobwrite.unshare(this.file);
}
// Numeric data should use overwrite mode.
this.mergeChanges = !this.element.value.match(/^\s*-?[\d.]+\s*$/);
return this.element.value;
};
/**
* Set the user's content.
* @param {string} text New content.
*/
mobwrite.shareHiddenObj.prototype.setClientText = function(text) {
this.element.value = text;
};
/**
* Handler to accept hidden fields as elements that can be shared.
* If the element is a hidden field, create a new sharing object.
* @param {*} node Object or ID of object to share.
* @return {Object?} A sharing object or null.
*/
mobwrite.shareHiddenObj.shareHandler = function(node) {
if (typeof node == 'string') {
node = document.getElementById(node);
}
if (node && 'type' in node && node.type == 'hidden') {
return new mobwrite.shareHiddenObj(node);
}
return null;
};
// Register this shareHandler with MobWrite.
mobwrite.shareHandlers.push(mobwrite.shareHiddenObj.shareHandler);
// CHECKBOX
/**
* Constructor of shared object representing a checkbox.
* @param {Node} node A checkbox element.
* @constructor
*/
mobwrite.shareCheckboxObj = function(node) {
// Call our prototype's constructor.
mobwrite.shareObj.apply(this, [node.id]);
this.element = node;
this.mergeChanges = false;
};
// The checkbox shared object's parent is a shareObj.
mobwrite.shareCheckboxObj.prototype = new mobwrite.shareObj('');
/**
* Retrieve the user's check.
* @return {string} Plaintext content.
*/
mobwrite.shareCheckboxObj.prototype.getClientText = function() {
if (!mobwrite.validNode_(this.element)) {
mobwrite.unshare(this.file);
}
return this.element.checked ? this.element.value : '';
};
/**
* Set the user's check.
* @param {string} text New content.
*/
mobwrite.shareCheckboxObj.prototype.setClientText = function(text) {
// Safari has a blank value if not set, all other browsers have 'on'.
var value = this.element.value || 'on';
this.element.checked = (text == value);
this.fireChange(this.element);
};
/**
* Handler to accept checkboxen as elements that can be shared.
* If the element is a checkbox, create a new sharing object.
* @param {*} node Object or ID of object to share.
* @return {Object?} A sharing object or null.
*/
mobwrite.shareCheckboxObj.shareHandler = function(node) {
if (typeof node == 'string') {
node = document.getElementById(node);
}
if (node && 'type' in node && node.type == 'checkbox') {
return new mobwrite.shareCheckboxObj(node);
}
return null;
};
// Register this shareHandler with MobWrite.
mobwrite.shareHandlers.push(mobwrite.shareCheckboxObj.shareHandler);
// SELECT OPTION
/**
* Constructor of shared object representing a select box.
* @param {Node} node A select box element.
* @constructor
*/
mobwrite.shareSelectObj = function(node) {
// Call our prototype's constructor.
mobwrite.shareObj.apply(this, [node.id]);
this.element = node;
// If the select box is select-one, use overwrite mode.
// If it is select-multiple, use text merge mode.
this.mergeChanges = (node.type == 'select-multiple');
};
// The select box shared object's parent is a shareObj.
mobwrite.shareSelectObj.prototype = new mobwrite.shareObj('');
/**
* Retrieve the user's selection(s).
* @return {string} Plaintext content.
*/
mobwrite.shareSelectObj.prototype.getClientText = function() {
if (!mobwrite.validNode_(this.element)) {
mobwrite.unshare(this.file);
}
var selected = [];
for (var x = 0, option; option = this.element.options[x]; x++) {
if (option.selected) {
selected.push(option.value);
}
}
return selected.join('\0');
};
/**
* Set the user's selection(s).
* @param {string} text New content.
*/
mobwrite.shareSelectObj.prototype.setClientText = function(text) {
text = '\0' + text + '\0';
for (var x = 0, option; option = this.element.options[x]; x++) {
option.selected = (text.indexOf('\0' + option.value + '\0') != -1);
}
this.fireChange(this.element);
};
/**
* Handler to accept select boxen as elements that can be shared.
* If the element is a select box, create a new sharing object.
* @param {*} node Object or ID of object to share
* @return {Object?} A sharing object or null.
*/
mobwrite.shareSelectObj.shareHandler = function(node) {
if (typeof node == 'string') {
node = document.getElementById(node);
}
if (node && 'type' in node && (node.type == 'select-one' || node.type == 'select-multiple')) {
return new mobwrite.shareSelectObj(node);
}
return null;
};
// Register this shareHandler with MobWrite.
mobwrite.shareHandlers.push(mobwrite.shareSelectObj.shareHandler);
// RADIO BUTTON
/**
* Constructor of shared object representing a radio button.
* @param {Node} node A radio button element.
* @constructor
*/
mobwrite.shareRadioObj = function(node) {
// Call our prototype's constructor.
mobwrite.shareObj.apply(this, [node.id]);
this.elements = [node];
this.form = node.form;
this.name = node.name;
this.mergeChanges = false;
};
// The radio button shared object's parent is a shareObj.
mobwrite.shareRadioObj.prototype = new mobwrite.shareObj('');
/**
* Retrieve the user's check.
* @return {string} Plaintext content.
*/
mobwrite.shareRadioObj.prototype.getClientText = function() {
// TODO: Handle cases where the radio buttons are added or removed.
if (!mobwrite.validNode_(this.elements[0])) {
mobwrite.unshare(this.file);
}
// Group of radio buttons
for (var x = 0; x < this.elements.length; x++) {
if (this.elements[x].checked) {
return this.elements[x].value;
}
}
// Nothing checked.
return '';
};
/**
* Set the user's check.
* @param {string} text New content.
*/
mobwrite.shareRadioObj.prototype.setClientText = function(text) {
for (var x = 0; x < this.elements.length; x++) {
this.elements[x].checked = (text == this.elements[x].value);
this.fireChange(this.elements[x]);
}
};
/**
* Handler to accept radio buttons as elements that can be shared.
* If the element is a radio button, create a new sharing object.
* @param {*} node Object or ID of object to share.
* @return {Object?} A sharing object or null.
*/
mobwrite.shareRadioObj.shareHandler = function(node) {
if (typeof node == 'string') {
node = document.getElementById(node);
}
if (node && 'type' in node && node.type == 'radio') {
// Check to see if this is another element of an existing radio button group.
for (var id in mobwrite.shared) {
if (mobwrite.shared[id].form == node.form && mobwrite.shared[id].name == node.name) {
mobwrite.shared[id].elements.push(node);
return null;
}
}
// Create new radio button object.
return new mobwrite.shareRadioObj(node);
}
return null;
};
// Register this shareHandler with MobWrite.
mobwrite.shareHandlers.push(mobwrite.shareRadioObj.shareHandler);
// TEXTAREA, TEXT & PASSWORD INPUTS
/**
* Constructor of shared object representing a text field.
* @param {Node} node A textarea, text or password input.
* @constructor
*/
mobwrite.shareTextareaObj = function(node) {
// Call our prototype's constructor.
mobwrite.shareObj.apply(this, [node.id]);
this.element = node;
if (node.type == 'password') {
// Use overwrite mode for password field, users can't see.
this.mergeChanges = false;
}
};
// The textarea shared object's parent is a shareObj.
mobwrite.shareTextareaObj.prototype = new mobwrite.shareObj('');
/**
* Retrieve the user's text.
* @return {string} Plaintext content.
*/
mobwrite.shareTextareaObj.prototype.getClientText = function() {
if (!mobwrite.validNode_(this.element)) {
mobwrite.unshare(this.file);
}
var text = mobwrite.shareTextareaObj.normalizeLinebreaks_(this.element.value);
if (this.element.type == 'text') {
// Numeric data should use overwrite mode.
this.mergeChanges = !text.match(/^\s*-?[\d.,]+\s*$/);
}
return text;
};
/**
* Set the user's text.
* @param {string} text New text
*/
mobwrite.shareTextareaObj.prototype.setClientText = function(text) {
this.element.value = text;
this.fireChange(this.element);
};
/**
* Modify the user's plaintext by applying a series of patches against it.
* @param {Array.} patches Array of Patch objects.
*/
mobwrite.shareTextareaObj.prototype.patchClientText = function(patches) {
// Set some constants which tweak the matching behaviour.
// Maximum distance to search from expected location.
this.dmp.Match_Distance = 1000;
// At what point is no match declared (0.0 = perfection, 1.0 = very loose)
this.dmp.Match_Threshold = 0.6;
var oldClientText = this.getClientText();
var cursor = this.captureCursor_();
// Pack the cursor offsets into an array to be adjusted.
// See http://neil.fraser.name/writing/cursor/
var offsets = [];
if (cursor) {
offsets[0] = cursor.startOffset;
if ('endOffset' in cursor) {
offsets[1] = cursor.endOffset;
}
}
var newClientText = this.patch_apply_(patches, oldClientText, offsets);
// Set the new text only if there is a change to be made.
if (oldClientText != newClientText) {
this.setClientText(newClientText);
if (cursor) {
// Unpack the offset array.
cursor.startOffset = offsets[0];
if (offsets.length > 1) {
cursor.endOffset = offsets[1];
if (cursor.startOffset >= cursor.endOffset) {
cursor.collapsed = true;
}
}
this.restoreCursor_(cursor);
}
}
};
/**
* Merge a set of patches onto the text. Return a patched text.
* @param {Array.} patches Array of patch objects.
* @param {string} text Old text.
* @param {Array.} offsets Offset indices to adjust.
* @return {string} New text.
*/
mobwrite.shareTextareaObj.prototype.patch_apply_ =
function(patches, text, offsets) {
if (patches.length == 0) {
return text;
}
// Deep copy the patches so that no changes are made to originals.
patches = this.dmp.patch_deepCopy(patches);
var nullPadding = this.dmp.patch_addPadding(patches);
text = nullPadding + text + nullPadding;
this.dmp.patch_splitMax(patches);
// delta keeps track of the offset between the expected and actual location
// of the previous patch. If there are patches expected at positions 10 and
// 20, but the first patch was found at 12, delta is 2 and the second patch
// has an effective expected position of 22.
var delta = 0;
for (var x = 0; x < patches.length; x++) {
var expected_loc = patches[x].start2 + delta;
var text1 = this.dmp.diff_text1(patches[x].diffs);
var start_loc;
var end_loc = -1;
if (text1.length > this.dmp.Match_MaxBits) {
// patch_splitMax will only provide an oversized pattern in the case of
// a monster delete.
start_loc = this.dmp.match_main(text,
text1.substring(0, this.dmp.Match_MaxBits), expected_loc);
if (start_loc != -1) {
end_loc = this.dmp.match_main(text,
text1.substring(text1.length - this.dmp.Match_MaxBits),
expected_loc + text1.length - this.dmp.Match_MaxBits);
if (end_loc == -1 || start_loc >= end_loc) {
// Can't find valid trailing context. Drop this patch.
start_loc = -1;
}
}
} else {
start_loc = this.dmp.match_main(text, text1, expected_loc);
}
if (start_loc == -1) {
// No match found. :(
if (mobwrite.debug) {
window.console.warn('Patch failed: ' + patches[x]);
}
// Subtract the delta for this failed patch from subsequent patches.
delta -= patches[x].length2 - patches[x].length1;
} else {
// Found a match. :)
if (mobwrite.debug) {
window.console.info('Patch OK.');
}
delta = start_loc - expected_loc;
var text2;
if (end_loc == -1) {
text2 = text.substring(start_loc, start_loc + text1.length);
} else {
text2 = text.substring(start_loc, end_loc + this.dmp.Match_MaxBits);
}
// Run a diff to get a framework of equivalent indices.
var diffs = this.dmp.diff_main(text1, text2, false);
if (text1.length > this.dmp.Match_MaxBits &&
this.dmp.diff_levenshtein(diffs) / text1.length >
this.dmp.Patch_DeleteThreshold) {
// The end points match, but the content is unacceptably bad.
if (mobwrite.debug) {
window.console.warn('Patch contents mismatch: ' + patches[x]);
}
} else {
var index1 = 0;
var index2;
for (var y = 0; y < patches[x].diffs.length; y++) {
var mod = patches[x].diffs[y];
if (mod[0] !== DIFF_EQUAL) {
index2 = this.dmp.diff_xIndex(diffs, index1);
}
if (mod[0] === DIFF_INSERT) { // Insertion
text = text.substring(0, start_loc + index2) + mod[1] +
text.substring(start_loc + index2);
for (var i = 0; i < offsets.length; i++) {
if (offsets[i] + nullPadding.length > start_loc + index2) {
offsets[i] += mod[1].length;
}
}
} else if (mod[0] === DIFF_DELETE) { // Deletion
var del_start = start_loc + index2;
var del_end = start_loc + this.dmp.diff_xIndex(diffs,
index1 + mod[1].length);
text = text.substring(0, del_start) + text.substring(del_end);
for (var i = 0; i < offsets.length; i++) {
if (offsets[i] + nullPadding.length > del_start) {
if (offsets[i] + nullPadding.length < del_end) {
offsets[i] = del_start - nullPadding.length;
} else {
offsets[i] -= del_end - del_start;
}
}
}
}
if (mod[0] !== DIFF_DELETE) {
index1 += mod[1].length;
}
}
}
}
}
// Strip the padding off.
text = text.substring(nullPadding.length, text.length - nullPadding.length);
return text;
};
/**
* Record information regarding the current cursor.
* @return {Object?} Context information of the cursor.
* @private
*/
mobwrite.shareTextareaObj.prototype.captureCursor_ = function() {
if ('activeElement' in this.element && !this.element.activeElement) {
// Safari specific code.
// Restoring a cursor in an unfocused element causes the focus to jump.
return null;
}
var padLength = this.dmp.Match_MaxBits / 2; // Normally 16.
var text = this.element.value;
var cursor = {};
if ('selectionStart' in this.element) { // W3
try {
var selectionStart = this.element.selectionStart;
var selectionEnd = this.element.selectionEnd;
} catch (e) {
// No cursor; the element may be "display:none".
return null;
}
cursor.startPrefix = text.substring(selectionStart - padLength, selectionStart);
cursor.startSuffix = text.substring(selectionStart, selectionStart + padLength);
cursor.startOffset = selectionStart;
cursor.collapsed = (selectionStart == selectionEnd);
if (!cursor.collapsed) {
cursor.endPrefix = text.substring(selectionEnd - padLength, selectionEnd);
cursor.endSuffix = text.substring(selectionEnd, selectionEnd + padLength);
cursor.endOffset = selectionEnd;
}
} else { // IE
// Walk up the tree looking for this textarea's document node.
var doc = this.element;
while (doc.parentNode) {
doc = doc.parentNode;
}
if (!doc.selection || !doc.selection.createRange) {
// Not IE?
return null;
}
var range = doc.selection.createRange();
if (range.parentElement() != this.element) {
// Cursor not in this textarea.
return null;
}
var newRange = doc.body.createTextRange();
cursor.collapsed = (range.text == '');
newRange.moveToElementText(this.element);
if (!cursor.collapsed) {
newRange.setEndPoint('EndToEnd', range);
cursor.endPrefix = newRange.text;
cursor.endOffset = cursor.endPrefix.length;
cursor.endPrefix = cursor.endPrefix.substring(cursor.endPrefix.length - padLength);
}
newRange.setEndPoint('EndToStart', range);
cursor.startPrefix = newRange.text;
cursor.startOffset = cursor.startPrefix.length;
cursor.startPrefix = cursor.startPrefix.substring(cursor.startPrefix.length - padLength);
newRange.moveToElementText(this.element);
newRange.setEndPoint('StartToStart', range);
cursor.startSuffix = newRange.text.substring(0, padLength);
if (!cursor.collapsed) {
newRange.setEndPoint('StartToEnd', range);
cursor.endSuffix = newRange.text.substring(0, padLength);
}
}
// Record scrollbar locations
if ('scrollTop' in this.element) {
cursor.scrollTop = this.element.scrollTop / this.element.scrollHeight;
cursor.scrollLeft = this.element.scrollLeft / this.element.scrollWidth;
}
// alert(cursor.startPrefix + '|' + cursor.startSuffix + ' ' +
// cursor.startOffset + '\n' + cursor.endPrefix + '|' +
// cursor.endSuffix + ' ' + cursor.endOffset + '\n' +
// cursor.scrollTop + ' x ' + cursor.scrollLeft);
return cursor;
};
/**
* Attempt to restore the cursor's location.
* @param {Object} cursor Context information of the cursor.
* @private
*/
mobwrite.shareTextareaObj.prototype.restoreCursor_ = function(cursor) {
// Set some constants which tweak the matching behaviour.
// Maximum distance to search from expected location.
this.dmp.Match_Distance = 1000;
// At what point is no match declared (0.0 = perfection, 1.0 = very loose)
this.dmp.Match_Threshold = 0.9;
var padLength = this.dmp.Match_MaxBits / 2; // Normally 16.
var newText = this.element.value;
// Find the start of the selection in the new text.
var pattern1 = cursor.startPrefix + cursor.startSuffix;
var pattern2, diff;
var cursorStartPoint = this.dmp.match_main(newText, pattern1,
cursor.startOffset - padLength);
if (cursorStartPoint !== null) {
pattern2 = newText.substring(cursorStartPoint,
cursorStartPoint + pattern1.length);
//alert(pattern1 + '\nvs\n' + pattern2);
// Run a diff to get a framework of equivalent indicies.
diff = this.dmp.diff_main(pattern1, pattern2, false);
cursorStartPoint += this.dmp.diff_xIndex(diff, cursor.startPrefix.length);
}
var cursorEndPoint = null;
if (!cursor.collapsed) {
// Find the end of the selection in the new text.
pattern1 = cursor.endPrefix + cursor.endSuffix;
cursorEndPoint = this.dmp.match_main(newText, pattern1,
cursor.endOffset - padLength);
if (cursorEndPoint !== null) {
pattern2 = newText.substring(cursorEndPoint,
cursorEndPoint + pattern1.length);
//alert(pattern1 + '\nvs\n' + pattern2);
// Run a diff to get a framework of equivalent indicies.
diff = this.dmp.diff_main(pattern1, pattern2, false);
cursorEndPoint += this.dmp.diff_xIndex(diff, cursor.endPrefix.length);
}
}
// Deal with loose ends
if (cursorStartPoint === null && cursorEndPoint !== null) {
// Lost the start point of the selection, but we have the end point.
// Collapse to end point.
cursorStartPoint = cursorEndPoint;
} else if (cursorStartPoint === null && cursorEndPoint === null) {
// Lost both start and end points.
// Jump to the offset of start.
cursorStartPoint = cursor.startOffset;
}
if (cursorEndPoint === null) {
// End not known, collapse to start.
cursorEndPoint = cursorStartPoint;
}
// Restore selection.
if ('selectionStart' in this.element) { // W3
this.element.selectionStart = cursorStartPoint;
this.element.selectionEnd = cursorEndPoint;
} else { // IE
// Walk up the tree looking for this textarea's document node.
var doc = this.element;
while (doc.parentNode) {
doc = doc.parentNode;
}
if (!doc.selection || !doc.selection.createRange) {
// Not IE?
return;
}
// IE's TextRange.move functions treat '\r\n' as one character.
var snippet = this.element.value.substring(0, cursorStartPoint);
var ieStartPoint = snippet.replace(/\r\n/g, '\n').length;
var newRange = doc.body.createTextRange();
newRange.moveToElementText(this.element);
newRange.collapse(true);
newRange.moveStart('character', ieStartPoint);
if (!cursor.collapsed) {
snippet = this.element.value.substring(cursorStartPoint, cursorEndPoint);
var ieMidLength = snippet.replace(/\r\n/g, '\n').length;
newRange.moveEnd('character', ieMidLength);
}
newRange.select();
}
// Restore scrollbar locations
if ('scrollTop' in cursor) {
this.element.scrollTop = cursor.scrollTop * this.element.scrollHeight;
this.element.scrollLeft = cursor.scrollLeft * this.element.scrollWidth;
}
};
/**
* Ensure that all linebreaks are LF
* @param {string} text Text with unknown line breaks
* @return {string} Text with normalized linebreaks
* @private
*/
mobwrite.shareTextareaObj.normalizeLinebreaks_ = function(text) {
return text.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
};
/**
* Handler to accept text fields as elements that can be shared.
* If the element is a textarea, text or password input, create a new
* sharing object.
* @param {*} node Object or ID of object to share.
* @return {Object?} A sharing object or null.
*/
mobwrite.shareTextareaObj.shareHandler = function(node) {
if (typeof node == 'string') {
node = document.getElementById(node);
}
if (node && 'value' in node && 'type' in node && (node.type == 'textarea' ||
node.type == 'text' || node.type == 'password')) {
if (mobwrite.UA_webkit) {
// Safari needs to track which text element has the focus.
node.addEventListener('focus', function() {this.activeElement = true;},
false);
node.addEventListener('blur', function() {this.activeElement = false;},
false);
node.activeElement = false;
}
return new mobwrite.shareTextareaObj(node);
}
return null;
};
// Register this shareHandler with MobWrite.
mobwrite.shareHandlers.push(mobwrite.shareTextareaObj.shareHandler);
================================================
FILE: static/code/mobwrite/demo/test.html
================================================
Manual test of MobWrite's client-server Protocol
Manual test of MobWrite's client-server Protocol
================================================
FILE: static/code/mobwrite/mobwrite_cc.js
================================================
/**
* @license
* Copyright 2018 Google LLC
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @fileoverview Realtime collaboration for Code City.
* @author fraser@google.com (Neil Fraser)
*/
'use strict';
/**
* Constructor of sharing object representing the code editor.
* @constructor
*/
Code.MobwriteShare = function() {
// Call our prototype's constructor.
mobwrite.shareObj.call(this, Code.MobwriteShare.id);
};
/**
* Handler to accept the code editor as an element that can be shared.
* @param {string} type Type of object to share
* ('Code' is currently the only option).
* @return {Object?} A sharing object or null.
*/
Code.MobwriteShare.shareHandler = function(type) {
if (type === 'Code') {
return new Code.MobwriteShare();
}
return null;
};
/**
* Initialization that happens once DMP, MobWrite, and this file are all loaded.
* Called by Code.Editor.waitMobWrite_
*/
Code.MobwriteShare.init = function() {
// Fetch the sharing ID from the parent frame's URL, or invent a new one.
var hash = parent && parent.location && parent.location.hash;
if (hash) {
hash = hash.substring(1);
}
Code.MobwriteShare.id = hash || mobwrite.uniqueId();
// The sharing object's parent is a shareObj.
Code.MobwriteShare.prototype = new mobwrite.shareObj();
/**
* Retrieve the user's content.
* @return {string} Plaintext content.
*/
Code.MobwriteShare.prototype.getClientText = function() {
var value = '';
if (Code.Editor.currentEditor) {
value = Code.Editor.currentEditor.getSource() || '';
}
// Numeric data should use overwrite mode.
this.mergeChanges = !value.match(/^\s*-?[\d.]+\s*$/);
return value;
};
/**
* Set the user's content.
* @param {string} text New content.
*/
Code.MobwriteShare.prototype.setClientText = function(text) {
Code.Editor.setSourceToAllEditors(text, false);
};
// Register this shareHandler with MobWrite.
mobwrite.shareHandlers.push(Code.MobwriteShare.shareHandler);
// Default max is 10 seconds. Decrease to 5.
mobwrite.maxSyncInterval = 5000;
};
================================================
FILE: static/code/mobwrite/mobwrite_core.js
================================================
/**
* @license
* Copyright 2006 Google LLC
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @fileoverview This client-side code drives the synchronisation.
* @author fraser@google.com (Neil Fraser)
*/
/**
* Namespace containing all MobWrite code.
*/
var mobwrite = {};
/**
* URL of Ajax gateway.
* @type {string}
*/
mobwrite.syncGateway = '/scripts/q.py';
/**
* Print diagnostic messages to the browser's console.
* @type {boolean}
*/
mobwrite.debug = true;
/**
* PID of task which will trigger next Ajax request.
* @type {number?}
* @private
*/
mobwrite.syncRunPid_ = null;
/**
* PID of task which will kill stalled Ajax request.
* @type {number?}
* @private
*/
mobwrite.syncKillPid_ = null;
/**
* Time to wait for a connection before giving up and retrying.
* @type {number}
*/
mobwrite.timeoutInterval = 30000;
/**
* Shortest interval (in milliseconds) between connections.
* @type {number}
*/
mobwrite.minSyncInterval = 1000;
/**
* Longest interval (in milliseconds) between connections.
* @type {number}
*/
mobwrite.maxSyncInterval = 4000;
/**
* Initial interval (in milliseconds) for connections.
* This value is modified later as traffic rates are established.
* @type {number}
*/
mobwrite.syncInterval = 2000;
/**
* Optional prefix to automatically add to all IDs.
* @type {string}
*/
mobwrite.idPrefix = '';
/**
* Flag to nullify all shared elements and terminate.
* @type {boolean}
*/
mobwrite.nullifyAll = false;
/**
* Track whether something changed client-side in each sync.
* @type {boolean}
* @private
*/
mobwrite.clientChange_ = false;
/**
* Track whether something changed server-side in each sync.
* @type {boolean}
* @private
*/
mobwrite.serverChange_ = false;
/**
* Temporary object used while each sync is airborne.
* @type {Object?}
* @private
*/
mobwrite.syncAjaxObj_ = null;
/**
* Return a random ID that's 6 characters long.
* 79^6 = 243,087,455,521
* @return {string} Random ID.
*/
mobwrite.uniqueId = function() {
// All the legal characters for a URL 'fragment' (hash) as per RFC 3986.
var soup = 'ABCDEFGHIJKLMNOPQUSTPVWXYZabcdefghijklmnopqrstuvwxyz' +
'0123456789-._~!$&\'()*+,;=?/';
var id = '';
for (var i = 0; i < 6; i++) {
id += soup.charAt(Math.random() * soup.length);
}
return id;
};
/**
* Unique ID for this session.
* @type {string}
*/
mobwrite.syncUsername = mobwrite.uniqueId();
/**
* Hash of all shared objects.
* @type {Object}
*/
mobwrite.shared = Object.create(null);
/**
* Array of registered handlers for sharing types.
* Modules add their share functions to this list.
* @type {Array.}
*/
mobwrite.shareHandlers = [];
/**
* Prototype of shared object.
* @param {string=} id Unique file ID.
* @constructor
*/
mobwrite.shareObj = function(id) {
if (!id) return; // Creating subclass prototype object.
this.file = id;
this.dmp = new diff_match_patch();
this.dmp.Diff_Timeout = 0.5;
// List of unacknowledged edits sent to the server.
this.editStack = [];
if (mobwrite.debug) {
console.info('Creating shareObj: "' + id + '"');
}
};
/**
* Client's understanding of what the server's text looks like.
* @type {string}
*/
mobwrite.shareObj.prototype.shadowText = '';
/**
* The client's version for the shadow (n).
* @type {number}
*/
mobwrite.shareObj.prototype.clientVersion = 0;
/**
* The server's version for the shadow (m).
* @type {number}
*/
mobwrite.shareObj.prototype.serverVersion = 0;
/**
* Did the client understand the server's delta in the previous heartbeat?
* Initialize false because the server and client are out of sync initially.
* @type {boolean}
*/
mobwrite.shareObj.prototype.deltaOk = false;
/**
* Synchronization mode.
* True: Used for text, attempts to gently merge differences together.
* False: Used for numbers, overwrites conflicts, last save wins.
* @type {boolean}
*/
mobwrite.shareObj.prototype.mergeChanges = true;
/**
* Fetch or compute a plaintext representation of the user's text.
* @return {string} Plaintext content.
*/
mobwrite.shareObj.prototype.getClientText = function() {
throw new Error('Defined by subclass');
};
/**
* Set the user's text based on the provided plaintext.
* @param {string} text New text.
*/
mobwrite.shareObj.prototype.setClientText = function(text) {
throw new Error('Defined by subclass');
};
/**
* Modify the user's plaintext by applying a series of patches against it.
* @param {Array.} patches Array of Patch objects.
*/
mobwrite.shareObj.prototype.patchClientText = function(patches) {
var oldClientText = this.getClientText();
var result = this.dmp.patch_apply(patches, oldClientText);
// Set the new text only if there is a change to be made.
if (oldClientText != result[0]) {
// The following will probably destroy any cursor or selection.
// Widgets with cursors should override and patch more delicately.
this.setClientText(result[0]);
}
};
/**
* Notification of when a diff was sent to the server.
* @param {Array.>} diffs Array of diff tuples.
*/
mobwrite.shareObj.prototype.onSentDiff = function(diffs) {
// Potential hook for subclass.
};
/**
* Fire a synthetic 'change' event to a target element.
* Notifies an element that its contents have been changed.
* @param {Object} target Element to notify.
*/
mobwrite.shareObj.prototype.fireChange = function(target) {
if ('createEvent' in document) { // W3
var e = document.createEvent('HTMLEvents');
e.initEvent('change', false, false);
target.dispatchEvent(e);
} else if ('fireEvent' in target) { // IE
target.fireEvent('onchange');
}
};
/**
* Return the command to nullify this field. Also unshares this field.
* @return {string} Command to be sent to the server.
*/
mobwrite.shareObj.prototype.nullify = function() {
mobwrite.unshare(this.file);
return 'N:' + mobwrite.idPrefix + this.file + '\n';
};
/**
* Asks the shareObj to synchronize. Computes client-made changes since
* previous postback. Return '' to skip this synchronization.
* @return {string} Commands to be sent to the server.
*/
mobwrite.shareObj.prototype.syncText = function() {
var clientText = this.getClientText();
if (this.deltaOk) {
// The last delta postback from the server to this shareObj was successful.
// Send a compressed delta.
var diffs = this.dmp.diff_main(this.shadowText, clientText, true);
if (diffs.length > 2) {
this.dmp.diff_cleanupSemantic(diffs);
this.dmp.diff_cleanupEfficiency(diffs);
}
var changed = diffs.length != 1 || diffs[0][0] != DIFF_EQUAL;
if (changed) {
mobwrite.clientChange_ = true;
this.shadowText = clientText;
}
// Don't bother appending a no-change diff onto the stack if the stack
// already contains something.
if (changed || !this.editStack.length) {
var action = (this.mergeChanges ? 'd:' : 'D:') + this.clientVersion +
':' + this.dmp.diff_toDelta(diffs);
this.editStack.push([this.clientVersion, action]);
this.clientVersion++;
this.onSentDiff(diffs);
}
} else {
// The last delta postback from the server to this shareObj didn't match.
// Send a full text dump to get back in sync. This will result in any
// changes since the last postback being wiped out. :(
this.shadowText = clientText;
this.clientVersion++;
var action = 'r:' + this.clientVersion + ':' +
encodeURI(clientText).replace(/%20/g, ' ');
// Append the action to the edit stack.
this.editStack.push([this.clientVersion, action]);
// Sending a raw dump will put us back in sync.
// Set deltaOk to true in case this sync fails to connect, in which case
// the following sync(s) should be a delta, not more raw dumps.
this.deltaOk = true;
}
// Create the output starting with the file statement, followed by the edits.
var data = 'F:' + this.serverVersion + ':' +
mobwrite.idPrefix + this.file + '\n';
for (var i = 0; i < this.editStack.length; i++) {
data += this.editStack[i][1] + '\n';
}
return data;
};
/**
* Collect all client-side changes and send them to the server.
* @private
*/
mobwrite.syncRun1_ = function() {
// Initialize clientChange_, to be checked at the end of syncRun2_.
mobwrite.clientChange_ = false;
var data = [];
data[0] = 'u:' + mobwrite.syncUsername + '\n';
var empty = true;
// Ask every shared object for their deltas.
for (var x in mobwrite.shared) {
if (mobwrite.shared[x]) {
if (mobwrite.nullifyAll) {
data.push(mobwrite.shared[x].nullify());
} else {
data.push(mobwrite.shared[x].syncText());
}
empty = false;
}
}
if (empty) {
// No sync objects.
if (mobwrite.debug) {
console.info('MobWrite task stopped.');
}
return;
}
if (data.length == 1) {
// No sync data.
if (mobwrite.debug) {
console.info('All objects silent; null sync.');
}
mobwrite.syncRun2_('\n\n');
return;
}
if (mobwrite.debug) {
console.info('TO server:\n' + data.join(''));
}
// Add terminating blank line.
data.push('\n');
data = data.join('');
// Schedule a watchdog task to catch us if something horrible happens.
mobwrite.syncKillPid_ =
setTimeout(mobwrite.syncKill_, mobwrite.timeoutInterval);
// Issue Ajax post of client-side changes and request server-side changes.
data = 'q=' + encodeURIComponent(data);
mobwrite.syncAjaxObj_ = mobwrite.syncLoadAjax_(mobwrite.syncGateway, data,
mobwrite.syncCheckAjax_);
// Execution will resume in either syncCheckAjax_(), or syncKill_()
};
/**
* Parse all server-side changes and distribute them to the shared objects.
* @param {string} text Raw content from server.
* @private
*/
mobwrite.syncRun2_ = function(text) {
// Initialize serverChange_, to be checked at the end of syncRun2_.
mobwrite.serverChange_ = false;
if (mobwrite.debug) {
console.info('FROM server:\n' + text);
}
// There must be a newline followed by a blank line.
if (text.length < 2 || text.substring(text.length - 2) != '\n\n') {
text = '';
if (mobwrite.debug) {
console.info('Truncated data. Abort.');
}
}
var lines = text.split('\n');
var file = null;
var clientVersion = null;
for (var i = 0; i < lines.length; i++) {
var line = lines[i];
if (!line) {
// Terminate on blank line.
break;
}
// Divide each line into 'N:value' pairs.
if (line.charAt(1) != ':') {
if (mobwrite.debug) {
console.error('Unparsable line: ' + line);
}
continue;
}
var name = line.charAt(0);
var value = line.substring(2);
// Parse out a version number for file, delta or raw.
var version;
if ('FfDdRr'.indexOf(name) != -1) {
var div = value.indexOf(':');
if (div < 1) {
if (mobwrite.debug) {
console.error('No version number: ' + line);
}
continue;
}
version = parseInt(value.substring(0, div), 10);
if (isNaN(version)) {
if (mobwrite.debug) {
console.error('NaN version number: ' + line);
}
continue;
}
value = value.substring(div + 1);
}
if (name == 'F' || name == 'f') {
// File indicates which shared object following delta/raw applies to.
if (value.substring(0, mobwrite.idPrefix.length) == mobwrite.idPrefix) {
// Trim off the ID prefix.
value = value.substring(mobwrite.idPrefix.length);
} else {
// This file does not have our ID prefix.
file = null;
if (mobwrite.debug) {
console.error('File does not have "' + mobwrite.idPrefix +
'" prefix: ' + value);
}
continue;
}
if (mobwrite.shared[value]) {
file = mobwrite.shared[value];
file.deltaOk = true;
clientVersion = version;
// Remove any elements from the edit stack with low version numbers
// which have been acked by the server.
for (var j = 0; j < file.editStack.length; j++) {
if (file.editStack[j][0] <= clientVersion) {
file.editStack.splice(j, 1);
j--;
}
}
} else {
// This file does not map to a currently shared object.
file = null;
if (mobwrite.debug) {
console.error('Unknown file: ' + value);
}
}
} else if (name == 'R' || name == 'r') {
// The server reports it was unable to integrate the previous delta.
if (file) {
file.shadowText = decodeURI(value);
file.clientVersion = clientVersion;
file.serverVersion = version;
file.editStack = [];
if (name == 'R') {
// Accept the server's raw text dump and wipe out any user's changes.
file.setClientText(file.shadowText);
}
// Server-side activity.
mobwrite.serverChange_ = true;
}
} else if (name == 'D' || name == 'd') {
// The server offers a compressed delta of changes to be applied.
if (file) {
if (clientVersion != file.clientVersion) {
// Can't apply a delta on a mismatched shadow version.
file.deltaOk = false;
if (mobwrite.debug) {
console.error('Client version number mismatch.\n' +
'Expected: ' + file.clientVersion + ' Got: ' + clientVersion);
}
} else if (version > file.serverVersion) {
// Server has a version in the future?
file.deltaOk = false;
if (mobwrite.debug) {
console.error('Server version in future.\n' +
'Expected: ' + file.serverVersion + ' Got: ' + version);
}
} else if (version < file.serverVersion) {
// We've already seen this diff.
if (mobwrite.debug) {
console.warn('Server version in past.\n' +
'Expected: ' + file.serverVersion + ' Got: ' + version);
}
} else {
// Expand the delta into a diff using the client shadow.
var diffs;
try {
diffs = file.dmp.diff_fromDelta(file.shadowText, value);
file.serverVersion++;
} catch (ex) {
// The delta the server supplied does not fit on our copy of
// shadowText.
diffs = null;
// Set deltaOk to false so that on the next sync we send
// a complete dump to get back in sync.
file.deltaOk = false;
// Do the next sync soon because the user will lose any changes.
mobwrite.syncInterval = 0;
if (mobwrite.debug) {
console.error('Delta mismatch.\n' + encodeURI(file.shadowText));
}
}
if (diffs && (diffs.length != 1 || diffs[0][0] != DIFF_EQUAL)) {
// Compute and apply the patches.
if (name == 'D') {
// Overwrite text.
file.shadowText = file.dmp.diff_text2(diffs);
file.setClientText(file.shadowText);
} else {
// Merge text.
var patches = file.dmp.patch_make(file.shadowText, diffs);
// First shadowText. Should be guaranteed to work.
var serverResult = file.dmp.patch_apply(patches, file.shadowText);
file.shadowText = serverResult[0];
// Second the user's text.
file.patchClientText(patches);
}
// Server-side activity.
mobwrite.serverChange_ = true;
}
}
}
}
}
mobwrite.computeSyncInterval_();
// Ensure that there is only one sync task.
clearTimeout(mobwrite.syncRunPid_);
// Schedule the next sync.
mobwrite.syncRunPid_ =
setTimeout(mobwrite.syncRun1_, mobwrite.syncInterval);
// Terminate the watchdog task, everything's ok.
clearTimeout(mobwrite.syncKillPid_);
mobwrite.syncKillPid_ = null;
};
/**
* Compute how long to wait until next synchronization.
* @private
*/
mobwrite.computeSyncInterval_ = function() {
var range = mobwrite.maxSyncInterval - mobwrite.minSyncInterval;
if (mobwrite.clientChange_) {
// Client-side activity.
// Cut the sync interval by 40% of the min-max range.
mobwrite.syncInterval -= range * 0.4;
}
if (mobwrite.serverChange_) {
// Server-side activity.
// Cut the sync interval by 20% of the min-max range.
mobwrite.syncInterval -= range * 0.2;
}
if (!mobwrite.clientChange_ && !mobwrite.serverChange_) {
// No activity.
// Let the sync interval creep up by 10% of the min-max range.
mobwrite.syncInterval += range * 0.1;
}
// Keep the sync interval constrained between min and max.
mobwrite.syncInterval =
Math.max(mobwrite.minSyncInterval, mobwrite.syncInterval);
mobwrite.syncInterval =
Math.min(mobwrite.maxSyncInterval, mobwrite.syncInterval);
};
/**
* If the Ajax call doesn't complete after a timeout period, start over.
* @private
*/
mobwrite.syncKill_ = function() {
mobwrite.syncKillPid_ = null;
if (mobwrite.syncAjaxObj_) {
// Cleanup old Ajax connection.
mobwrite.syncAjaxObj_.abort();
mobwrite.syncAjaxObj_ = null;
}
if (mobwrite.debug) {
console.warn('Connection timeout.');
}
clearTimeout(mobwrite.syncRunPid_);
// Initiate a new sync right now.
mobwrite.syncRunPid_ = setTimeout(mobwrite.syncRun1_, 1);
};
/**
* Initiate an Ajax network connection.
* @param {string} url Location to send request.
* @param {string} post Data to be sent.
* @param {Function} callback Function to be called when response arrives.
* @return {!Object} New Ajax object.
* @private
*/
mobwrite.syncLoadAjax_ = function(url, post, callback) {
var req = new XMLHttpRequest();
req.onload = callback;
req.open('POST', url, true);
req.withCredentials = true;
req.setRequestHeader('Content-Type','application/x-www-form-urlencoded');
req.send(post);
return req;
};
/**
* Callback function for Ajax request. Checks network response was ok,
* then calls mobwrite.syncRun2_.
* @private
*/
mobwrite.syncCheckAjax_ = function() {
if (typeof mobwrite == 'undefined' || !mobwrite.syncAjaxObj_) {
// This might be a callback after the page has unloaded,
// or this might be a callback which we deemed to have timed out.
return;
}
// Only if "OK"
if (mobwrite.syncAjaxObj_.status === 200) {
var text = mobwrite.syncAjaxObj_.responseText;
mobwrite.syncAjaxObj_ = null;
mobwrite.syncRun2_(text);
} else if (mobwrite.syncAjaxObj_.status === 410) {
// Required cookie not found. Stop sharing.
console.warn('410: Required cookie not found');
for (var file in mobwrite.shared) {
delete mobwrite.shared[file];
}
} else {
if (mobwrite.debug) {
console.warn('Connection error code: ' + mobwrite.syncAjaxObj_.status);
}
mobwrite.syncAjaxObj_ = null;
}
};
/**
* When unloading, run a sync one last time.
* @private
*/
mobwrite.unload_ = function() {
if (!mobwrite.syncKillPid_) {
// Turn off debug mode since the console disappears on page unload before
// this code does.
mobwrite.debug = false;
mobwrite.syncRun1_();
}
// By the time the callback runs mobwrite.syncRun2_, this page will probably
// be gone. But that's ok, we are just sending our last changes out, we
// don't care what the server says.
};
// Attach unload event to
addEventListener('unload', mobwrite.unload_, false);
/**
* Start sharing the specified object(s).
* @param {*} var_args Object(s) or ID(s) of object(s) to share.
*/
mobwrite.share = function(var_args) {
for (var i = 0; i < arguments.length; i++) {
var el = arguments[i];
var result = null;
// Ask every registered handler if it knows what to do with this object.
for (var j = 0; j < mobwrite.shareHandlers.length && !result; j++) {
result = mobwrite.shareHandlers[j].call(mobwrite, el);
}
if (result && result.file) {
if (!result.file.match(/^[-.~!$&\'()*+,;=?\/\w]*$/)) {
if (mobwrite.debug) {
console.error('Illegal id "' + result.file + '".');
}
continue;
}
if (result.file in mobwrite.shared) {
// Already exists.
// Don't replace, since we don't want to lose state.
if (mobwrite.debug) {
console.warn('Ignoring duplicate share on "' + el + '".');
}
continue;
}
mobwrite.shared[result.file] = result;
if (mobwrite.syncRunPid_ === null) {
// Startup the main task if it doesn't already exist.
if (mobwrite.debug) {
console.info('MobWrite task started.');
}
} else {
// Bring sync forward in time.
clearTimeout(mobwrite.syncRunPid_);
}
mobwrite.syncRunPid_ = setTimeout(mobwrite.syncRun1_, 10);
} else {
if (mobwrite.debug) {
console.warn('Share: Unknown widget type: ' + el + '.');
}
}
}
};
/**
* Stop sharing the specified object(s).
* Does not handle forms recursively.
* @param {*} var_args Object(s) or ID(s) of object(s) to unshare.
*/
mobwrite.unshare = function(var_args) {
for (var i = 0; i < arguments.length; i++) {
var el = arguments[i];
if (typeof el == 'string' && mobwrite.shared[el]) {
delete mobwrite.shared[el];
if (mobwrite.debug) {
console.info('Unshared: ' + el);
}
} else {
// Pretend to want to share this object, acquire a new shareObj, then use
// its ID to locate and kill the existing shareObj that's already shared.
var result = null;
// Ask every registered handler if it knows what to do with this object.
for (var j = 0; j < mobwrite.shareHandlers.length && !result; j++) {
result = mobwrite.shareHandlers[j].call(mobwrite, el);
}
if (result && result.file) {
if (mobwrite.shared[result.file]) {
delete mobwrite.shared[result.file];
if (mobwrite.debug) {
console.info('Unshared: ' + el);
}
} else {
if (mobwrite.debug) {
console.warn('Ignoring ' + el + '. Not currently shared.');
}
}
} else {
if (mobwrite.debug) {
console.warn('Unshare: Unknown widget type: ' + el + '.');
}
}
}
}
};
================================================
FILE: static/code/objectPanel.js
================================================
/**
* @license
* Copyright 2018 Google LLC
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @fileoverview Integrated Development Environment for Code City.
* @author fraser@google.com (Neil Fraser)
*/
'use strict';
Code.ObjectPanel = {};
/**
* List of parts (passed in by the URL hash).
* @type {?Array}
*/
Code.ObjectPanel.parts = null;
/**
* DOM node containing the list of properties.
* @type {?Element}
*/
Code.ObjectPanel.tableBody = null;
/**
* Structured data from Code City.
* @type {?Object}
*/
Code.ObjectPanel.data = null;
/**
* Page has loaded, initialize the panel. Called by Code City with data.
*/
Code.ObjectPanel.init = function() {
Code.ObjectPanel.tableBody = document.getElementById('objectTableBody');
// Clear the '...'
Code.ObjectPanel.tableBody.innerHTML = '';
var data = Code.ObjectPanel.data;
if (!data) {
// Server error. Should not happen.
var title = document.getElementById('objectTitle');
title.className = 'objectFailTitle';
var fail = document.getElementById('objectFail');
fail.style.display = 'table-row';
return;
}
if (data.roots) {
// Print all root objects.
for (var root of data.roots) {
var part = {type: 'id', value: root.name};
Code.ObjectPanel.addLink(part, root.type, false);
}
}
if (data.properties) {
Code.ObjectPanel.filterShadowed(data.properties);
// Print all properties of this object.
for (var i = 0; i < data.properties.length; i++) {
var propList = data.properties[i];
propList.sort(Code.ObjectPanel.caseInsensitiveComp_);
for (var j = 0; j < propList.length; j++) {
var part = {type: 'id', value: propList[j].name};
Code.ObjectPanel.addLink(part, propList[j].type, i && !j);
}
}
}
if (data.keywords) {
var first = true;
for (var keyword of data.keywords) {
var part = {type: 'keyword', value: keyword};
Code.ObjectPanel.addLink(part, 'object', first);
first = false;
}
}
// Position the type symbols, and monitor for layout changes.
Code.ObjectPanel.positionTypes();
window.addEventListener('scroll', Code.ObjectPanel.positionTypes, false);
window.addEventListener('resize', Code.ObjectPanel.positionTypes, false);
// Highlight current item, and monitor for path changes.
Code.ObjectPanel.highlight();
window.addEventListener('message', Code.ObjectPanel.highlight, false);
};
/**
* Create the DOM elements to add one property link to the list.
* @param {!Object} part Single selector part.
* @param {string} type Type of the property value.
* @param {boolean} section Flag indicating a new section.
*/
Code.ObjectPanel.addLink = function(part, type, section) {
var newParts = Code.ObjectPanel.parts.concat(part);
var selector = Code.Common.partsToSelector(newParts);
var a = document.createElement('a');
var query = encodeURIComponent(selector).replace(/%24/g, '$');
a.href = './?' + query;
a.target = '_blank';
a.setAttribute('data-link', JSON.stringify(part));
a.addEventListener('click', Code.ObjectPanel.click);
var text = document.createTextNode(Code.Common.partsToSelector([part]));
a.appendChild(text);
var td = document.createElement('td');
if (section) {
td.className = 'section';
}
var typeSymbol = Code.ObjectPanel.TYPES[type];
if (typeSymbol) {
var div = document.createElement('div');
div.className = 'objectType';
div.appendChild(document.createTextNode(typeSymbol));
div.title = type;
td.appendChild(div);
}
td.appendChild(a);
var tr = document.createElement('tr');
tr.appendChild(td);
Code.ObjectPanel.tableBody.appendChild(tr);
};
/**
* Symbols to print next to properties.
*/
Code.ObjectPanel.TYPES = {
'array': '[]',
'boolean': '⏼',
'function': '𝑓',
'null': '␀',
'number': '#',
'object': '{}',
'string': '”',
'symbol': '☆',
'verb': '𝑣𝑓'
};
/**
* When scrollbar is moved or size changes reposition the floating types.
*/
Code.ObjectPanel.positionTypes = function() {
var left = (document.body.clientWidth + window.scrollX - 18) + 'px';
var types = document.getElementsByClassName('objectType');
for (var t of types) {
t.style.left = left;
}
};
/**
* When a property is clicked, trigger an update.
* @param {!Event} e Click event.
*/
Code.ObjectPanel.click = function(e) {
if (e.metaKey || e.ctrlKey) {
return;
}
var part = JSON.parse(e.currentTarget.getAttribute('data-link'));
var newParts = Code.ObjectPanel.parts.concat(part);
var selector = Code.Common.partsToSelector(newParts);
// Store the new selector in sessionStorage for all frames to see.
sessionStorage.setItem(Code.Common.SELECTOR, selector);
// Alert the top "/code" frameset that there's been a selector change.
window.parent.parent.postMessage('ping', '*');
// Don't navigate to this link.
e.preventDefault();
};
/**
* Currently selected property, or null if none.
* @type {?Element}
*/
Code.ObjectPanel.highlighted = null;
/**
* Highlight the currently selected property (if any).
* The current selection is based on a value in sessionStorage.
*/
Code.ObjectPanel.highlight = function() {
var selector = sessionStorage.getItem(Code.Common.SELECTOR);
var parts = Code.Common.selectorToParts(selector);
var part = parts ? parts[Code.ObjectPanel.parts.length] : null;
var jsonPart = JSON.stringify(part);
var newHighlighted = null;
for (var tr of Code.ObjectPanel.tableBody.childNodes) {
var td = tr.firstChild;
var link = td.lastChild; // There might be an objectType div first.
if (link.getAttribute('data-link') === jsonPart) {
newHighlighted = td;
}
}
if (newHighlighted !== Code.ObjectPanel.highlighted) {
if (Code.ObjectPanel.highlighted) {
Code.ObjectPanel.highlighted.classList.remove('highlighted');
}
if (newHighlighted) {
newHighlighted.classList.add('highlighted');
if (newHighlighted.scrollIntoView) {
newHighlighted.scrollIntoView({block: 'nearest', inline: 'nearest'});
}
}
Code.ObjectPanel.highlighted = newHighlighted;
}
};
/**
* Remove any properties that are shadowed by objects higher on the inheritance
* chain.
* @param {Array>} data Property names from Code City.
*/
Code.ObjectPanel.filterShadowed = function(data) {
if (!data || data.length < 2) return;
var seen = Object.create(null);
for (var datum of data) {
var cursorInsert = 0;
var cursorRead = 0;
while (cursorRead < datum.length) {
var prop = datum[cursorRead++];
if (!seen[prop.name]) {
seen[prop.name] = true;
datum[cursorInsert++] = prop;
}
}
datum.length = cursorInsert;
}
};
/**
* Comparison function to sort named objects A-Z without regard to case.
* @param {!Object} a One named object.
* @param {!Object} b Another named object.
* @return {number} -1/0/1 comparator value.
* @private
*/
Code.ObjectPanel.caseInsensitiveComp_ = function(a, b) {
return Code.Common.caseInsensitiveComp(a.name, b.name);
};
if (!window.TEST) {
(function() {
// Fill in the object name.
var query = decodeURIComponent(location.search.substring(1));
Code.ObjectPanel.parts = Code.Common.selectorToParts(query);
var div = document.getElementById('objectTitle');
var lastPart = Code.ObjectPanel.parts[Code.ObjectPanel.parts.length - 1];
var name;
if (!lastPart) {
name = 'Globals';
} else if (Code.ObjectPanel.parts.length === 1) {
// Render as 'foo' or '[42]' or '["???"]' or '{xyz}'.
name = Code.Common.partsToSelector([lastPart]);
} else {
// Render as '.foo' or '[42]' or '["???"]' or '{xyz}'.
var mockParts = [{type: 'id', value: 'X'}, lastPart];
name = Code.Common.partsToSelector(mockParts).substring(1);
}
div.innerHTML = '';
div.appendChild(document.createTextNode(name));
})();
window.addEventListener('load', Code.ObjectPanel.init);
}
================================================
FILE: static/code/style.css
================================================
body {
background: #fff;
color: #444;
font-family: "Roboto Mono", monospace;
font-size: 11pt;
}
input,
textarea {
font-family: "Roboto Mono", monospace;
font-size: 11pt;
}
#input {
box-sizing: border-box;
margin-left: -2px;
width: 100%;
}
#input.invalid {
color: red;
}
#autocompleteMenu {
background: #fff;
border-color: #ccc #666 #666 #ccc;
border-style: solid;
border-width: 1px;
display: none;
max-width: 20em;
overflow-y: auto;
padding: 4px 0;
position: absolute;
z-index: 1;
}
#autocompleteMenuScroll {
}
#autocompleteMenuScroll>div {
cursor: default;
overflow-x: hidden;
padding: 0 1em;
text-overflow: ellipsis;
white-space: nowrap;
}
#autocompleteMenuScroll>div.selected {
background-color: #def;
}
#panels {
bottom: 5px;
left: 0;
overflow-x: auto;
overflow-y: hidden;
position: absolute;
right: 0;
top: 42px;
width: 100%;
}
#panelsScroll {
height: 100%;
padding-left: 5px;
white-space: nowrap;
}
#panelsScroll>iframe {
border: 2px solid #444;
border-radius: 2px;
box-sizing: border-box;
height: 100%;
margin: 0 5px 0 0;
padding: 0;
width: 300px;
}
#panelsScroll>iframe:last-of-type {
width: 500px;
}
#objectPanel {
margin: 0;
}
#objectFail {
display: none;
}
#objectFail>tr>td {
padding: 8px;
}
.objectFailTitle {
background-color: #d00;
color: #fff;
}
#objectPanel {
margin: 0;
}
#objectTitle {
border-bottom: 2px solid #444;
padding: 8px;
}
#objectTable {
border-collapse: collapse;
width: 100%;
}
#objectTableBody>tr>td {
padding: 0 2ex 0 8px;
}
#objectTableBody>tr>td>a {
color: #444;
display: block;
text-decoration: none;
}
#objectTableBody>tr>td:hover {
background-color: #d6e9f8;
}
#objectTableBody>tr>td.highlighted {
background-color: #ccc;
}
#objectTableBody>tr>td.section {
border-top: 1px solid #444;
}
.objectType {
color: #888;
font-family: monospace;
font-size: medium;
padding-top: 2px;
position: absolute;
text-align: center;
width: 3ex;
}
.loading:after {
animation: ellipsis steps(5, end) 1000ms infinite;
content: "...";
display: inline-block;
overflow: hidden;
vertical-align: bottom;
width: 0;
}
@keyframes ellipsis {
to {
width: 3.2em;
}
}
#editorButtons {
float: right;
margin-right: 3px;
}
#editorHeader {
margin-top: 5px;
overflow: hidden;
white-space: nowrap;
text-overflow: ellipsis;
}
#editorTabs {
font-family: "Arial", "Helvetica", sans-serif;
font-size: 11px;
margin-top: -2px;
}
#editorTabs>.spacer {
border-bottom: 1px solid rgba(0,0,0,.1);
padding: 4px 5px;
}
#editorTabs>.jfk-button {
border-bottom-color: #f1f1f1;
border-bottom-left-radius: 0;
border-bottom-right-radius: 0;
height: auto;
line-height: normal;
margin-right: 0;
padding-bottom: 4px;
padding-top: 4px;
}
#editorTabs.disabled>.jfk-button {
color: #ccc;
}
#editorTabs>.highlighted {
background-color: #ccc;
background-image: none;
}
#editorContainers>div {
display: none;
}
#editorDialog,
#editorDialogBox,
#editorConfirmBox,
#editorShareBox {
display: none;
}
#editorDialogMask,
#editorSavingMask {
background-color: #000;
bottom: 0;
left: 0;
opacity: 0;
position: absolute;
right: 0;
top: 0;
transition-property: opacity;
z-index: 998;
}
#editorSavingMask {
cursor: wait;
display: none;
transition-duration: 1s;
}
#editorDialogBox {
background-color: #fff;
border: 2px solid #444;
border-radius: 2px;
border-top: none;
left: 0;
margin: 0 auto;
padding: 1em;
position: absolute;
right: 0;
text-align: center;
top: -120px;
transition-property: top;
width: 20em;
z-index: 999;
}
#editorConfirmDiscard {
float: left;
margin-left: 25px;
}
#editorConfirmCancel {
float: right;
}
#editorConfirmSave,
#editorShareOk {
float: right;
margin-right: 25px;
}
#editorShareBox.disabled {
color: #ccc;
}
#editorShareAddress {
width: 18em;
}
.CodeMirror {
border: 1px solid #ddd;
}
================================================
FILE: static/code/svg.css
================================================
body {
margin: 0;
padding: 0;
overflow: hidden;
}
#editorContainer {
position: absolute;
}
#toolbox {
padding-left: 2px;
}
#svgroot {
border: 1px solid #ccc;
box-sizing: border-box;
overflow: hidden;
}
#canvasBackground {
display: none;
}
#toolboxColumn1 {
left: 3px;
position: absolute;
top: 0;
}
#toolboxColumn2 {
left: 40px;
position: absolute;
top: 0;
}
#toolbox button {
background: #eee;
border-radius: 3px;
box-shadow: inset 1px 1px 2px white, 1px 1px 1px rgba(0,0,0,0.3);
margin: 4px;
padding: 1px;
display: block;
}
#toolbox button:hover {
background: #d6e9f8;
}
#toolbox button.selected {
background: #ccc;
box-shadow: inset 1px 1px 2px rgba(0,0,0,0.4), 1px 1px 0 #fff;
}
#toolbox button:focus {
outline: 0;
}
#menu {
background: #fff;
border-color: #ccc #666 #666 #ccc;
border-radius: 4px;
border-style: solid;
border-width: 1px;
cursor: default;
display: none;
font: normal 13px Arial, sans-serif;
margin: 0;
max-height: 100%;
outline: none;
padding: 4px 0;
position: absolute;
user-select: none;
z-index: 100;
}
.menuitem {
color: #444;
margin: 0;
padding: 4px 1em;
white-space: nowrap;
}
.menuitem:hover:not(.menuItemDisabled) {
background-color: #d6e9f8;
border-color: #d6e9f8;
border-style: dotted;
border-width: 1px 0;
padding-bottom: 3px;
padding-top: 3px;
}
.menuItemDisabled {
color: #ccc;
}
.menudiv {
border-top: 1px solid #ccc;
margin-top: 4px;
padding-top: 4px;
}
================================================
FILE: static/code/svg.js
================================================
/**
* @license
* Copyright 2018 Google LLC
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @fileoverview SVG Editor using SvgCanvas from SVG-Edit.
* @author fraser@google.com (Neil Fraser)
*/
'use strict';
import Canvas from './SVG-Edit/svgcanvas.js';
var svgEditor = {};
// Export namespace variable to window (would normally happen automatically,
// but this file is being loaded as a module).
// Used to for the parent frame to communicate with us.
window.svgEditor = svgEditor;
svgEditor.init = function() {
var container = document.getElementById('editorContainer');
var config = {
initFill: {color: 'FFFFFF', opacity: 1},
initStroke: {color: '000000', opacity: 1, width: 1},
text: {stroke_width: 0, font_size: 24, font_family: 'serif'},
initOpacity: 1,
imgPath: 'SVG-Edit/images/',
baseUnit: 'px',
};
svgEditor.canvas = new Canvas(container, config);
// Check to see if the parent window left us an initial source to render.
var source = window.initialSource;
if (source !== undefined) {
svgEditor.setString(source);
delete window.initialSource;
}
svgEditor.resize();
// Update the toolbox whenever a button is clicked.
// Don't wait for up to a quarter second until the next scheduled call.
// Also force a heavier update to catch changes such as open-close path.
var update = svgEditor.updateToolbox.bind(svgEditor, true);
for (var button of document.querySelectorAll('#toolbox button')) {
button.addEventListener('click', update, false);
}
document.addEventListener('keydown', svgEditor.keypress);
document.addEventListener('contextmenu', svgEditor.openMenu, false);
document.addEventListener('mousedown', svgEditor.mousedown, false);
document.getElementById('menu').addEventListener('click', svgEditor.menuClick);
// Don't undo beyond initialization.
svgEditor.canvas.undoMgr.resetUndoStack();
};
/**
* Resize and reposition the SVG canvas when the window has changed shape.
* Zoom so that a 100 unit tall image fills the screen.
*/
svgEditor.resize = function() {
var top = 0;
var left = 80;
var height = window.innerHeight;
var width = window.innerWidth - left;
var container = document.getElementById('editorContainer');
container.style.top = top + 'px';
container.style.left = left + 'px';
// Code City sprites are 100 units tall.
var FIXED_HEIGHT = 100;
var zoom = height / FIXED_HEIGHT;
svgEditor.canvas.setZoom(zoom);
svgEditor.canvas.setResolution(width / height * FIXED_HEIGHT, FIXED_HEIGHT);
svgEditor.canvas.updateCanvas(width, height);
// Recenter the origin to be the middle of the screen.
svgEditor.canvas.getRootElem().setAttribute('viewBox',
(-width / 2) + ' 0 ' + width + ' ' + height);
};
/**
* Handle mouse down actions.
*/
svgEditor.mousedown = function(e) {
// Control-clicking on Mac OS X is treated as a right-click.
// WebKit on Mac OS X fails to change button to 2 (but Gecko does).
if (e.ctrlKey || e.button === 2) {
svgEditor.openMenu(e);
} else if (!document.getElementById('menu').contains(e.target)) {
svgEditor.closeMenu();
}
};
/**
* Handle keyboard commands.
*/
svgEditor.keypress = function(e) {
if (e.key === 'Delete' || e.key === 'Backspace') {
svgEditor.delete();
e.preventDefault();
} else if (e.ctrlKey || e.metaKey) {
if (e.key === 'z') {
if (e.shiftKey) {
svgEditor.redo();
} else {
svgEditor.undo();
}
e.preventDefault();
} else if (e.key === 'x') {
svgEditor.cut();
e.preventDefault();
} else if (e.key === 'c') {
svgEditor.copy();
e.preventDefault();
} else if (e.key === 'v') {
svgEditor.paste();
e.preventDefault();
}
}
};
/**
* Redo one action.
*/
svgEditor.redo = function() {
var undoMgr = svgEditor.canvas.undoMgr;
if (undoMgr.getRedoStackSize() > 0) {
undoMgr.redo();
}
};
/**
* Undo one action.
*/
svgEditor.undo = function() {
var undoMgr = svgEditor.canvas.undoMgr;
if (undoMgr.getUndoStackSize() > 0) {
undoMgr.undo();
}
};
/**
* Cut selected element(s).
*/
svgEditor.cut = function() {
svgEditor.copy();
svgEditor.canvas.deleteSelectedElements();
};
/**
* Copy selected element(s).
*/
svgEditor.copy = function() {
svgEditor.canvas.copySelectedElements();
};
/**
* Delete selected element(s).
*/
svgEditor.delete = function() {
svgEditor.canvas.deleteSelectedElements();
};
/**
* Paste clipboard to middle of editor.
*/
svgEditor.paste = function() {
var svgCanvas = svgEditor.canvas;
var workarea = document.getElementById('editorContainer');
var zoom = svgCanvas.getZoom();
var y = (workarea.scrollTop + workarea.offsetHeight / 2) / zoom - svgCanvas.contentH;
svgCanvas.pasteElements('point', 0, -y);
};
/**
* Inject SVG to the editor.
* @param {string} xmlString SVG rendered as text.
*/
svgEditor.setString = function(xmlString) {
// SvgCanvas needs contents wrapped in a throw-away SVG node.
if (xmlString) {
var svgString = '' +
xmlString + ' ';
svgEditor.canvas.setSvgString(svgString);
} else {
svgEditor.canvas.clear();
}
svgEditor.resize();
// Preserve the original input, alongside its round-tripped output.
svgEditor.inputString = xmlString;
svgEditor.outputString = svgEditor.getString();
};
svgEditor.inputString = undefined;
svgEditor.outputString = undefined;
/**
* Extract the SVG from the editor.
* @return {string} SVG rendered as text.
*/
svgEditor.getString = function() {
var rootSvg = svgEditor.canvas.getContentElem();
// The user's image is the wrapped in the first group.
var contentSvg = rootSvg.querySelector('svg g').cloneNode(true);
// Remove the layer title.
var title = contentSvg.querySelector('g>title');
title.parentNode.removeChild(title);
// Walk the tree removing unused properties.
var tw = document.createTreeWalker(contentSvg, NodeFilter.SHOW_ELEMENT);
do {
var node = tw.currentNode;
node.removeAttribute('id');
node.removeAttribute('fill');
node.removeAttribute('stroke');
} while (tw.nextNode());
var source = svgEditor.canvas.svgToString(contentSvg, -1);
// Remove the wrapping .
source = source.replace(/^\s*]*>\s*/i, '');
source = source.replace(/\s*<\/g>\s*$/i, '');
// If the output is the same as the original input's round-tripped value,
// then return the original input.
// Otherwise changes may be claimed when none were made by the user.
if (source === svgEditor.outputString) {
return svgEditor.inputString;
}
return source;
};
/**
* Update the toolbox visualization in response to the editor state.
* This function is called four times a second, and when a button is clicked.
* @param {boolean=} force If true, force a redraw.
*/
svgEditor.updateToolbox = function(force) {
// Highlight the current mode button.
var mode = svgEditor.canvas.getMode();
if (force ||
(mode !== 'resize' && mode !== 'rotate' &&
mode !== svgEditor.updateToolbox.oldMode_)) {
var stylePathEdit = document.getElementById('mode-pathedit').style;
var styleSelect = document.getElementById('mode-select').style;
var styleNodeActions = document.getElementById('node-actions').style;
if (mode === 'pathedit') {
styleSelect.display = 'none';
stylePathEdit.display = 'block';
styleNodeActions.display = 'block';
// Show or hide the appropriate open/close path button.
var styleCloseAction = document.getElementById('close-action').style;
var styleOpenAction = document.getElementById('open-action').style;
if (svgEditor.canvas.pathActions.closed_subpath) {
styleCloseAction.display = 'none';
styleOpenAction.display = 'block';
} else {
styleOpenAction.display = 'none';
styleCloseAction.display = 'block';
}
} else {
stylePathEdit.display = 'none';
styleSelect.display = 'block';
styleNodeActions.display = 'none';
}
var button = document.getElementById('mode-' +
svgEditor.updateToolbox.oldMode_);
if (button) {
button.classList.remove('selected');
}
svgEditor.updateToolbox.oldMode_ = mode;
button = document.getElementById('mode-' + mode);
if (button) {
button.classList.add('selected');
}
}
// Show or hide action buttons that apply to one or more selected elements.
var selected = svgEditor.canvas.getSelectedElems();
if (selected.length !== svgEditor.updateToolbox.oldSelectedCount_) {
var actions = document.getElementById('selected-actions');
var singleActions = document.getElementById('selected-single-actions');
actions.style.display = selected.length > 0 ? 'block' : 'none';
singleActions.style.display = selected.length === 1 ? 'block' : 'none';
svgEditor.updateToolbox.oldSelectedCount_ = selected.length;
document.getElementById('menuCut').classList
.toggle('menuItemDisabled', selected.length === 0);
document.getElementById('menuCopy').classList
.toggle('menuItemDisabled', selected.length === 0);
document.getElementById('menuDelete').classList
.toggle('menuItemDisabled', selected.length === 0);
}
if (selected.length === 1) {
var element = selected[0];
document.getElementById('convertpath-action').style.display =
element.tagName === 'path' ? 'none' : 'block';
var fillStroke = svgEditor.getFillStroke(element);
var fill = fillStroke[0];
var stroke = fillStroke[1];
var fillRect = document.getElementById('fillRect');
var fillNoneStyle = document.getElementById('fillNone').style;
if (fill === 'fillNone') {
fillNoneStyle.display = 'inline';
fillRect.setAttribute('class', 'fillWhite');
} else {
fillNoneStyle.display = 'none';
fillRect.setAttribute('class', fill);
}
var strokeRect = document.getElementById('strokeRect');
if (stroke === 'strokeNone') {
strokeRect.setAttribute('stroke-width', '1');
strokeRect.setAttribute('stroke', '#d40000');
strokeRect.setAttribute('class', '');
} else {
strokeRect.setAttribute('stroke-width', '4');
strokeRect.setAttribute('stroke', '');
strokeRect.setAttribute('class', stroke);
}
}
};
svgEditor.updateToolbox.oldMode_ = '';
svgEditor.updateToolbox.oldSelectedCount_ = NaN;
/**
* Find the fill and stroke for an element.
* @param {!Element} element Element with style.
* @return {!Array} Array with normalized fill and stroke strings.
*/
svgEditor.getFillStroke = function(element) {
if (!element) throw new TypeError('Element not provided');
var classes = element.getAttribute('class') || '';
classes = classes.replace(/Gray/g, 'Grey');
var fill = classes.match(/\b(fill(None|White|Black|Grey))\b/);
fill = fill ? fill[1] : 'fillNone';
var stroke = classes.match(/\b(stroke(None|White|Black|Grey))\b/);
stroke = stroke ? stroke[1] : 'strokeBlack';
return [fill, stroke];
};
/**
* Rotate the fill in the currently selected object between allowed options.
*/
svgEditor.changeFill = function() {
var element = svgEditor.canvas.getSelectedElems()[0];
var fill = svgEditor.getFillStroke(element)[0];
var fillOptions = ['fillNone', 'fillBlack', 'fillGrey', 'fillWhite'];
var fillIndex = Math.max(fillOptions.indexOf(fill), 0);
fillIndex++;
fillIndex %= fillOptions.length;
var classes = element.getAttribute('class') || '';
classes = classes.replace(/\bfill\w+\b/g, '');
classes += ' ' + fillOptions[fillIndex];
classes = classes.replace(/\s+/g, ' ').trim();
element.setAttribute('class', classes);
};
/**
* Rotate the stroke in the currently selected object between allowed options.
*/
svgEditor.changeStroke = function() {
var element = svgEditor.canvas.getSelectedElems()[0];
var stroke = svgEditor.getFillStroke(element)[1];
var strokeOptions = ['strokeBlack', 'strokeGrey', 'strokeWhite', 'strokeNone'];
var strokeIndex = Math.max(strokeOptions.indexOf(stroke), 0);
strokeIndex++;
strokeIndex %= strokeOptions.length;
var classes = element.getAttribute('class') || '';
classes = classes.replace(/\bstroke\w+\b/g, '');
classes += ' ' + strokeOptions[strokeIndex];
classes = classes.replace(/\s+/g, ' ').trim();
element.setAttribute('class', classes);
};
/**
* Open the context menu command menu at the mouse location.
* @param {!Event} e Mouse event.
*/
svgEditor.openMenu = function(e) {
svgEditor.closeMenu();
var menu = document.getElementById('menu');
var pageHeight = window.innerHeight;
var pageWidth = window.innerWidth;
var top = e.y;
var left = e.x;
menu.style.display = 'block';
// Don't go off the bottom of the page (hug the bottom).
if (top + menu.offsetHeight > pageHeight) {
top = Math.max(pageHeight - menu.offsetHeight, 0);
}
// Don't go off the right of the page (flip menu).
if (left + menu.offsetWidth > pageWidth) {
left = Math.max(left - menu.offsetWidth, 0);
}
menu.style.top = top + 'px';
menu.style.left = left + 'px';
// Don't open the system context menu.
e.preventDefault();
};
/**
* If there is a menu open, close it.
*/
svgEditor.closeMenu = function() {
document.getElementById('menu').style.display = 'none';
};
/**
* Handle mouse clicking on a context menu option.
* @param {!Event} e Mouse event.
*/
svgEditor.menuClick = function(e) {
if (!e.target.classList.contains('menuItemDisabled')) {
switch (e.target.id) {
case 'menuCut':
svgEditor.cut();
break;
case 'menuCopy':
svgEditor.copy();
break;
case 'menuPaste':
svgEditor.paste();
break;
case 'menuDelete':
svgEditor.delete();
break;
}
}
svgEditor.closeMenu();
};
window.addEventListener('load', svgEditor.init);
window.addEventListener('resize', svgEditor.resize);
window.addEventListener('mousedown', window.focus);
setInterval(svgEditor.updateToolbox, 250);
================================================
FILE: static/code/tests/test.html
================================================
Test harness for Code City: Code
Test harness for Code City: Code
================================================
FILE: static/code/tests/test.js
================================================
/**
* @license
* Copyright 2019 Google LLC
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @fileoverview Tests for Integrated Development Environment for Code City.
* @author fraser@google.com (Neil Fraser)
*/
'use strict';
function testCommonSelectorToParts() {
// Join a list of parts into a path selector.
assertEquals('[{"type":"id","value":"$"},{"type":"keyword","value":"{proto}"},{"type":"id","value":"foo"}]', JSON.stringify(Code.Common.selectorToParts('${proto}.foo')));
}
function testCommonPartsToSelector() {
// Join a list of parts into a path selector.
assertEquals('${proto}.foo', Code.Common.partsToSelector([{type: 'id', value: '$'}, {type: 'keyword', value: '{proto}'}, {type: 'id', value: 'foo'}]));
}
function testCommonSelectorToReference() {
// No substitution.
assertEquals('$.foo', Code.Common.selectorToReference('$.foo'));
// Parent substitution.
assertEquals("$('${proto}.foo')", Code.Common.selectorToReference('${proto}.foo'));
}
function testGetPrefix() {
// No string.
assertEquals('', Code.Explorer.getPrefix([]));
// One string.
assertEquals('foo', Code.Explorer.getPrefix(['foo']));
// No prefix.
assertEquals('', Code.Explorer.getPrefix(['foo', 'bar', 'baz']));
// Some prefix.
assertEquals('ba', Code.Explorer.getPrefix(['bar', 'baz']));
// Whole prefix.
assertEquals('foo', Code.Explorer.getPrefix(['foo', 'foot', 'food']));
// Case-sensitive.
assertEquals('foo', Code.Explorer.getPrefix(['foot', 'fooT']));
}
function testAutocompletePrefix() {
// No options.
assertEquals('{"prefix":"foo","terminal":false}', JSON.stringify(Code.Explorer.autocompletePrefix([], 'foo')));
// One option.
assertEquals('{"prefix":"FOOT","terminal":true}', JSON.stringify(Code.Explorer.autocompletePrefix(['FOOT'], 'foo')));
// No prefix, one option.
assertEquals('{"prefix":"foot","terminal":true}', JSON.stringify(Code.Explorer.autocompletePrefix(['foot'], '')));
// No prefix, two options.
assertEquals('{"prefix":"foo","terminal":false}', JSON.stringify(Code.Explorer.autocompletePrefix(['food', 'foot'], '')));
// Case-sensitive prefix.
assertEquals('{"prefix":"foo","terminal":false}', JSON.stringify(Code.Explorer.autocompletePrefix(['foot', 'fool', 'FORK'], 'f')));
// Case-sensitive prefix.
assertEquals('{"prefix":"FORK","terminal":true}', JSON.stringify(Code.Explorer.autocompletePrefix(['foot', 'fool', 'FORK'], 'F')));
// Case-insensitive prefix.
assertEquals('{"prefix":"foo","terminal":false}', JSON.stringify(Code.Explorer.autocompletePrefix(['foot', 'fool'], 'F')));
// Case-insensitive no match.
assertEquals('{"prefix":"Fo","terminal":false}', JSON.stringify(Code.Explorer.autocompletePrefix(['FOOT', 'fool'], 'Fo')));
}
================================================
FILE: static/connect/common.css
================================================
body {
color: #444;
}
a {
color: #00e;
}
a:hover {
color: #d00;
}
a.command {
cursor: pointer;
text-decoration: underline dotted;
}
body.disconnected a.command,
body.disconnected a.command:hover {
cursor: not-allowed;
color: #444;
text-decoration-color: #444;
}
#scrollDiv {
bottom: 0;
left: 0;
max-height: 100%;
overflow-y: auto;
position: absolute;
right: 0;
}
svg.menuIcon {
cursor: pointer;
display: inline;
fill: #444;
height: 10px;
stroke: #fff;
vertical-align: top;
width: 11px;
}
body.disconnected svg.menuIcon {
cursor: not-allowed;
fill: #ccc;
}
svg.menuIcon:hover {
fill: #d00;
}
body.disconnected svg.menuIcon:hover {
fill: #aaa;
}
#menu {
background: #fff;
border-color: #ccc #666 #666 #ccc;
border-radius: 4px;
border-style: solid;
border-width: 1px;
cursor: default;
font: normal 13px Arial, sans-serif;
margin: 0;
max-height: 100%;
outline: none;
padding: 4px 0;
position: absolute;
z-index: 100;
}
.menuitem {
color: #444;
margin: 0;
padding: 4px 1em;
white-space: nowrap;
}
body.disconnected .menuitem {
color: #ccc;
cursor: not-allowed;
}
.menuitem:hover {
background-color: #d6e9f8;
border-color: #d6e9f8;
border-style: dotted;
border-width: 1px 0;
padding-bottom: 3px;
padding-top: 3px;
}
================================================
FILE: static/connect/common.js
================================================
/**
* @license
* Copyright 2017 Google LLC
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @fileoverview Functions common across log/world frames of Code City's client.
* @author fraser@google.com (Neil Fraser)
*/
'use strict';
var CCC = {};
CCC.Common = {};
/**
* Namespace for SVG elements.
* @constant
*/
CCC.Common.NS = 'http://www.w3.org/2000/svg';
/**
* Is the client currently connected to the server?
*/
CCC.Common.isConnected = false;
/**
* Enum for message types to the log/world frames.
* Should be identical to CCC.MessageTypes
* @enum {string}
*/
CCC.Common.MessageTypes = {
// Messages that may be paused:
COMMAND: 'command', // User-generated command echoed.
MEMO: 'memo', // Block of text from Code City.
CONNECT_MSG: 'connect msg', // User-visible connection message.
DISCONNECT_MSG: 'disconnect msg', // User-visible disconnection message.
// Messages that may be sent while paused:
CONNECTION: 'connection', // Signal change of connection state.
CLEAR: 'clear', // Signal tho clear history.
BLUR: 'blur' // Signal to close pop-up menus.
};
/**
* Initialization code called on startup.
*/
CCC.Common.init = function() {
CCC.Common.parser = new DOMParser();
CCC.Common.serializer = new XMLSerializer();
document.body.addEventListener('click', CCC.Common.closeMenu, true);
document.body.addEventListener('keydown', CCC.Common.keyDown, true);
document.body.addEventListener('keypress', CCC.Common.keyPress, true);
// Report back to the parent frame that we're fully loaded and ready to go.
parent.postMessage('init', location.origin);
};
/**
* Verify that a received message is from our parent frame.
* @param {!Event} e Incoming message event.
* @return {*} Value from message.
*/
CCC.Common.verifyMessage = function(e) {
var origin = e.origin || e.originalEvent.origin;
if (origin !== location.origin) {
throw new Error('Message received by frame from unknown origin: ' + origin);
}
return e.data;
};
/**
* Change the connection status between being connected or disconnected.
* @param {boolean} newConnected New status.
*/
CCC.Common.setConnected = function(newConnected) {
if (newConnected === CCC.Common.isConnected) {
return; // No change.
}
CCC.Common.isConnected = newConnected;
// Add/remove a classname on body, so that links and menus can change style.
if (CCC.Common.isConnected) {
document.body.classList.remove('disconnected');
} else {
document.body.classList.add('disconnected');
}
};
/**
* Create a command menu icon. Attach the menu commands to the icon.
* @param {!Array|!Element} cmds Array of menu commands,
* or root DOM element describing the menu commands.
* @return {SVGSVGElement} Root element of icon.
*/
CCC.Common.newMenuIcon = function(cmds) {
if (cmds.querySelectorAll) {
// HTML frames provide commands as XML.
// Convert the command DOM into an array.
// look Bob 123456 789 -> '123456789'
* @param {!Element} node Root DOM element.
* @return {string} Plain text.
*/
CCC.Common.innerText = function(node) {
var text = '';
if (node.nodeType === Node.TEXT_NODE) {
text = node.data;
} else if (node.nodeType === Node.ELEMENT_NODE) {
for (var child of node.childNodes) {
text += CCC.Common.innerText(child);
}
}
return text;
};
/**
* Open the command menu for the clicked menu icon.
* @param {!Event} e Click event.
* @this {!SVGSVGElement} Root element of icon.
*/
CCC.Common.openMenu = function(e) {
CCC.Common.closeMenu(); // Should be already closed, but let's make sure.
var cmds = JSON.parse(this.getAttribute('data-cmds'));
var menu = document.createElement('div');
menu.id = 'menu';
for (var cmd of cmds) {
var menuItem = document.createElement('div');
menuItem.className = 'menuitem';
menuItem.appendChild(document.createTextNode(cmd));
menuItem.addEventListener('click', CCC.Common.commandFunction, false);
menu.appendChild(menuItem);
}
var scrollDiv = document.getElementById('scrollDiv');
var pageHeight = scrollDiv.scrollHeight;
var pageWidth = scrollDiv.scrollWidth;
scrollDiv.appendChild(menu);
var iconRect = this.getBoundingClientRect();
// Calculate preferred location of below and right of icon.
var top = iconRect.top + scrollDiv.scrollTop + iconRect.height -
scrollDiv.offsetTop;
var left = iconRect.left + scrollDiv.scrollLeft;
// Flip up if below page.
if (top + menu.offsetHeight > pageHeight) {
top -= menu.offsetHeight + iconRect.height;
// Don't go off the top of the page.
top = Math.max(top, 0);
}
// Don't go off the right of the page.
if (left + menu.offsetWidth > pageWidth) {
left = pageWidth - menu.offsetWidth;
// Don't go off the right of the page.
left = Math.max(left, 0);
}
menu.style.top = top + 'px';
menu.style.left = left + 'px';
};
/**
* If there is a menu open, close it.
*/
CCC.Common.closeMenu = function() {
var menu = document.getElementById('menu');
if (menu) {
menu.parentNode.removeChild(menu);
CCC.Common.parentFocus();
}
};
/**
* When clicked, execute the printed command.
* @this {!Element} Clicked element.
*/
CCC.Common.commandFunction = function() {
var command = this.innerText;
// Menu commands should never be multi-line.
// This should never happen and be caught earlier.
// But if it does, fail here rather than be a security hole.
if (command.split(/[\r\n]/).length !== 1) {
throw new Error('Multi-line command: ' + command);
}
if (CCC.Common.isConnected) {
parent.postMessage({'commands': [command]}, location.origin);
}
CCC.Common.parentFocus();
};
/**
* The user pressed a key with the focus in the world/log frame.
* Move focus back to the parent frame and inject the keystroke into the
* command area.
* @param {!KeyboardEvent} e Keyboard down event.
*/
CCC.Common.keyDown = function(e) {
if (e.key === 'Alt' || e.key === 'Control' || e.key === 'Meta') {
// Don't steal focus if the user is pressing a modifier key in preparation
// for a cut/copy operation.
return;
}
if (e.ctrlKey || e.altKey || e.metaKey) {
// Allow Chrome time to complete a copy before moving focus.
setTimeout(CCC.Common.parentFocus, 0);
} else {
CCC.Common.parentFocus(e);
}
};
/**
* The user pressed a key with the focus in the world/log frame.
* Move focus back to the parent frame and inject the keystroke into the
* command area.
* @param {!KeyboardEvent} e Keyboard press event.
*/
CCC.Common.keyPress = function(e) {
// Allow Firefox time to complete a copy before moving focus.
setTimeout(CCC.Common.parentFocus, 0);
};
/**
* Move focus back to the parent frame. If specified, inject the keystroke
* into the command area.
* @param {KeyboardEvent} e Optional keyboard event.
*/
CCC.Common.parentFocus = function(e) {
try {
var ct = parent.document.getElementById('commandTextarea');
ct.focus();
// Chrome won't type the character in the textarea after a focus change.
// For the easy case where the field is empty, just add the character.
// TODO: Handle cases where the field is not empty.
if (e && e.key.length === 1 && !ct.value.length) {
ct.value = e.key;
// Firefox will type the character a second time, prevent this.
e.preventDefault();
}
} catch (e) {
// Cross-frame is risky in some browsers. Fallback method.
parent.focus();
}
};
/**
* Helper method for creating SVG elements.
* @param {string} name Element's tag name.
* @param {!Object} attrs Dictionary of attribute names and values.
* @param {!Element=} opt_parent Optional parent on which to append the element.
* @return {!SVGElement} Newly created SVG element.
*/
CCC.Common.createSvgElement = function(name, attrs, opt_parent) {
var el = document.createElementNS(CCC.Common.NS, name);
for (var key in attrs) {
el.setAttribute(key, attrs[key]);
}
if (opt_parent) {
opt_parent.appendChild(el);
}
return el;
};
/**
* Given plain text, encode spaces and tabs such that HTML won't crush it.
* Does not handle line breaks in any way.
* @param {string} text Plain text.
* @return {string} HTML with any runs of spaces encoded.
*/
CCC.Common.escapeSpaces = function(text) {
return text.replace(/\t/g, '\u00A0 \u00A0 \u00A0 \u00A0 ')
.replace(/ /g, '\u00A0 ').replace(/ /g, '\u00A0 ')
.replace(/^ /gm, '\u00A0');
};
/**
* Detect URLs in the provided document fragment and replace with links.
* @param {!Element} el A DOM element to scan and modify.
*/
CCC.Common.autoHyperlink = function(el) {
var isSvg = el.namespaceURI === CCC.Common.NS;
var children = el.childNodes; // This is a live NodeList.
for (var i = children.length - 1, child; (child = children[i]); i--) {
if (child.nodeType !== Node.TEXT_NODE) {
CCC.Common.autoHyperlink(child);
continue;
}
var text = child.nodeValue;
var parts = text.split(CCC.Common.autoHyperlink.urlRegex);
if (parts.length <= 1) { // No hyperlinks found.
continue;
}
for (var j = 0; j < parts.length; j++) {
var part = parts[j];
var m = part.match(CCC.Common.autoHyperlink.urlRegex);
// Look up the previous character (if it exists), to weed out: $.www.bar
var prevChar = j ? parts[j - 1].substr(-1) : '';
if (prevChar !== '.' && m && m[0] === part) {
// This part is a URL.
var n = part.match(/[.,!)\]?']+$/);
if (n) {
// Move any trailing punctuation out of URL.
part = part.substring(0, part.length - n[0].length);
parts[j + 1] = n[0] + (parts[j + 1] || '');
}
var href = part;
if (!/^https?:\/\//.test(href)) {
href = 'http://' + href;
}
var link = isSvg ? document.createElementNS(CCC.Common.NS, 'a') :
document.createElement('a');
link.setAttribute('href', href);
link.setAttribute('target', '_blank');
link.setAttribute('rel', 'noopener noreferrer');
link.appendChild(document.createTextNode(part));
newNode = link;
} else {
// This part is plain text.
var newNode = document.createTextNode(part);
}
el.insertBefore(newNode, child);
}
el.removeChild(child);
}
};
CCC.Common.autoHyperlink.urlRegex =
/(\b(?:https?:\/\/|www\.)[-\w.~:\/?#\[\]@!$&'()*+,;=%]+)/i;
// Set background colour to differentiate server vs local copy.
if (location.hostname === 'localhost') {
window.addEventListener('load', function() {
document.body.style.backgroundColor = '#ffe';
});
}
================================================
FILE: static/connect/connect.css
================================================
html {
height: 100%;
}
body {
color: #444;
background-color: #fff;
border-left: 2px dashed #fff;
border-right: 2px dashed #fff;
font-family: 'Roboto Mono', monospace;
height: 100%;
margin: 0;
overflow: hidden;
padding: 0;
transition: border 0.5s;
}
body.paused {
border-left: 2px dashed #d00;
border-right: 2px dashed #d00;
}
#worldFrame, #logFrame {
position: absolute;
width: 100%;
z-index: -1;
border: none;
}
#mainTable {
height: 100%;
width: 100%;
background: #fff;
}
tfoot {
height: 1%;
}
#displayCell {
text-align: center;
}
#commandTextarea {
color: #000;
box-sizing: border-box;
background-color: #f8f8f8;
font-size: 12pt;
height: 42pt;
margin-top: 2px;
resize: none;
width: 100%;
}
#optionsDiv {
background: rgba(255,255,255, 0.8);
margin-right: 25px; /* Leave room for the scrollbar. */
position: fixed;
right: 0;
top: 0;
z-index: 9; /* On top of the iframes. */
padding: 0 2px 2px 2px;
}
.icon {
height: 8px;
width: 8px;
fill: #444;
}
.jfk-button {
border-top-left-radius: 0;
border-top-right-radius: 0;
border-top: none !important;
}
#playIcon {
fill: #fff;
}
#worldButton {
border-bottom-right-radius: 0;
margin-right: 0;
}
#logButton {
border-bottom-left-radius: 0;
margin-left: -1px;
}
#clearButton {
margin-right: 0; /* This is the right-most button. */
}
================================================
FILE: static/connect/connect.js
================================================
/**
* @license
* Copyright 2017 Google LLC
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @fileoverview Code City's client.
* @author fraser@google.com (Neil Fraser)
*/
'use strict';
var CCC = {};
/**
* Smallest interval in milliseconds between pings.
* @constant
*/
CCC.MIN_PING_INTERVAL = 1000;
/**
* Largest interval in milliseconds between pings.
* @constant
*/
CCC.MAX_PING_INTERVAL = 4000;
/**
* Maximum number of commands saved in history.
* @constant
*/
CCC.MAX_HISTORY_SIZE = 1000;
/**
* Location to send pings to.
* @constant
*/
CCC.PING_URL = 'ping';
// Properties below this point are not configurable.
/**
* All the commands the user has sent.
*/
CCC.commandHistory = [];
/**
* When browsing the command history, save the current command here.
*/
CCC.commandTemp = '';
/**
* Where in the command history are we browsing?
*/
CCC.commandHistoryPointer = -1;
/**
* When was the last time we saw the user?
* @type {number}
*/
CCC.lastActiveTime = Date.now();
/**
* Number of lines we think the user has not seen.
*/
CCC.unreadLines = 0;
/**
* The index number of the most recent command added to the command buffer.
*/
CCC.commandNum = 0;
/**
* Buffer of commands being sent, awaiting acks from server.
*/
CCC.commandBuffer = [];
/**
* Bit to switch off local echo when typing passwords.
*/
CCC.localEcho = true;
/**
* The index number of the most recent memo received from the server.
*/
CCC.memoNum = 0;
/**
* Number of calls to countdown required before launching.
*/
CCC.countdownValue = 3;
/**
* XMLHttpRequest currently in flight, or null.
* @type {XMLHttpRequest}
*/
CCC.xhrObject = null;
/**
* Current length of time between pings.
*/
CCC.pingInterval = CCC.MIN_PING_INTERVAL;
/**
* Process ID of next ping to the server.
*/
CCC.nextPingPid = -1;
/**
* Flag for only acknowledging new memos after a new memo has arrived.
* Saves bandwidth.
*/
CCC.ackMemoNextPing = true;
/**
* Buffer to accumulate incoming messages when paused.
*/
CCC.pauseBuffer = null;
/**
* Number of consecutive ping errors that have occurred.
*/
CCC.xhrErrorCounter = 0;
/**
* Sequence of possible connection states.
* @enum {number}
*/
CCC.ConnectionStates = {
NEVER_CONNECTED: 0,
CONNECTED: 1,
DISCONNECTED: 2
};
/**
* Is the client currently connected to the server?
* @type {CCC.ConnectionStates}
*/
CCC.connectionState = CCC.ConnectionStates.NEVER_CONNECTED;
/**
* Enum for message types to the log/world frames.
* Should be identical to CCC.Common.MessageTypes
* @enum {string}
*/
CCC.MessageTypes = {
// Messages that may be paused:
COMMAND: 'command', // User-generated command echoed.
MEMO: 'memo', // Block of text from Code City.
CONNECT_MSG: 'connect msg', // User-visible connection message.
DISCONNECT_MSG: 'disconnect msg', // User-visible disconnection message.
// Messages that may be sent while paused:
CONNECTION: 'connection', // Signal change of connection state.
CLEAR: 'clear', // Signal to clear history.
BLUR: 'blur' // Signal to close pop-up menus.
};
/**
* Unique queue ID. Identifies this client to the connectServer across
* polling connections. Set by the server at startup.
* @private
*/
CCC.queueId_ = SESSION_ID;
/**
* After every iframe has reported ready, call the initialization.
*/
CCC.countdown = function() {
CCC.countdownValue--;
if (!CCC.countdownValue) {
CCC.init();
}
};
/**
* Initialization code called on startup.
*/
CCC.init = function() {
CCC.worldFrame = document.getElementById('worldFrame');
CCC.logFrame = document.getElementById('logFrame');
CCC.displayCell = document.getElementById('displayCell');
CCC.commandTextarea = document.getElementById('commandTextarea');
// When the user closes the tab/window, tell connect server to logout.
window.addEventListener('unload', function() {
CCC.abortPing();
clearTimeout(CCC.nextPingPid);
var sendingJson = {
'q': CCC.queueId_,
'logout': true
};
navigator.sendBeacon(CCC.PING_URL, JSON.stringify(sendingJson));
}, false);
// When focus returns to this frame from an iframe, go to the command area.
// This happens whenever a command link is clicked in an iframe.
window.addEventListener('focus', function() {
CCC.commandTextarea.focus();
}, false);
window.addEventListener('resize', CCC.resize, false);
// Firefox needs a 0ms delay before first resize, Chrome does not care.
setTimeout(CCC.resize, 0);
CCC.commandTextarea.addEventListener('keydown', CCC.keydown, false);
CCC.commandTextarea.addEventListener('click', CCC.userActive, false);
CCC.commandTextarea.value = '';
// Restore command history from sessionStorage.
var sessionHistory = sessionStorage.getItem('commandHistory');
if (sessionHistory) {
CCC.commandHistory = JSON.parse(sessionHistory);
}
var clearButton = document.getElementById('clearButton');
clearButton.addEventListener('click', CCC.clear, false);
var pauseButton = document.getElementById('pauseButton');
pauseButton.addEventListener('click', CCC.pause, false);
var worldButton = document.getElementById('worldButton');
worldButton.addEventListener('click', CCC.tab.bind(null, 'world'), false);
var logButton = document.getElementById('logButton');
logButton.addEventListener('click', CCC.tab.bind(null, 'log'), false);
document.body.addEventListener('click', function() {
CCC.postToAllFrames({'mode': 'blur'});
}, true);
CCC.tab();
CCC.schedulePing(0);
// Firefox sometimes caches the disabled value on reload.
CCC.commandTextarea.disabled = false;
};
/**
* Switch between world and log views.
* @param {string=} mode Either 'world' or 'log', or undefined.
*/
CCC.tab = function(mode) {
if (!mode) {
// Check for a cookie preference.
var m = document.cookie.match(/(?:^|;\s*)TAB=(\w+)(?:;|$)/);
mode = m ? m[1] : 'world';
}
CCC.userActive();
var worldButton = document.getElementById('worldButton');
var logButton = document.getElementById('logButton');
if (mode === 'world') {
CCC.worldFrame.style.zIndex = 1;
CCC.logFrame.style.zIndex = -1;
CCC.commandTextarea.style.fontFamily = '"Patrick Hand", "Comic Sans MS"';
worldButton.classList.add('jfk-checked');
logButton.classList.remove('jfk-checked');
} else {
CCC.logFrame.style.zIndex = 1;
CCC.worldFrame.style.zIndex = -1;
CCC.commandTextarea.style.fontFamily = '"Roboto Mono", monospace';
worldButton.classList.remove('jfk-checked');
logButton.classList.add('jfk-checked');
}
// Set a session cookie to preserve this setting.
document.cookie = 'TAB=' + mode;
CCC.commandTextarea.focus();
};
/**
* Clear all history.
*/
CCC.clear = function() {
CCC.userActive();
CCC.commandHistory.length = 0;
CCC.commandTemp = '';
CCC.commandHistoryPointer = -1;
sessionStorage.removeItem('commandHistory');
if (CCC.pauseBuffer) {
var datum;
while ((datum = CCC.pauseBuffer[0]) &&
datum[0] !== CCC.MessageTypes.DISCONNECT_MSG) {
CCC.pauseBuffer.shift();
}
// Clear the date/time on the 'Reconnect?' line (if it exists).
if (datum) {
datum[1] = '...';
}
}
CCC.postToAllFrames({'mode': 'clear'});
CCC.commandTextarea.focus();
};
/**
* Toggle pausing of incoming messages.
*/
CCC.pause = function() {
CCC.userActive();
var paused = CCC.pauseBuffer === null;
var pauseButton = document.getElementById('pauseButton');
var pauseIcon = document.getElementById('pauseIcon');
var playIcon = document.getElementById('playIcon');
if (paused) {
document.body.classList.add('paused');
pauseButton.classList.add('jfk-button-action');
pauseIcon.style.display = 'none';
playIcon.style.display = '';
// Initialize the pause buffer.
CCC.pauseBuffer = [];
} else {
document.body.classList.remove('paused');
pauseButton.classList.remove('jfk-button-action');
pauseIcon.style.display = '';
playIcon.style.display = 'none';
// Fire off all accumulated messages.
var buffer = CCC.pauseBuffer;
CCC.pauseBuffer = null;
for (var args of buffer) {
CCC.distributeMessage.apply(null, args);
}
}
CCC.commandTextarea.focus();
};
/**
* Reposition the iframes over the placeholder displayCell.
* Called when the window changes size.
*/
CCC.resize = function() {
// Compute the absolute coordinates and dimensions of displayCell.
var element = CCC.displayCell;
var x = 0;
var y = 0;
do {
x += element.offsetLeft;
y += element.offsetTop;
element = element.offsetParent;
} while (element);
// Position both iframes over displayCell.
CCC.worldFrame.style.left = x + 'px';
CCC.worldFrame.style.top = y + 'px';
CCC.worldFrame.style.width = CCC.displayCell.offsetWidth + 'px';
CCC.worldFrame.style.height = CCC.displayCell.offsetHeight + 'px';
CCC.logFrame.style.left = x + 'px';
CCC.logFrame.style.top = y + 'px';
CCC.logFrame.style.width = CCC.displayCell.offsetWidth + 'px';
CCC.logFrame.style.height = CCC.displayCell.offsetHeight + 'px';
};
/**
* Receive messages from our child frames.
* @param {!Event} e Incoming message event.
*/
CCC.receiveMessage = function(e) {
var origin = e.origin || e.originalEvent.origin;
if (origin !== location.origin) {
console.error('Message received by client frame from unknown origin: ' +
origin);
return;
}
if (!e.data) {
// Shouldn't happen, but harmless.
} else if (e.data === 'init') {
// A frame is notifying us that it has fully loaded.
CCC.countdown();
} else if (e.data['commands'] && e.data['commands'].length) {
// User has clicked a command link or command menu.
for (var command of e.data['commands']) {
CCC.sendCommand(command, true);
}
} else {
console.log('Unknown message received by client frame: ' + e.data);
}
};
/**
* Distribute a line of text to all frames. If paused, hold this message back.
* @param {!CCC.MessageTypes} mode Message type.
* @param {string} text Text to or from Code City.
*/
CCC.distributeMessage = function(mode, text) {
if (CCC.pauseBuffer) {
CCC.pauseBuffer.push(arguments);
return;
}
CCC.postToAllFrames({'mode': mode, 'text': text});
};
/**
* Distribute an encoded message to all sub-frames.
* @param {!Object} json Encoded message.
*/
CCC.postToAllFrames = function(json) {
CCC.worldFrame.contentWindow.postMessage(json, location.origin);
CCC.logFrame.contentWindow.postMessage(json, location.origin);
};
/**
* Add one command to the outbound queue.
* @param {string} commands Text of user's command. May be more than one line.
* @param {boolean} echo True if command to be saved in history.
*/
CCC.sendCommand = function(commands, echo) {
CCC.userActive();
commands = commands.split('\n');
// A blank line at the end of a multi-line command is usually accidental.
if (commands.length > 1 && !commands[commands.length - 1]) {
commands.pop();
}
for (var command of commands) {
// Add command to list of commands to send to server.
CCC.commandBuffer.push(command + '\n');
CCC.commandNum++;
// Add command to history.
if (echo) {
if (!CCC.commandHistory.length ||
CCC.commandHistory[CCC.commandHistory.length - 1] !== command) {
CCC.commandHistory.push(command);
}
}
while (CCC.commandHistory.length > CCC.MAX_HISTORY_SIZE) {
CCC.commandHistory.shift();
}
// Echo command onscreen.
if (echo) {
CCC.distributeMessage(CCC.MessageTypes.COMMAND, command);
}
}
CCC.commandTemp = '';
CCC.commandHistoryPointer = -1;
sessionStorage.setItem('commandHistory', JSON.stringify(CCC.commandHistory));
// User is sending command, reset the ping to be frequent.
CCC.pingInterval = CCC.MIN_PING_INTERVAL;
CCC.abortPing();
CCC.doPing();
};
/**
* Interrupt any in-flight ping.
*/
CCC.abortPing = function() {
if (CCC.xhrObject) {
CCC.xhrObject.abort();
CCC.xhrObject = null;
}
};
/**
* Initiate an XHR network connection.
*/
CCC.doPing = function() {
if (CCC.xhrObject) {
// Another ping is currently in progress.
return;
}
// Next ping will be scheduled when this ping completes,
// but schedule a contingency ping in case of some thrown error.
CCC.schedulePing(CCC.MAX_PING_INTERVAL + 1);
var sendingJson = {
'q': CCC.queueId_
};
if (CCC.ackMemoNextPing) {
sendingJson['ackMemoNum'] = CCC.memoNum;
}
if (CCC.commandBuffer.length) {
sendingJson['cmdNum'] = CCC.commandNum;
sendingJson['cmds'] = CCC.commandBuffer;
}
// XMLHttpRequest with timeout works in IE8 or better.
var req = new XMLHttpRequest();
req.onload = CCC.xhrLoaded;
req.ontimeout = CCC.xhrError;
req.onerror = CCC.xhrError;
req.open('POST', CCC.PING_URL, true);
req.timeout = CCC.MAX_PING_INTERVAL; // Time in milliseconds.
req.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
req.send(JSON.stringify(sendingJson));
CCC.xhrObject = req;
// Let the ping interval creep up.
CCC.pingInterval = Math.min(CCC.MAX_PING_INTERVAL, CCC.pingInterval * 1.1);
};
/**
* Error handler for XHR request.
* @this {!XMLHttpRequest}
*/
CCC.xhrError = function() {
CCC.xhrErrorCounter++;
console.warn('Connection error: ' + CCC.xhrErrorCounter);
CCC.xhrObject = null;
if (CCC.xhrErrorCounter >= 8) {
// Too many errors. Drop the connection.
CCC.terminate();
return;
} else {
CCC.schedulePing(CCC.pingInterval);
}
};
/**
* Callback function for XHR request.
* Check network response was ok, then call CCC.parse.
* @this {!XMLHttpRequest}
*/
CCC.xhrLoaded = function() {
CCC.xhrObject = null;
// Only if "OK".
if (this.status === 200) {
try {
var json = JSON.parse(this.responseText);
} catch (e) {
console.warn('Invalid JSON: ' + this.responseText);
CCC.xhrError();
return;
}
CCC.xhrErrorCounter = 0;
CCC.parse(json);
} else if (this.status === 410) {
console.warn('Session closed.');
CCC.terminate();
return;
} else if (this.status) {
console.warn('Connection error code: ' + this.status);
CCC.xhrError();
return;
}
CCC.schedulePing(CCC.pingInterval);
};
/**
* Received an error from the server, indicating that our connection is closed.
*/
CCC.terminate = function() {
CCC.connectionState = CCC.ConnectionStates.DISCONNECTED;
clearTimeout(CCC.nextPingPid);
// Send immediate signal to enter readonly-mode for all frames.
CCC.postToAllFrames({'mode': CCC.MessageTypes.CONNECTION, 'state': false});
// Send user-visible message (which might be delayed due to pause).
CCC.distributeMessage(CCC.MessageTypes.DISCONNECT_MSG,
CCC.currentDateString());
};
/**
* Parse the response from the server.
* @param {!Object} receivedJson Server data.
*/
CCC.parse = function(receivedJson) {
if (CCC.connectionState === CCC.ConnectionStates.DISCONNECTED) {
throw new Error('JSON received after disconnection: ' + receivedJson);
} else if (CCC.connectionState === CCC.ConnectionStates.NEVER_CONNECTED) {
CCC.postToAllFrames({'mode': CCC.MessageTypes.CONNECTION, 'state': true});
CCC.distributeMessage(CCC.MessageTypes.CONNECT_MSG,
CCC.currentDateString());
CCC.connectionState = CCC.ConnectionStates.CONNECTED;
}
var ackCmdNum = receivedJson['ackCmdNum'];
var memoNum = receivedJson['memoNum'];
var memos = receivedJson['memos'];
if (typeof ackCmdNum === 'number') {
if (ackCmdNum > CCC.commandNum) {
console.error('Server acks ' + ackCmdNum +
', but CCC.commandNum is only ' + CCC.commandNum);
CCC.terminate();
}
// Server acknowledges receipt of commands.
// Remove them from the output list.
CCC.commandBuffer.splice(0,
CCC.commandBuffer.length + ackCmdNum - CCC.commandNum);
}
if (typeof memoNum === 'number') {
// Server sent messages. Increase client's index for acknowledgment.
var currentIndex = memoNum - memos.length + 1;
for (var memo of memos) {
if (currentIndex > CCC.memoNum) {
CCC.memoNum = currentIndex;
CCC.distributeMessage(CCC.MessageTypes.MEMO, memo);
// Reduce ping interval.
CCC.pingInterval =
Math.max(CCC.MIN_PING_INTERVAL, CCC.pingInterval * 0.8);
}
currentIndex++;
}
CCC.setUnreadLines(CCC.unreadLines + memos.length);
CCC.ackMemoNextPing = true;
} else {
CCC.ackMemoNextPing = false;
}
};
/**
* Schedule the next ping.
* @param {number} ms Milliseconds.
*/
CCC.schedulePing = function(ms) {
clearTimeout(CCC.nextPingPid);
CCC.nextPingPid = setTimeout(CCC.doPing, ms);
};
/**
* Monitor the user's keystrokes in the command text area.
* @param {!Event} e Keydown event.
*/
CCC.keydown = function(e) {
CCC.userActive();
if (!e.shiftKey && e.key === 'Enter') {
// Enter
if (CCC.connectionState === CCC.ConnectionStates.CONNECTED) {
CCC.sendCommand(CCC.commandTextarea.value, CCC.localEcho);
// Clear the textarea.
CCC.commandTextarea.value = '';
CCC.commandHistoryPointer = -1;
CCC.commandTemp = '';
} else {
// Pulse the command text area to indicate disconnection.
CCC.commandTextarea.style.transition = '';
CCC.commandTextarea.style.backgroundColor = '#f88';
// Wait 0.1 seconds for the browser to process the above style changes.
setTimeout(function() {
CCC.commandTextarea.style.transition = 'background-color 1s';
CCC.commandTextarea.style.backgroundColor = '';
}, 100);
}
e.preventDefault(); // Don't add an enter after the clear.
} else if ((!e.shiftKey && e.key === 'ArrowUp') ||
(e.ctrlKey && e.key === 'p')) {
// Up or Ctrl-P
if (!CCC.commandHistory.length) {
return;
}
if (CCC.commandHistoryPointer === -1) {
CCC.commandTemp = CCC.commandTextarea.value;
CCC.commandHistoryPointer = CCC.commandHistory.length - 1;
CCC.commandTextarea.value = CCC.commandHistory[CCC.commandHistoryPointer];
} else if (CCC.commandHistoryPointer > 0) {
CCC.commandHistoryPointer--;
CCC.commandTextarea.value = CCC.commandHistory[CCC.commandHistoryPointer];
}
e.preventDefault(); // Don't move the cursor to start after change.
} else if ((!e.shiftKey && e.key === 'ArrowDown') ||
(e.ctrlKey && e.key === 'n')) {
// Down or Ctrl-N
if (!CCC.commandHistory.length) {
return;
}
if (CCC.commandHistoryPointer === CCC.commandHistory.length - 1) {
CCC.commandHistoryPointer = -1;
CCC.commandTextarea.value = CCC.commandTemp;
CCC.commandTemp = '';
} else if (CCC.commandHistoryPointer >= 0) {
CCC.commandHistoryPointer++;
CCC.commandTextarea.value = CCC.commandHistory[CCC.commandHistoryPointer];
}
} else if (e.key === 'Tab') {
// Tab
e.preventDefault(); // Don't change the focus.
if (!CCC.commandHistory.length) {
return;
}
var chp = CCC.commandHistoryPointer;
if (chp === -1) { // Save the current value.
CCC.commandTemp = CCC.commandTextarea.value;
}
var reverse = e.shiftKey;
for (var i = 0; i <= CCC.commandHistory.length; i++) {
// Loop through the entire history, and the current value.
chp += reverse ? 1 : -1;
if (chp < -1) { // Wrap up.
chp = CCC.commandHistory.length - 1;
} else if (chp >= CCC.commandHistory.length) { // Wrap down.
chp = -1;
}
if (chp === -1) {
// The current value is always a match.
CCC.commandHistoryPointer = -1;
CCC.commandTextarea.value = CCC.commandTemp;
CCC.commandTemp = '';
break;
} else if (CCC.commandHistory[chp].toLowerCase()
.startsWith(CCC.commandTemp.toLowerCase())) {
CCC.commandHistoryPointer = chp;
CCC.commandTextarea.value = CCC.commandHistory[chp];
break;
}
}
} else if (e.key.length === 1) {
CCC.commandHistoryPointer = -1;
CCC.commandTemp = '';
}
// Delete the placeholder text as soon as the user types anything.
CCC.commandTextarea.placeholder = '';
};
/**
* The user is active.
* Reset the last active time, and clear the notification of unread lines.
*/
CCC.userActive = function() {
CCC.lastActiveTime = Date.now();
CCC.setUnreadLines(0);
};
/**
* Change the number of unread lines, as notified in the title.
* @param {number} n Number of unread lines.
*/
CCC.setUnreadLines = function(n) {
CCC.unreadLines = n;
var title = document.title;
// Strip off old number.
title = title.replace(/ \(\d+\)$/, '');
// Add new number if user hasn't been seen in 10 seconds.
if (n && CCC.lastActiveTime + 10000 < Date.now()) {
title += ' (' + n + ')';
}
document.title = title;
};
/**
* Return a local date/time in 'yyyy-mm-dd hh:mm:ss' format.
* @return {string} Current date/time.
*/
CCC.currentDateString = function() {
var now = new Date();
var dy = now.getFullYear();
var dm = ('0' + (now.getMonth() + 1)).slice(-2);
var dd = ('0' + now.getDate()).slice(-2);
var th = ('0' + now.getHours()).slice(-2);
var tm = ('0' + now.getMinutes()).slice(-2);
var ts = ('0' + now.getSeconds()).slice(-2);
return dy + '-' + dm + '-' + dd + ' ' + th + ':' + tm + ':' + ts;
};
window.addEventListener('message', CCC.receiveMessage, false);
window.addEventListener('load', CCC.countdown, false);
================================================
FILE: static/connect/log.css
================================================
body {
font-family: 'Roboto Mono', monospace;
}
#scrollDiv {
padding-left: 15px;
}
#scrollDiv>div:first-child {
/* Add whitespace above the first line so that the client buttons don't
obscure any content. */
margin-top: 2em;
}
.zippySpan {
cursor: pointer;
margin-left: -15px;
position: absolute;
}
.zippySpan::before {
content: '▸ ';
}
.zippySpan.open::before {
content: '▾ ';
}
.zippySpan:hover {
color: #d00;
}
pre {
font-family: 'Roboto Mono', monospace;
margin-bottom: 0;
margin-top: 0;
}
.commandDiv {
background: #ffc;
}
.sceneTitle {
font-weight: bold;
}
.openIcon {
fill: #444;
width: 1.5ex;
}
.openIcon:hover {
fill: #d00;
}
.connectDiv {
background-color: #0a0;
}
.disconnectDiv {
background-color: #d00;
}
.connectDiv, .disconnectDiv {
color: #fff;
padding: 0 15px;
margin-left: -15px;
}
.connectDiv>.date, .disconnectDiv>.date {
float: right;
}
a.reconnect {
color: #fff;
cursor: pointer;
margin-left: 1em;
text-decoration: underline dotted;
user-select: none;
}
a.reconnect:hover {
opacity: .9;
}
================================================
FILE: static/connect/log.js
================================================
/**
* @license
* Copyright 2017 Google LLC
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @fileoverview Log frame of Code City's client.
* @author fraser@google.com (Neil Fraser)
*/
'use strict';
CCC.Log = {};
/**
* Maximum number of lines saved in history.
*/
CCC.Log.maxHistorySize = 10000;
/**
* Allowed protocols for iframe links.
* Probably best not to allow 'javascript:' URIs due to security reasons.
*/
CCC.Log.protocolRegex =
/^((https?|ftp|gopher|data|irc|telnet|news|wais|file|nntp|mailto):|\/)/;
/**
* Record of the user's name. Used for displaying 2nd person vs 3rd person
* messages. E.g.: You say, "Hello." -vs- Max says, "Hello."
* @type {string=}
*/
CCC.Log.userName = undefined;
/**
* Initialization code called on startup.
*/
CCC.Log.init = function() {
CCC.Common.init();
CCC.Log.scrollDiv = document.getElementById('scrollDiv');
window.addEventListener('resize', CCC.Log.scrollToBottom, false);
// Lazy-load prettify library.
setTimeout(CCC.Log.importPrettify, 1);
};
/**
* Load the Prettify CSS and JavaScript.
*/
CCC.Log.importPrettify = function() {
// Arbitrary HTML
"}
var dom = CCC.Common.parser.parseFromString(json.htmlText, 'text/html');
if (dom.body) {
var div = document.createElement('div');
CCC.Log.renderHtmltext(div, dom.body);
CCC.Common.autoHyperlink(div);
return div;
}
return undefined; // Illegal HTML.
case 'scene':
//{
// type: "scene",
// requested: true,
// user: "Max",
// where: "Hangout",
// description: "The lights are dim and blah blah blah...",
// svgText: "...",
// contents: [
// {
// type: "user",
// what: "Max",
// svgText: "...",
// cmds: ["look Max", "kick Max"]
// },
// {
// type: "thing",
// what: "clock",
// svgText: "...",
// cmds: ["look clock"]
// }
// ]
//}
if (!json.requested) {
return null; // Do not display this scene update in the log.
}
if (json.user) {
// Record the user name if present.
CCC.Log.userName = json.user;
}
var objects = [];
var users = [];
if (json.contents) {
for (var content of json.contents) {
if (content.type === 'user' && CCC.Log.userName === content.what) {
continue; // Don't show the current user.
}
var df = document.createDocumentFragment();
df.appendChild(document.createTextNode(content.what));
if (content.cmds) {
var icon = CCC.Common.newMenuIcon(content.cmds);
if (icon) {
icon.addEventListener('click', CCC.Common.openMenu);
df.appendChild(icon);
}
}
(content.type === 'user' ? users : objects).push(df);
}
}
var div = document.createElement('div');
if (json.where) {
var titleDiv = document.createElement('div');
titleDiv.className = 'sceneTitle';
titleDiv.appendChild(document.createTextNode(json.where));
div.appendChild(titleDiv);
}
if (json.description) {
var descriptionDiv = CCC.Log.textToHtml(json.description);
CCC.Common.autoHyperlink(descriptionDiv);
div.appendChild(descriptionDiv);
}
if (objects.length) {
var objectsDiv = document.createElement('div');
if (objects.length === 1) {
objectsDiv.appendChild(CCC.Log.getTemplate(
'roomObjectTemplate', objects[0]));
} else if (objects.length > 1) {
objectsDiv.appendChild(CCC.Log.getTemplate(
'roomObjectsTemplate', CCC.Log.naturalList(objects)));
}
div.appendChild(objectsDiv);
}
if (users.length) {
var usersDiv = document.createElement('div');
if (users.length === 1) {
usersDiv.appendChild(CCC.Log.getTemplate(
'roomUserTemplate', users[0]));
} else if (users.length > 1) {
usersDiv.appendChild(CCC.Log.getTemplate(
'roomUsersTemplate', CCC.Log.naturalList(users)));
}
div.appendChild(usersDiv);
}
return div;
case 'say':
// {type: "say", text: "Welcome"}
// {type: "say", source: "Max", where: "Hangout", text: "Hello world."}
// {type: "say", source: "Cat", where: "Hangout", text: "Meow."}
// Fall through.
case 'think':
// {type: "think", text: "Don't be evil."}
// {type: "think", source: "Max", where: "Hangout", text: "I'm hungry."}
// {type: "think", source: "Cat", where: "Hangout", text: "I'm evil."}
var text = CCC.Common.escapeSpaces(json.text);
if (json.type === 'think') {
var type = 'think';
} else {
var lastLetter = text.trim().slice(-1);
var type = (lastLetter === '?') ? 'ask' :
((lastLetter === '!') ? 'exclaim' : 'say');
}
if (json.source && CCC.Log.userName === json.source) {
var fragment = CCC.Log.getTemplate(type + 'SelfTemplate', text);
} else {
var who = json.source || CCC.Log.getTemplate('unknownTemplate');
var fragment = CCC.Log.getTemplate(type + 'Template', who, text);
}
CCC.Common.autoHyperlink(fragment);
var div = document.createElement('div');
div.appendChild(fragment);
return div;
case 'narrate':
// {type: "narrate", text: "Command not recognized."}
// {type: "narrate", where: "Hangout", text: "Hangout is dark."}
// {type: "narrate", source: "Max", where: "Hangout", text: "Max smiles."}
// {type: "narrate", source: "Cat", where: "Hangout", text: "Cat meows."}
var div = document.createElement('div');
var text = json.text;
if (json.source) {
text = json.source + ': ' + text;
}
div.appendChild(document.createTextNode(text));
CCC.Common.autoHyperlink(div);
return div;
case 'link':
// {type: "link", href: "https://example.com/"}
var div = document.createElement('div');
var a = document.createElement('a');
a.href = json.href;
a.target = '_blank';
a.appendChild(document.createTextNode(json.href));
div.appendChild(a);
// Note: this opens the link in a new tab regardless of whether the user
// is in world or log view.
var success = window.open(json.href);
if (!success) {
alert('Your browser has blocked the opening of the page you requested.\n' +
'Please allow pop-ups on this domain. ✓️');
}
return div;
}
// Unknown XML.
return undefined;
};
/**
* Create an icon that links to a page in a new window.
* @param {string} src URL of link to open.
* @return {!Element} DOM element of newly-created link and icon.
*/
CCC.Log.openIcon = function(src) {
//
//
//
//
// Icon artwork sourced from https://icons.googleplex.com/
var link = document.createElement('a');
link.href = src;
link.target = '_blank';
link.rel = 'noopener noreferrer';
var svg = CCC.Common.createSvgElement('svg',
{'class': 'openIcon', 'viewBox': '0 3 24 24'}, link);
CCC.Common.createSvgElement('path',
{'d': 'M19 19H5V5h7V3H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2v-7h-2v7zM14 3v2h3.59l-9.83 9.83 1.41 1.41L19 6.41V10h2V3h-7z'}, svg);
return link;
};
/**
* Create a mostly text-based representation of the provided DOM.
* @param {!Element} div Div element to append content to.
* @param {!Node} node DOM to walk.
*/
CCC.Log.renderHtmltext = function(div, node) {
if (node.nodeType === Node.ELEMENT_NODE) {
// Element.
if (node.tagName === 'svg') { // XML tagNames are lowercase.
return; // No text content of this tag should be rendered.
}
if (node.tagName === 'CMDS') { // HTML tagNames are uppercase.
var icon = CCC.Common.newMenuIcon(node);
if (icon) {
icon.addEventListener('click', CCC.Common.openMenu);
div.appendChild(icon);
}
return;
}
if (node.tagName === 'CMD') { // HTML tagNames are uppercase.
var cmdText = node.innerText;
var a = document.createElement('a');
a.className = 'command';
a.appendChild(document.createTextNode(cmdText));
a.addEventListener('click', CCC.Common.commandFunction, false);
div.appendChild(a);
return;
}
for (var child of node.childNodes) {
CCC.Log.renderHtmltext(div, child);
}
if (CCC.Log.renderHtmltext.BLOCK_NAMES.has(node.tagName)) {
// Add a k||122k||90k||122h[0]&&(h[1]+1>h[0]&&c.push("-"),c.push(f(h[1])));c.push("]");return c.join("")}function v(e){for(var a=e.source.match(/(?:\[(?:[^\x5C\x5D]|\\[\s\S])*\]|\\u[A-Fa-f0-9]{4}|\\x[A-Fa-f0-9]{2}|\\[0-9]+|\\[^ux0-9]|\(\?[:!=]|[\(\)\^]|[^\x5B\x5C\(\)\^]+)/g),c=a.length,d=[],g=0,h=0;g/,null])):d.push(["com",/^#[^\r\n]*/,null,"#"]));a.cStyleComments&&(f.push(["com",/^\/\/[^\r\n]*/,null]),f.push(["com",/^\/\*[\s\S]*?(?:\*\/|$)/,null]));if(b=a.regexLiterals){var v=(b=1|\\/=?|::?|<>?>?=?|,|;|\\?|@|\\[|~|{|\\^\\^?=?|\\|\\|?=?|break|case|continue|delete|do|else|finally|instanceof|return|throw|try|typeof)\\s*("+
("/(?=[^/*"+b+"])(?:[^/\\x5B\\x5C"+b+"]|\\x5C"+v+"|\\x5B(?:[^\\x5C\\x5D"+b+"]|\\x5C"+v+")*(?:\\x5D|$))+/")+")")])}(b=a.types)&&f.push(["typ",b]);b=(""+a.keywords).replace(/^ | $/g,"");b.length&&f.push(["kwd",new RegExp("^(?:"+b.replace(/[\s,]+/g,"|")+")\\b"),null]);d.push(["pln",/^\s+/,null," \r\n\t\u00a0"]);b="^.[^\\s\\w.$@'\"`/\\\\]*";a.regexLiterals&&(b+="(?!s*/)");f.push(["lit",/^@[a-z_$][a-z_$@0-9]*/i,null],["typ",/^(?:[@_]?[A-Z]+[a-z][A-Za-z_$@0-9]*|\w+_t\b)/,null],["pln",/^[a-z_$][a-z_$@0-9]*/i,
null],["lit",/^(?:0x[a-f0-9]+|(?:\d(?:_\d+)*\d*(?:\.\d*)?|\.\d\+)(?:e[+\-]?\d+)?)[a-z]*/i,null,"0123456789"],["pln",/^\\[\s\S]?/,null],["pun",new RegExp(b),null]);return G(d,f)}function L(a,d,f){function b(a){var c=a.nodeType;if(1==c&&!A.test(a.className))if("br"===a.nodeName)v(a),a.parentNode&&a.parentNode.removeChild(a);else for(a=a.firstChild;a;a=a.nextSibling)b(a);else if((3==c||4==c)&&f){var d=a.nodeValue,q=d.match(n);q&&(c=d.substring(0,q.index),a.nodeValue=c,(d=d.substring(q.index+q[0].length))&&
a.parentNode.insertBefore(l.createTextNode(d),a.nextSibling),v(a),c||a.parentNode.removeChild(a))}}function v(a){function b(a,c){var d=c?a.cloneNode(!1):a,k=a.parentNode;if(k){var k=b(k,1),e=a.nextSibling;k.appendChild(d);for(var f=e;f;f=e)e=f.nextSibling,k.appendChild(f)}return d}for(;!a.nextSibling;)if(a=a.parentNode,!a)return;a=b(a.nextSibling,0);for(var d;(d=a.parentNode)&&1===d.nodeType;)a=d;c.push(a)}for(var A=/(?:^|\s)nocode(?:\s|$)/,n=/\r\n?|\n/,l=a.ownerDocument,m=l.createElement("li");a.firstChild;)m.appendChild(a.firstChild);
for(var c=[m],p=0;p=+v[1],d=/\n/g,A=a.a,n=A.length,f=0,l=a.c,m=l.length,b=0,c=a.g,p=c.length,w=0;c[p]=n;var r,e;for(e=r=0;e=h&&(b+=2);f>=k&&(w+=2)}}finally{g&&(g.style.display=a)}}catch(x){E.console&&console.log(x&&x.stack||x)}}var E=window,C=["break,continue,do,else,for,if,return,while"],
F=[[C,"auto,case,char,const,default,double,enum,extern,float,goto,inline,int,long,register,restrict,short,signed,sizeof,static,struct,switch,typedef,union,unsigned,void,volatile"],"catch,class,delete,false,import,new,operator,private,protected,public,this,throw,true,try,typeof"],H=[F,"alignas,alignof,align_union,asm,axiom,bool,concept,concept_map,const_cast,constexpr,decltype,delegate,dynamic_cast,explicit,export,friend,generic,late_check,mutable,namespace,noexcept,noreturn,nullptr,property,reinterpret_cast,static_assert,static_cast,template,typeid,typename,using,virtual,where"],
O=[F,"abstract,assert,boolean,byte,extends,finally,final,implements,import,instanceof,interface,null,native,package,strictfp,super,synchronized,throws,transient"],P=[F,"abstract,add,alias,as,ascending,async,await,base,bool,by,byte,checked,decimal,delegate,descending,dynamic,event,finally,fixed,foreach,from,get,global,group,implicit,in,interface,internal,into,is,join,let,lock,null,object,out,override,orderby,params,partial,readonly,ref,remove,sbyte,sealed,select,set,stackalloc,string,select,uint,ulong,unchecked,unsafe,ushort,value,var,virtual,where,yield"],
F=[F,"abstract,async,await,constructor,debugger,enum,eval,export,function,get,implements,instanceof,interface,let,null,set,undefined,var,with,yield,Infinity,NaN"],Q=[C,"and,as,assert,class,def,del,elif,except,exec,finally,from,global,import,in,is,lambda,nonlocal,not,or,pass,print,raise,try,with,yield,False,True,None"],R=[C,"alias,and,begin,case,class,def,defined,elsif,end,ensure,false,in,module,next,nil,not,or,redo,rescue,retry,self,super,then,true,undef,unless,until,when,yield,BEGIN,END"],C=[C,"case,done,elif,esac,eval,fi,function,in,local,set,then,until"],
S=/^(DIR|FILE|array|vector|(de|priority_)?queue|(forward_)?list|stack|(const_)?(reverse_)?iterator|(unordered_)?(multi)?(set|map)|bitset|u?(int|float)\d*)\b/,W=/\S/,X=y({keywords:[H,P,O,F,"caller,delete,die,do,dump,elsif,eval,exit,foreach,for,goto,if,import,last,local,my,next,no,our,print,package,redo,require,sub,undef,unless,until,use,wantarray,while,BEGIN,END",Q,R,C],hashComments:!0,cStyleComments:!0,multiLineStrings:!0,regexLiterals:!0}),I={};t(X,["default-code"]);t(G([],[["pln",/^[^]*(?:>|$)/],["com",/^<\!--[\s\S]*?(?:-\->|$)/],["lang-",/^<\?([\s\S]+?)(?:\?>|$)/],["lang-",/^<%([\s\S]+?)(?:%>|$)/],["pun",/^(?:<[%?]|[%?]>)/],["lang-",/^]*>([\s\S]+?)<\/xmp\b[^>]*>/i],["lang-js",/^]*>([\s\S]*?)(<\/script\b[^>]*>)/i],["lang-css",/^]*>([\s\S]*?)(<\/style\b[^>]*>)/i],["lang-in.tag",/^(<\/?[a-z][^<>]*>)/i]]),"default-markup htm html mxml xhtml xml xsl".split(" "));t(G([["pln",/^[\s]+/,null," \t\r\n"],["atv",/^(?:\"[^\"]*\"?|\'[^\']*\'?)/,null,
"\"'"]],[["tag",/^^<\/?[a-z](?:[\w.:-]*\w)?|\/?>$/i],["atn",/^(?!style[\s=]|on)[a-z](?:[\w:-]*\w)?/i],["lang-uq.val",/^=\s*([^>\'\"\s]*(?:[^>\'\"\s\/]|\/(?=\s)))/],["pun",/^[=<>\/]+/],["lang-js",/^on\w+\s*=\s*\"([^\"]+)\"/i],["lang-js",/^on\w+\s*=\s*\'([^\']+)\'/i],["lang-js",/^on\w+\s*=\s*([^\"\'>\s]+)/i],["lang-css",/^style\s*=\s*\"([^\"]+)\"/i],["lang-css",/^style\s*=\s*\'([^\']+)\'/i],["lang-css",/^style\s*=\s*([^\"\'>\s]+)/i]]),["in.tag"]);t(G([],[["atv",/^[\s\S]+/]]),["uq.val"]);t(y({keywords:H,
hashComments:!0,cStyleComments:!0,types:S}),"c cc cpp cxx cyc m".split(" "));t(y({keywords:"null,true,false"}),["json"]);t(y({keywords:P,hashComments:!0,cStyleComments:!0,verbatimStrings:!0,types:S}),["cs"]);t(y({keywords:O,cStyleComments:!0}),["java"]);t(y({keywords:C,hashComments:!0,multiLineStrings:!0}),["bash","bsh","csh","sh"]);t(y({keywords:Q,hashComments:!0,multiLineStrings:!0,tripleQuotedStrings:!0}),["cv","py","python"]);t(y({keywords:"caller,delete,die,do,dump,elsif,eval,exit,foreach,for,goto,if,import,last,local,my,next,no,our,print,package,redo,require,sub,undef,unless,until,use,wantarray,while,BEGIN,END",
hashComments:!0,multiLineStrings:!0,regexLiterals:2}),["perl","pl","pm"]);t(y({keywords:R,hashComments:!0,multiLineStrings:!0,regexLiterals:!0}),["rb","ruby"]);t(y({keywords:F,cStyleComments:!0,regexLiterals:!0}),["javascript","js","ts","typescript"]);t(y({keywords:"all,and,by,catch,class,else,extends,false,finally,for,if,in,is,isnt,loop,new,no,not,null,of,off,on,or,return,super,then,throw,true,try,unless,until,when,while,yes",hashComments:3,cStyleComments:!0,multilineStrings:!0,tripleQuotedStrings:!0,
regexLiterals:!0}),["coffee"]);t(G([],[["str",/^[\s\S]+/]]),["regex"]);var Y=E.PR={createSimpleLexer:G,registerLangHandler:t,sourceDecorator:y,PR_ATTRIB_NAME:"atn",PR_ATTRIB_VALUE:"atv",PR_COMMENT:"com",PR_DECLARATION:"dec",PR_KEYWORD:"kwd",PR_LITERAL:"lit",PR_NOCODE:"nocode",PR_PLAIN:"pln",PR_PUNCTUATION:"pun",PR_SOURCE:"src",PR_STRING:"str",PR_TAG:"tag",PR_TYPE:"typ",prettyPrintOne:E.prettyPrintOne=function(a,d,f){f=f||!1;d=d||null;var b=document.createElement("div");b.innerHTML=""+a+" ";
b=b.firstChild;f&&L(b,f,!0);M({j:d,m:f,h:b,l:1,a:null,i:null,c:null,g:null});return b.innerHTML},prettyPrint:E.prettyPrint=function(a,d){function f(){for(var b=E.PR_SHOULD_USE_CONTINUATION?c.now()+250:Infinity;p
Test harness for Code City: Client
Test harness for Code City: Connect
\n <%= response.statusCode %> <%= $.servers.http.STATUS_CODES[response.statusCode] %>\n 
\n Code City\n ![](\"<%=staticUrl%)
logo.svg\" alt=\"\" width=\"47.5\" height=\"50\">\n Code City Browser Mirror\n