├── .gitignore
├── .hgignore
├── LICENSE-MIT-AtomizeJS
├── README.md
├── index.js
├── lib
    ├── atomize.js
    ├── compat.js
    ├── javascript.pegjs
    ├── javascript_parser.js
    ├── prettyprinter_test.js
    ├── transform.js
    └── walker.js
└── package.json


/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | *~
3 | 


--------------------------------------------------------------------------------
/.hgignore:
--------------------------------------------------------------------------------
1 | ~$
2 | ^node_modules/
3 | 


--------------------------------------------------------------------------------
/LICENSE-MIT-AtomizeJS:
--------------------------------------------------------------------------------
 1 | Copyright (C) 2011-2012 VMware, Inc.
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining a copy
 4 | of this software and associated documentation files (the "Software"), to deal
 5 | in the Software without restriction, including without limitation the rights
 6 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 7 | copies of the Software, and to permit persons to whom the Software is
 8 | furnished to do so, subject to the following conditions:
 9 | 
10 | The above copyright notice and this permission notice shall be included in
11 | all copies or substantial portions of the Software.
12 | 
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19 | THE SOFTWARE.
20 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Atomize-client
 2 | 
 3 | This is the client library for the Atomize DSTM JavaScript project.
 4 | 
 5 | This library can be used either client-side or in NodeJS. It is
 6 | required when running Atomize-node.
 7 | 
 8 | When running in Node, an `npm install atomize-client` will work. When
 9 | running client side, you'll need to `<script>`-include both
10 | [`cereal.js`](https://github.com/atomizejs/cereal/blob/master/lib/cereal.js)
11 | and
12 | [`atomize.js`](https://github.com/atomizejs/atomize-client/blob/master/lib/atomize.js).
13 | 
14 | Please see the main [AtomizeJS site](http://atomizejs.github.com/).


--------------------------------------------------------------------------------
/index.js:
--------------------------------------------------------------------------------
1 | module.exports = require('./lib/atomize');
2 | 


--------------------------------------------------------------------------------
/lib/atomize.js:
--------------------------------------------------------------------------------
   1 | /*global WeakMap, Map, Proxy, SockJS, Cereal, exports, require */
   2 | /*jslint browser: true, devel: true */
   3 | 
   4 | var Atomize;
   5 | 
   6 | function NotATVarException() {}
   7 | NotATVarException.prototype = {
   8 |     prototype: Error.prototype,
   9 |     constructor: NotATVarException,
  10 |     toString: function () {return "Not A TVar";}
  11 | };
  12 | 
  13 | function WriteOutsideTransactionException() {}
  14 | WriteOutsideTransactionException.prototype = {
  15 |     prototype: Error.prototype,
  16 |     constructor: WriteOutsideTransactionException,
  17 |     toString: function () {return "Write outside transaction";}
  18 | };
  19 | 
  20 | function DeleteOutsideTransactionException() {}
  21 | DeleteOutsideTransactionException.prototype = {
  22 |     prototype: Error.prototype,
  23 |     constructor: DeleteOutsideTransactionException,
  24 |     toString: function () {return "Delete outside transaction";}
  25 | };
  26 | 
  27 | function RetryOutsideTransactionException() {}
  28 | RetryOutsideTransactionException.prototype = {
  29 |     prototype: Error.prototype,
  30 |     constructor: RetryOutsideTransactionException,
  31 |     toString: function () {return "Retry outside transaction";}
  32 | };
  33 | 
  34 | function InternalException() {}
  35 | InternalException.prototype = {
  36 |     prototype: Error.prototype,
  37 |     constructor: InternalException,
  38 |     toString: function () {return "Internal Exception";}
  39 | };
  40 | 
  41 | function UnpopulatedException(tvar) { this.tvar = tvar; }
  42 | UnpopulatedException.prototype = {
  43 |     prototype: Error.prototype,
  44 |     constructor: UnpopulatedException,
  45 |     toString: function () {return "Use of unpopulated tvar: " + this.tvar.id;}
  46 | };
  47 | 
  48 | function AccessorDescriptorsNotSupportedException(desc) { this.desc = desc; }
  49 | AccessorDescriptorsNotSupportedException.prototype = {
  50 |     prototype: Error.prototype,
  51 |     constructor: AccessorDescriptorsNotSupportedException,
  52 |     toString: function () {
  53 |         return "Accessor Descriptors Not Supported: " +
  54 |             JSON.stringify(this.desc);
  55 |     }
  56 | };
  57 | 
  58 | function InvalidDescriptorException(desc) { this.desc = desc; }
  59 | InvalidDescriptorException.prototype = {
  60 |     prototype: Error.prototype,
  61 |     constructor: InvalidDescriptorException,
  62 |     toString: function () {
  63 |         return "Invalid Descriptor: " + JSON.stringify(this.desc);
  64 |     }
  65 | };
  66 | 
  67 | 
  68 | (function (window) {
  69 |     'use strict';
  70 | 
  71 |     var util, STM, Cereal, events;
  72 | 
  73 |     if (typeof exports !== "undefined") {
  74 |         Cereal = require('cereal');
  75 |         events = require('events');
  76 | 
  77 |     } else {
  78 |         Cereal = window.Cereal;
  79 | 
  80 |         if (typeof Cereal === "undefined") {
  81 |             console.error("Please load the cereal.js script before the atomize.js script.");
  82 |             return;
  83 |         }
  84 |     }
  85 | 
  86 |     util = (function () {
  87 |         var result, i, name, names;
  88 | 
  89 |         result = {};
  90 |         names = ['defineProperty', 'getPropertyDescriptor',
  91 |                  'getPropertyNames', 'getOwnPropertyDescriptor',
  92 |                  'getOwnPropertyNames', 'keys', 'hasOwnProperty'];
  93 | 
  94 |         for (i = 0; i < names.length; i += 1) {
  95 |             name = names[i];
  96 |             if (undefined !== Object[name]) {
  97 |                 if (undefined === Object[name]._origFun) {
  98 |                     result[name] = Object[name];
  99 |                 } else {
 100 |                     result[name] = Object[name]._origFun;
 101 |                 }
 102 |             }
 103 |         }
 104 | 
 105 |         result.isPrimitive = function (obj) {
 106 |             return obj !== Object(obj);
 107 |         };
 108 | 
 109 |         result.hasOwnProp = result.hasOwnProperty;
 110 | 
 111 |         result.shallowCopy = function (src, dest) {
 112 |             var keys, i;
 113 |             keys = result.keys(src);
 114 |             for (i = 0; i < keys.length; i += 1) {
 115 |                 dest[keys[i]] = src[keys[i]];
 116 |             }
 117 |         };
 118 | 
 119 |         result.lift = function (src, dest, fields) {
 120 |             var i;
 121 |             for (i = 0; i < fields.length; i += 1) {
 122 |                 dest[fields[i]] = src[fields[i]].bind(src);
 123 |             }
 124 |         };
 125 | 
 126 |         (function () {
 127 |             var nextId = 0, MyMap;
 128 |             if (typeof Map === "undefined") {
 129 |                 if (typeof WeakMap === "undefined") {
 130 |                     MyMap = function () {
 131 |                         this.objs = {};
 132 |                         this.prims = {};
 133 |                     };
 134 |                     MyMap.prototype = {
 135 |                         id: function () {
 136 |                             nextId += 1;
 137 |                             return nextId;
 138 |                         },
 139 | 
 140 |                         set: function (key, value) {
 141 |                             if (result.isPrimitive(key)) {
 142 |                                 this.prims[key] = value;
 143 |                             } else {
 144 |                                 if (! result.hasOwnProp.call(key, '_map')) {
 145 |                                     result.defineProperty(
 146 |                                         key, '_map',
 147 |                                         {value: this.id(),
 148 |                                          writable: true,
 149 |                                          configurable: false,
 150 |                                          enumerable: false});
 151 |                                 }
 152 |                                 this.objs[key._map] = value;
 153 |                             }
 154 |                         },
 155 | 
 156 |                         get: function (key) {
 157 |                             if (result.isPrimitive(key)) {
 158 |                                 return this.prims[key];
 159 |                             } else {
 160 |                                 if (result.hasOwnProp.call(key, '_map')) {
 161 |                                     return this.objs[key._map];
 162 |                                 } else {
 163 |                                     return undefined;
 164 |                                 }
 165 |                             }
 166 |                         },
 167 | 
 168 |                         has: function (key) {
 169 |                             if (result.isPrimitive(key)) {
 170 |                                 return result.hasOwnProp.call(this.prims, key);
 171 |                             } else {
 172 |                                 return (result.hasOwnProp.call(key, '_map') &&
 173 |                                         result.hasOwnProp.call(this.objs, key._map));
 174 |                             }
 175 |                         }
 176 |                     };
 177 |                 } else {
 178 |                     MyMap = WeakMap;
 179 |                 }
 180 |             } else {
 181 |                 MyMap = Map;
 182 |             }
 183 |             result.Map = MyMap;
 184 |         }());
 185 | 
 186 |         return result;
 187 |     }());
 188 | 
 189 |     (function () {
 190 | 
 191 |         function TVar(id, obj, stm) {
 192 |             this.id = id;
 193 |             this.raw = obj;
 194 |             this.isArray = Array === obj.constructor;
 195 |             this.stm = stm;
 196 |             this.version = 0;
 197 |             this.handler = this.objHandlerMaker();
 198 |             this.proxied = this.createProxy(this.handler, Object.getPrototypeOf(obj));
 199 |         }
 200 | 
 201 |         TVar.prototype = {
 202 |             unpopulated: false,
 203 | 
 204 |             hasNativeProxy: "undefined" !== typeof Proxy,
 205 | 
 206 |             log: function () {
 207 |                 var args;
 208 |                 if (this.stm.isLogging) {
 209 |                     args = Array.prototype.slice.call(arguments, 0);
 210 |                     args.unshift("[TVar " + this.id + "]");
 211 |                     this.stm.log.apply(this.stm, args);
 212 |                 }
 213 |             },
 214 | 
 215 |             clone: function (obj) {
 216 |                 // provided the .proxy is different from the .raw then
 217 |                 // we're ok. But in a few places we also need to make
 218 |                 // sure the prototype of the .proxy matches the
 219 |                 // prototype of the .raw (in order to correctly walk
 220 |                 // down the prototype chain), hence this method.
 221 |                 var result, keys, i, ctr = function () {};
 222 |                 ctr.prototype = Object.getPrototypeOf(obj);
 223 |                 result = new ctr();
 224 |                 util.shallowCopy(obj, result);
 225 |                 return result;
 226 |             },
 227 | 
 228 |             createProxy: function (handler, proto) {
 229 |                 if (this.hasNativeProxy) {
 230 |                     return Proxy.create(handler, proto);
 231 |                 } else {
 232 |                     return this.clone(this.raw);
 233 |                 }
 234 |             },
 235 | 
 236 |             objHandlerMaker: function () {
 237 |                 var self, stm, handler;
 238 | 
 239 |                 self = this;
 240 |                 stm = self.stm;
 241 | 
 242 |                 handler = {
 243 | 
 244 |                     getOwnPropertyDescriptor: function (name) {
 245 |                         self.log("getOwnPropertyDescriptor:", name);
 246 |                         if ("_map" !== name) {
 247 |                             stm.recordRead(self);
 248 |                         }
 249 |                         var desc, value;
 250 |                         if ("_map" === name || ! stm.inTransaction()) {
 251 |                             desc = util.getOwnPropertyDescriptor(self.raw, name);
 252 |                         } else if (stm.transactionFrame.isDeleted(self, name)) {
 253 |                             return undefined;
 254 |                         } else {
 255 |                             desc = stm.transactionFrame.get(self, name);
 256 |                             if (undefined === desc) {
 257 |                                 desc = util.getOwnPropertyDescriptor(self.raw, name);
 258 |                                 if (undefined !== desc &&
 259 |                                     ! (undefined === desc.value ||
 260 |                                        util.isPrimitive(desc.value) ||
 261 |                                        'function' === typeof desc.value)) {
 262 |                                     value = stm.ensureTVar(desc.value).proxied;
 263 |                                     if (desc.value !== value) {
 264 |                                         // rewrite our local graph to use the proxied version
 265 |                                         self.log("Implicity lifting");
 266 |                                         desc.value = value;
 267 |                                         stm.transactionFrame.recordDefine(self, name, desc);
 268 |                                     }
 269 |                                 }
 270 |                             }
 271 |                         }
 272 |                         if (undefined !== desc &&
 273 |                             util.hasOwnProp.call(desc, 'configurable')) {
 274 |                             desc.configurable = true; // should go away with direct proxies
 275 |                         }
 276 |                         return desc;
 277 |                     },
 278 | 
 279 |                     getPropertyDescriptor: function (name) {
 280 |                         self.log("getPropertyDescriptor:", name);
 281 |                         if ("_map" !== name) {
 282 |                             stm.recordRead(self);
 283 |                         }
 284 |                         var visited = [], tvar = self, obj = tvar.proxied, desc;
 285 |                         while (obj !== undefined && obj !== null) {
 286 |                             tvar = stm.ensureTVar(obj);
 287 |                             if (-1 !== visited.lastIndexOf(tvar)) {
 288 |                                 break;
 289 |                             }
 290 |                             obj = tvar.proxied;
 291 |                             desc = tvar.handler.getOwnPropertyDescriptor(name);
 292 |                             if (undefined === desc) {
 293 |                                 visited.push(tvar);
 294 |                                 obj = Object.getPrototypeOf(obj);
 295 |                             } else {
 296 |                                 return desc;
 297 |                             }
 298 |                         }
 299 |                         return undefined;
 300 |                     },
 301 | 
 302 |                     getOwnPropertyNames: function () {
 303 |                         self.log("getOwnPropertyNames");
 304 |                         stm.recordRead(self);
 305 |                         var names, result, i;
 306 |                         if (stm.inTransaction()) {
 307 |                             result = {};
 308 |                             // names here won't contain any names that have been deleted...
 309 |                             names = stm.transactionFrame.getOwnPropertyNames(self);
 310 |                             for (i = 0; i < names.length; i += 1) {
 311 |                                 result[names[i]] = true;
 312 |                             }
 313 |                             // ...but here, these names may have been deleted in the txn.
 314 |                             names = util.getOwnPropertyNames(self.raw);
 315 |                             for (i = 0; i < names.length; i += 1) {
 316 |                                 if (! stm.transactionFrame.isDeleted(self, names[i])) {
 317 |                                     result[names[i]] = true;
 318 |                                 }
 319 |                             }
 320 |                             return util.keys(result);
 321 |                         } else {
 322 |                             return util.getOwnPropertyNames(self.raw);
 323 |                         }
 324 |                     },
 325 | 
 326 |                     getPropertyNames: function () {
 327 |                         self.log("getPropertyNames");
 328 |                         stm.recordRead(self);
 329 |                         var seen = {}, visited = [], tvar = self, obj = tvar.proxied, names, i;
 330 |                         // the final Object.prototype !== obj is probably a bug in chrome/v8:
 331 |                         // http://code.google.com/p/v8/issues/detail?id=2145
 332 |                         while (obj !== undefined && obj !== null && Object.prototype !== obj) {
 333 |                             tvar = stm.ensureTVar(obj);
 334 |                             if (-1 !== visited.lastIndexOf(tvar)) {
 335 |                                 break;
 336 |                             }
 337 |                             obj = tvar.proxied;
 338 |                             names = tvar.handler.getOwnPropertyNames();
 339 |                             for (i = 0; i < names.length; i += 1) {
 340 |                                 if (! util.hasOwnProp.call(seen, names[i])) {
 341 |                                     seen[names[i]] = true;
 342 |                                 }
 343 |                             }
 344 |                             visited.push(tvar);
 345 |                             obj = Object.getPrototypeOf(obj);
 346 |                         }
 347 |                         return util.keys(seen);
 348 |                     },
 349 | 
 350 |                     defineProperty: function (name, desc) {
 351 |                         var current, match, key, merged;
 352 |                         self.log("defineProperty:", name);
 353 |                         if ("_map" === name) {
 354 |                             return util.defineProperty(self.raw, name, desc);
 355 |                         }
 356 |                         if (stm.inTransaction()) {
 357 |                             if (util.hasOwnProp.call(desc, 'get') ||
 358 |                                 util.hasOwnProp.call(desc, 'set')) {
 359 |                                 throw new AccessorDescriptorsNotSupportedException(desc);
 360 |                             } else {
 361 |                                 if ('value' in desc &&
 362 |                                     (!util.isPrimitive(desc.value)) &&
 363 |                                     (!stm.isProxied(desc.value))) {
 364 |                                     // the value is not a tvar, explode
 365 |                                     throw new NotATVarException(desc.value);
 366 |                                 }
 367 |                                 current = handler.getOwnPropertyDescriptor(name);
 368 |                                 if (undefined === current) {
 369 |                                     if (Object.isExtensible(self.proxied)) {
 370 |                                         // fill in the default values
 371 |                                         desc.writable = desc.writable || false;
 372 |                                         desc.enumerable = desc.enumerable || false;
 373 |                                         desc.configurable = desc.configurable || false;
 374 |                                         desc.value = 'value' in desc ? desc.value : undefined;
 375 |                                         stm.transactionFrame.recordDefine(self, name, desc);
 376 |                                         return self.proxied;
 377 |                                     } else {
 378 |                                         throw new InvalidDescriptorException(desc);
 379 |                                     }
 380 |                                 }
 381 |                                 match = true;
 382 |                                 for (key in desc) {
 383 |                                     if (desc[key] !== current[key]) {
 384 |                                         match = false;
 385 |                                         break;
 386 |                                     }
 387 |                                 }
 388 |                                 if (match) {
 389 |                                     return self.proxied;
 390 |                                 }
 391 |                                 if ((! current.configurable) &&
 392 |                                     (desc.configurable ||
 393 |                                      ('enumerable' in desc && desc.enumerable !== current.enumerable))) {
 394 |                                     throw new InvalidDescriptorException(desc);
 395 |                                 }
 396 |                                 merged = {};
 397 |                                 util.shallowCopy(current, merged);
 398 |                                 util.shallowCopy(desc, merged);
 399 |                                 // merged should now have no missing fields
 400 |                                 if (! ('value' in desc)) {
 401 |                                     // desc is a GenericDescriptor. Nothing further to do.
 402 |                                     stm.transactionFrame.recordDefine(self, name, merged);
 403 |                                     return self.proxied;
 404 |                                 }
 405 |                                 // From here on, desc must be DataDescriptor
 406 |                                 if ('value' in current) {
 407 |                                     // current is DataDescriptor too
 408 |                                     if ((! current.configurable) &&
 409 |                                         (! current.writable) &&
 410 |                                         (desc.writable || desc.value !== current.value)) {
 411 |                                         throw new InvalidDescriptorException(desc);
 412 |                                     }
 413 |                                     stm.transactionFrame.recordDefine(self, name, merged);
 414 |                                     return self.proxied;
 415 |                                 } else {
 416 |                                     // Current is Accessor; but we're converting to DataDescriptor
 417 |                                     if (current.configurable) {
 418 |                                         desc.writable = desc.writable || false;
 419 |                                         stm.transactionFrame.recordDefine(self, name, merged);
 420 |                                         return self.proxied;
 421 |                                     } else {
 422 |                                         throw new InvalidDescriptorException(desc);
 423 |                                     }
 424 |                                 }
 425 |                             }
 426 |                         } else {
 427 |                             throw new WriteOutsideTransactionException();
 428 |                         }
 429 |                     },
 430 | 
 431 |                     erase: function (name) {
 432 |                         self.log("delete:", name);
 433 |                         var desc;
 434 |                         if ("_map" === name) {
 435 |                             return delete self.raw[name];
 436 |                         } else if (stm.inTransaction()) {
 437 |                             desc = handler.getOwnPropertyDescriptor(name);
 438 |                             if (undefined === desc) {
 439 |                                 return true;
 440 |                             } else if (desc.configurable) {
 441 |                                 // Just like in set: we don't do the delete here
 442 |                                 stm.transactionFrame.recordDelete(self, name);
 443 |                                 return true;
 444 |                             } else {
 445 |                                 return false;
 446 |                             }
 447 |                         } else {
 448 |                             throw new DeleteOutsideTransactionException();
 449 |                         }
 450 |                     },
 451 | 
 452 |                     fix: function () {
 453 |                         // TODO - make transaction aware. Somehow. Might not be possible...
 454 |                         self.log("*** fix ***");
 455 |                         if (Object.isFrozen(self.raw)) {
 456 |                             var result = {};
 457 |                             util.getOwnPropertyNames(self.raw).forEach(function (name) {
 458 |                                 result[name] = util.getOwnPropertyDescriptor(self.raw, name);
 459 |                             });
 460 |                             return result;
 461 |                         }
 462 |                         // As long as obj is not frozen, the proxy won't allow
 463 |                         // itself to be fixed
 464 |                         return undefined; // will cause a TypeError to be thrown
 465 |                     },
 466 | 
 467 |                     has: function (name) {
 468 |                         self.log("has:", name);
 469 |                         var desc;
 470 |                         if ("_map" !== name) {
 471 |                             stm.recordRead(self);
 472 |                         }
 473 |                         if ("_map" === name || ! stm.inTransaction()) {
 474 |                             return !!handler.getPropertyDescriptor(name);
 475 |                         } else if (stm.transactionFrame.isDeleted(self, name)) {
 476 |                             return false;
 477 |                         } else {
 478 |                             desc = stm.transactionFrame.get(self, name);
 479 |                             if (undefined === desc) {
 480 |                                 return !!handler.getPropertyDescriptor(name);
 481 |                             } else {
 482 |                                 return true;
 483 |                             }
 484 |                         }
 485 |                     },
 486 | 
 487 |                     hasOwn: function (name) {
 488 |                         self.log("hasOwn:", name);
 489 |                         var desc;
 490 |                         if ("_map" !== name) {
 491 |                             stm.recordRead(self);
 492 |                         }
 493 |                         if ("_map" === name || ! stm.inTransaction()) {
 494 |                             return !!handler.getOwnPropertyDescriptor(name);
 495 |                         } else if (stm.transactionFrame.isDeleted(self, name)) {
 496 |                             return false;
 497 |                         } else {
 498 |                             desc = stm.transactionFrame.get(self, name);
 499 |                             if (undefined === desc) {
 500 |                                 return !!handler.getOwnPropertyDescriptor(name);
 501 |                             } else {
 502 |                                 return true;
 503 |                             }
 504 |                         }
 505 |                     },
 506 | 
 507 |                     get: function (receiver, name) {
 508 |                         self.log("get:", name);
 509 |                         var desc;
 510 |                         if ("_map" !== name) {
 511 |                             stm.recordRead(self);
 512 |                         }
 513 |                         if ("_map" === name || ! stm.inTransaction()) {
 514 |                             return self.raw[name];
 515 |                         } else if (stm.transactionFrame.isDeleted(self, name)) {
 516 |                             self.log("...has been deleted");
 517 |                             return undefined;
 518 |                         } else {
 519 |                             desc = stm.transactionFrame.get(self, name);
 520 |                             if (undefined === desc) {
 521 |                                 desc = handler.getPropertyDescriptor(name);
 522 |                                 if (undefined === desc) {
 523 |                                     self.log("...not found");
 524 |                                     return undefined;
 525 |                                 } else if ('value' in desc) {
 526 |                                     self.log("...found.");
 527 |                                     return desc.value;
 528 |                                 } else if ('get' in desc && undefined !== desc.get) {
 529 |                                     return desc.get.call(self.proxied);
 530 |                                 } else {
 531 |                                     return undefined;
 532 |                                 }
 533 |                             } else {
 534 |                                 self.log("...found in txn log");
 535 |                                 return desc.value;
 536 |                             }
 537 |                         }
 538 |                     },
 539 | 
 540 |                     set: function (receiver, name, val) {
 541 |                         var desc, setter;
 542 |                         self.log("set:", name);
 543 |                         if ("_map" === name) {
 544 |                             self.raw[name] = val;
 545 |                             return true;
 546 |                         }
 547 |                         if (stm.inTransaction()) {
 548 |                             if (undefined === val ||
 549 |                                 util.isPrimitive(val) ||
 550 |                                 stm.isProxied(val)) {
 551 |                                 // Note at no point do we do the real write here
 552 |                                 desc = handler.getOwnPropertyDescriptor(name);
 553 |                                 if (desc) {
 554 |                                     if ('writable' in desc) {
 555 |                                         if (desc.writable) {
 556 |                                             stm.transactionFrame.recordWrite(self, name, val);
 557 |                                             return true;
 558 |                                         } else {
 559 |                                             return false;
 560 |                                         }
 561 |                                     } else { // accessor
 562 |                                         setter = desc.set;
 563 |                                         if (setter) {
 564 |                                             // we assume the setter is
 565 |                                             // set up for use with atomize
 566 |                                             setter.call(receiver, val);
 567 |                                             return true;
 568 |                                         } else {
 569 |                                             return false;
 570 |                                         }
 571 |                                     }
 572 |                                 } else {
 573 |                                     // ok, we don't have it on us, but what about prototypes?
 574 |                                     desc = handler.getPropertyDescriptor(name);
 575 |                                     if (desc) {
 576 |                                         if ('writable' in desc) {
 577 |                                             if (desc.writable) { // fall through
 578 |                                             } else {
 579 |                                                 return false;
 580 |                                             }
 581 |                                         } else { // accessor
 582 |                                             setter = desc.set;
 583 |                                             if (setter) {
 584 |                                                 // we assume the setter is
 585 |                                                 // set up for use with atomize
 586 |                                                 setter.call(receiver, val);
 587 |                                                 return true;
 588 |                                             } else {
 589 |                                                 return false;
 590 |                                             }
 591 |                                         }
 592 |                                     }
 593 |                                     if (!Object.isExtensible(receiver)) {
 594 |                                         return false;
 595 |                                     } else {
 596 |                                         stm.transactionFrame.recordWrite(self, name, val);
 597 |                                         return true;
 598 |                                     }
 599 |                                 }
 600 |                             } else {
 601 |                                 // it's not a tvar, explode
 602 |                                 throw new NotATVarException();
 603 |                             }
 604 |                         } else {
 605 |                             throw new WriteOutsideTransactionException();
 606 |                         }
 607 |                     }, // bad behavior when set fails in non-strict mode
 608 | 
 609 |                     enumerate: function () {
 610 |                         self.log("enumerate");
 611 |                         var result = [], keys, i, name, desc;
 612 |                         stm.recordRead(self);
 613 |                         keys = handler.getPropertyNames();
 614 |                         for (i = 0; i < keys.length; i += 1) {
 615 |                             name = keys[i];
 616 |                             desc = handler.getPropertyDescriptor(name);
 617 |                             if (undefined !== desc && desc.enumerable) {
 618 |                                 result.push(name);
 619 |                             }
 620 |                         }
 621 |                         return result;
 622 |                     },
 623 | 
 624 |                     keys: function () {
 625 |                         self.log("keys");
 626 |                         var result = [], keys, i, name, desc;
 627 |                         stm.recordRead(self);
 628 |                         keys = handler.getOwnPropertyNames();
 629 |                         for (i = 0; i < keys.length; i += 1) {
 630 |                             name = keys[i];
 631 |                             desc = handler.getOwnPropertyDescriptor(name);
 632 |                             if (undefined !== desc && desc.enumerable) {
 633 |                                 result.push(name);
 634 |                             }
 635 |                         }
 636 |                         return result;
 637 |                     }
 638 |                 };
 639 | 
 640 |                 // disgusting hack to get around fact IE won't parse
 641 |                 // JS if it sees 'delete' as a field.
 642 |                 handler['delete'] = handler['erase'];
 643 | 
 644 |                 return handler;
 645 |             }
 646 |         };
 647 | 
 648 | 
 649 |         function Transaction(stm, id, parent, funs, cont, abort) {
 650 |             this.stm = stm;
 651 |             this.id = id;
 652 |             this.funs = funs;
 653 |             this.funIndex = 0;
 654 |             if (undefined !== cont && undefined !== cont.call) {
 655 |                 this.cont = cont;
 656 |             }
 657 |             if (undefined !== abort && undefined !== abort.call) {
 658 |                 this.abort = abort;
 659 |             }
 660 |             if (undefined !== parent) {
 661 |                 this.parent = parent;
 662 |             }
 663 | 
 664 |             this.read = {};
 665 |             this.created = {};
 666 |             this.written = {};
 667 | 
 668 |             this.readStack = [];
 669 | 
 670 |             this.suspended = true;
 671 |         }
 672 | 
 673 |         Transaction.prototype = {
 674 |             retryException: {
 675 |                 toString: function () { return "Internal Retry Exception"; }
 676 |             },
 677 |             deleted: {
 678 |                 toString: function () { return "Deleted Object"; }
 679 |             },
 680 | 
 681 |             log: function () {
 682 |                 var args;
 683 |                 if (this.stm.isLogging) {
 684 |                     args = Array.prototype.slice.call(arguments, 0);
 685 |                     args.unshift("[Txn " + this.id + "]");
 686 |                     this.stm.log.apply(this.stm, args);
 687 |                 }
 688 |             },
 689 | 
 690 |             reset: function (createds) {
 691 |                 if (0 === this.funIndex) {
 692 |                     this.readStack = [];
 693 |                 } else if (util.keys(this.read).length !== 0) {
 694 |                     this.readStack.push(this.read);
 695 |                 }
 696 |                 this.read = {};
 697 |                 this.written = {};
 698 |                 if (createds) {
 699 |                     this.created = {};
 700 |                 }
 701 |             },
 702 | 
 703 |             recordRead: function (parent) {
 704 |                 this.read[parent.id] = parent.version;
 705 |                 if (parent.unpopulated) {
 706 |                     throw new UnpopulatedException(parent);
 707 |                 }
 708 |             },
 709 | 
 710 |             recordCreation: function (value, meta) {
 711 |                 this.created[value.id] = {value: value,
 712 |                                           meta: meta};
 713 |             },
 714 | 
 715 |             recordDelete: function (parent, name) {
 716 |                 this.recordDefine(parent, name, this.deleted);
 717 |             },
 718 | 
 719 |             recordWrite: function (parent, name, value) {
 720 |                 var desc = Object.getOwnPropertyDescriptor(parent.proxied, name);
 721 |                 if (undefined === desc) {
 722 |                     desc = {value        : value,
 723 |                             enumerable   : true,
 724 |                             configurable : true,
 725 |                             writable     : true};
 726 |                 } else {
 727 |                     desc.value = value;
 728 |                 }
 729 | 
 730 |                 this.recordDefine(parent, name, desc);
 731 |             },
 732 | 
 733 |             recordDefine: function (parent, name, descriptor) {
 734 |                 if (this.deleted !== descriptor) {
 735 |                     if (util.hasOwnProp.call(descriptor, 'get') ||
 736 |                         util.hasOwnProp.call(descriptor, 'set')) {
 737 |                         throw new AccessorDescriptorsNotSupportedException(descriptor);
 738 |                     }
 739 |                 }
 740 |                 if (! util.hasOwnProp.call(this.written, parent.id)) {
 741 |                     this.written[parent.id] = {tvar     : parent,
 742 |                                                children : {}};
 743 |                 }
 744 |                 // this could get messy - name could be 'constructor', for
 745 |                 // example.
 746 |                 this.written[parent.id].children[name] = descriptor;
 747 |             },
 748 | 
 749 |             get: function (parent, name) {
 750 |                 if (util.hasOwnProp.call(this.written, parent.id) &&
 751 |                     util.hasOwnProp.call(this.written[parent.id].children, name)) {
 752 |                     if (this.deleted === this.written[parent.id].children[name]) {
 753 |                         return undefined;
 754 |                     } else {
 755 |                         return this.written[parent.id].children[name];
 756 |                     }
 757 |                 }
 758 |                 if (util.hasOwnProp.call(this, 'parent')) {
 759 |                     return this.parent.get(parent, name);
 760 |                 } else {
 761 |                     return undefined;
 762 |                 }
 763 |             },
 764 | 
 765 |             isDeleted: function (parent, name) {
 766 |                 if (util.hasOwnProp.call(this.written, parent.id) &&
 767 |                     util.hasOwnProp.call(this.written[parent.id].children, name)) {
 768 |                     return this.deleted === this.written[parent.id].children[name];
 769 |                 }
 770 |                 if (util.hasOwnProp.call(this, 'parent')) {
 771 |                     return this.parent.isDeleted(parent, name);
 772 |                 } else {
 773 |                     return false;
 774 |                 }
 775 |             },
 776 | 
 777 |             keys: function (parent, predicate) {
 778 |                 var result, worklist, seen, obj, vars, keys, i;
 779 |                 result = [];
 780 |                 worklist = [];
 781 |                 seen = {};
 782 | 
 783 |                 if (undefined === predicate) {
 784 |                     predicate = function (obj, key) {
 785 |                         return obj[key].enumerable;
 786 |                     };
 787 |                 }
 788 | 
 789 |                 obj = this;
 790 |                 while (undefined !== obj) {
 791 |                     if (util.hasOwnProp.call(obj.written, parent.id)) {
 792 |                         worklist.push(obj.written[parent.id].children);
 793 |                     }
 794 |                     obj = obj.parent;
 795 |                 }
 796 |                 // use shift not pop to ensure we start at the child
 797 |                 // txn. Thus child txn 'delete' prevents parent
 798 |                 // 'write' of same var from showing up, as 'seen' will
 799 |                 // record the former and filter out the latter.
 800 |                 while (0 < worklist.length) {
 801 |                     vars = worklist.shift();
 802 |                     keys = util.keys(vars);
 803 |                     for (i = 0; i < keys.length; i += 1) {
 804 |                         if (! util.hasOwnProp.call(seen, keys[i])) {
 805 |                             seen[keys[i]] = true;
 806 |                             if ((this.deleted !== vars[keys[i]]) && predicate(vars, keys[i])) {
 807 |                                 result.push(keys[i]);
 808 |                             }
 809 |                         }
 810 |                     }
 811 |                 }
 812 |                 return result;
 813 |             },
 814 | 
 815 |             getOwnPropertyNames: function (parent) {
 816 |                 return this.keys(parent, function (obj, key) { return true; });
 817 |             },
 818 | 
 819 |             run: function () {
 820 |                 if (util.hasOwnProp.call(this.stm, 'transactionFrame') &&
 821 |                     this.parent !== this.stm.transactionFrame &&
 822 |                     this !== this.stm.transactionFrame) {
 823 |                     throw new InternalException();
 824 |                 }
 825 |                 this.suspended = false;
 826 |                 this.funIndex = 0;
 827 |                 this.stm.transactionFrame = this;
 828 |                 while (! this.suspended) {
 829 |                     try {
 830 |                         return this.commit(this.funs[this.funIndex]());
 831 |                     } catch (err) {
 832 |                         if ((! util.isPrimitive(err)) &&
 833 |                             (UnpopulatedException.prototype ===
 834 |                              Object.getPrototypeOf(err))) {
 835 |                             // if we're in an orElse, we need to
 836 |                             // pretend that we hit a retry in every
 837 |                             // branch, so that we actually do the
 838 |                             // server-side retry
 839 |                             this.funIndex = 0;
 840 |                             err = this.retryException;
 841 |                         }
 842 |                         if (err === this.retryException) {
 843 |                             this.maybeSendRetry();
 844 |                         } else {
 845 |                             if (util.hasOwnProp.call(this, 'parent')) {
 846 |                                 this.stm.transactionFrame = this.parent;
 847 |                             } else {
 848 |                                 delete this.stm.transactionFrame;
 849 |                             }
 850 |                             throw err;
 851 |                         }
 852 |                     }
 853 |                 }
 854 |             },
 855 | 
 856 |             bumpCreated: function () {
 857 |                 var keys = util.keys(this.created).sort(),
 858 |                     i, obj;
 859 |                 for (i = 0; i < keys.length; i += 1) {
 860 |                     obj = this.created[keys[i]].value;
 861 |                     if (obj.version === 0) {
 862 |                         obj.version = 1;
 863 |                     }
 864 |                 }
 865 |             },
 866 | 
 867 |             copyToParent: function (written) {
 868 |                 var worklist, obj, keys, i, key;
 869 |                 worklist = [this.read].concat(this.readStack);
 870 |                 while (worklist.length !== 0) {
 871 |                     obj = worklist.shift();
 872 |                     keys = util.keys(obj);
 873 |                     for (i = 0; i < keys.length; i += 1) {
 874 |                         key = keys[i];
 875 |                         this.parent.read[key] = obj[key];
 876 |                     }
 877 |                 }
 878 | 
 879 |                 keys = util.keys(this.created);
 880 |                 for (i = 0; i < keys.length; i += 1) {
 881 |                     key = keys[i];
 882 |                     this.parent.created[key] = this.created[key];
 883 |                 }
 884 | 
 885 |                 if (written) {
 886 |                     keys = util.keys(this.written);
 887 |                     for (i = 0; i < keys.length; i += 1) {
 888 |                         key = keys[i];
 889 |                         if (util.hasOwnProp.call(this.parent.written, key)) {
 890 |                             // parent has already written to some
 891 |                             // fields within key, so we need to merge
 892 |                             // our changes in (last writer wins, so
 893 |                             // this is quite simple):
 894 |                             util.shallowCopy(this.written[key].children,
 895 |                                              this.parent.written[key].children);
 896 |                         } else {
 897 |                             this.parent.written[key] = this.written[key];
 898 |                         }
 899 |                     }
 900 |                 }
 901 |             },
 902 | 
 903 |             commit: function (result) {
 904 |                 var success, failure, txnLog, read, written, created, self;
 905 | 
 906 |                 this.suspended = true;
 907 | 
 908 |                 if (util.hasOwnProp.call(this, 'parent')) {
 909 |                     // TODO - we could do a validation here - not a
 910 |                     // full commit. Would require server support.
 911 | 
 912 |                     this.copyToParent(true);
 913 |                     this.stm.transactionFrame = this.parent;
 914 | 
 915 |                     if (util.hasOwnProp.call(this, 'cont')) {
 916 |                         return this.cont(result);
 917 |                     } else {
 918 |                         return result;
 919 |                     }
 920 | 
 921 |                 } else {
 922 |                     delete this.stm.transactionFrame;
 923 | 
 924 |                     read = util.keys(this.read).length !== 0;
 925 |                     written = util.keys(this.written).length !== 0;
 926 |                     created = util.keys(this.created).length !== 0;
 927 | 
 928 |                     if (written || created) {
 929 |                         // if we wrote or created something then we
 930 |                         // have to go to the server, but the server
 931 |                         // can only fail us if we also read.
 932 |                         txnLog = this.cerealise();
 933 |                         txnLog.type = "commit";
 934 |                         this.bumpCreated();
 935 |                         if (read) {
 936 |                             self = this;
 937 |                             success = function () {
 938 |                                 self.applyWritten();
 939 |                                 return self.committed(result);
 940 |                             };
 941 |                             return this.stm.server.commit(
 942 |                                 txnLog, success, this.failed.bind(this), this.abort);
 943 |                         } else {
 944 |                             success = function () {};
 945 |                             failure = function () {
 946 |                                 throw new InternalException();
 947 |                             }
 948 |                             this.stm.server.commit(
 949 |                                 txnLog, success, failure, this.abort);
 950 |                             // server can't fail us, so don't wait for it
 951 |                             this.applyWritten();
 952 |                             return this.committed(result);
 953 |                         }
 954 |                     } else {
 955 |                         // we didn't write or create. We don't need to
 956 |                         // go to the server at all.
 957 |                         return this.committed(result);
 958 |                     }
 959 |                 }
 960 |             },
 961 | 
 962 |             committed: function (result) {
 963 |                 if (util.hasOwnProp.call(this, 'cont')) {
 964 |                     return this.cont(result);
 965 |                 } else {
 966 |                     return result;
 967 |                 }
 968 |             },
 969 | 
 970 |             failed: function () {
 971 |                 // Created vars will be grabbed even on a failed
 972 |                 // commit. Thus do a full reset here.
 973 |                 this.reset(true);
 974 |                 return this.run();
 975 |             },
 976 | 
 977 |             applyWritten: function () {
 978 |                 var ids, i,j, parent, tvar, names, name, value;
 979 |                 ids = util.keys(this.written).sort();
 980 |                 for (i = 0; i < ids.length; i += 1) {
 981 |                     parent = this.written[ids[i]];
 982 |                     tvar = parent.tvar;
 983 |                     tvar.version += 1;
 984 |                     this.log("incr tvar", tvar.id, "to version", tvar.version);
 985 |                     names = util.keys(parent.children);
 986 |                     for (j = 0; j < names.length; j += 1) {
 987 |                         name = names[j];
 988 |                         value = parent.children[name];
 989 |                         if (this.deleted === value) {
 990 |                             this.log("Committing delete to", ids[i], ".", name);
 991 |                             delete tvar.raw[name];
 992 |                         } else {
 993 |                             this.log("Committing write to", ids[i], ".", name);
 994 |                             // mess for dealing with arrays, defineProperty, and some proxy mess
 995 |                             if (tvar.isArray && 'length' === name) {
 996 |                                 tvar.raw[name] = value.value;
 997 |                             } else {
 998 |                                 util.defineProperty(tvar.raw, name, value);
 999 |                             }
1000 |                         }
1001 |                     }
1002 |                 }
1003 |             },
1004 | 
1005 |             retry: function () {
1006 |                 this.funIndex = (this.funIndex + 1) % this.funs.length;
1007 |                 this.suspended = this.funIndex === 0;
1008 |                 throw this.retryException;
1009 |             },
1010 | 
1011 |             maybeSendRetry: function () {
1012 |                 var self, restart, txnLog;
1013 | 
1014 |                 if (0 === this.funIndex) {
1015 |                     // If 0 === this.funIndex then we have done a full
1016 |                     // retry and will soon be waiting on the
1017 |                     // server. Thus we should continue unwinding the
1018 |                     // stack and thus rethrow if we have a parent. If
1019 |                     // we don't have a parent then we should absorb
1020 |                     // the exception and actually issue the retry to
1021 |                     // the server.
1022 | 
1023 |                     this.suspended = true;
1024 | 
1025 |                     if (util.hasOwnProp.call(this, 'parent')) {
1026 |                         this.copyToParent(false);
1027 |                         // We want to do a full retry, so we need to
1028 |                         // make sure our parent wants to do a full
1029 |                         // retry too.
1030 |                         this.parent.funIndex = 0;
1031 |                         this.stm.transactionFrame = this.parent;
1032 |                         throw this.retryException;
1033 | 
1034 |                     } else {
1035 |                         self = this;
1036 |                         txnLog = this.cerealise({created: true, read: true});
1037 |                         delete this.stm.transactionFrame;
1038 | 
1039 |                         // All created vars are about to become
1040 |                         // public. Thus bump vsn to 1.
1041 |                         this.bumpCreated();
1042 | 
1043 |                         restart = function () {
1044 |                             // Created vars will be grabbed even on a
1045 |                             // retry. Thus even if we have to restart
1046 |                             // here, we don't have to worry about the
1047 |                             // current createds any more.
1048 |                             self.reset(true);
1049 |                             return self.run();
1050 |                         };
1051 | 
1052 |                         txnLog.type = "retry";
1053 | 
1054 |                         this.stm.server.retry(txnLog, restart, this.abort);
1055 |                     }
1056 |                 } else {
1057 |                     // If 0 !== this.funIndex then we're in an orElse
1058 |                     // and we've hit a retry which we're going to
1059 |                     // service by changing to the next alternative and
1060 |                     // going round the run loop again. Thus absorb the
1061 |                     // exception, and don't exit the run loop. Do a
1062 |                     // partial reset - throw out the writes but keep
1063 |                     // the reads that led us here (and keep the
1064 |                     // creates; they won't be grabbed by the server
1065 |                     // until we talk to the server).
1066 |                     this.reset(false);
1067 |                 }
1068 |             },
1069 | 
1070 |             cerealise: function (obj) {
1071 |                 var worklist, seen, keys, i, self, key, meta, parent, names, j, value, desc;
1072 |                 self = this;
1073 | 
1074 |                 if (undefined === obj) {
1075 |                     obj = {read: {},
1076 |                            created: {},
1077 |                            written: {},
1078 |                            txnId: this.id};
1079 |                 } else {
1080 |                     obj.txnId = this.id;
1081 |                 }
1082 | 
1083 |                 if (util.hasOwnProp.call(obj, 'created') && obj.created) {
1084 |                     obj.created = {};
1085 |                     keys = util.keys(this.created).sort();
1086 |                     for (i = 0; i < keys.length; i += 1) {
1087 |                         key = keys[i];
1088 |                         obj.created[key] = {value: this.created[key].value.raw,
1089 |                                             isArray: this.created[key].value.isArray,
1090 |                                             version: this.created[key].value.version};
1091 |                         meta = this.created[key].meta;
1092 |                         if (undefined !== meta) {
1093 |                             obj.created[key].meta = meta;
1094 |                         }
1095 |                     }
1096 |                 }
1097 | 
1098 |                 if (util.hasOwnProp.call(obj, 'read') && obj.read) {
1099 |                     obj.read = {};
1100 |                     seen = {};
1101 |                     worklist = [this.read].concat(this.readStack);
1102 |                     while (worklist.length !== 0) {
1103 |                         value = worklist.shift();
1104 |                         keys = util.keys(value).sort();
1105 |                         for (i = 0; i < keys.length; i += 1) {
1106 |                             key = keys[i];
1107 |                             if (! util.hasOwnProp.call(seen, key)) {
1108 |                                 seen[key] = true;
1109 |                                 if (util.hasOwnProp.call(obj, 'created') ||
1110 |                                     ! util.hasOwnProp.call(this.created, key)) {
1111 |                                     obj.read[keys[i]] = {version: value[key]};
1112 |                                 }
1113 |                             }
1114 |                         }
1115 |                     }
1116 |                 }
1117 | 
1118 |                 if (util.hasOwnProp.call(obj, 'written') && obj.written) {
1119 |                     obj.written = {};
1120 |                     keys = util.keys(this.written).sort();
1121 |                     for (i = 0; i < keys.length; i += 1) {
1122 |                         parent = {};
1123 |                         obj.written[keys[i]] = parent;
1124 |                         names = util.keys(this.written[keys[i]].children);
1125 |                         for (j = 0; j < names.length; j += 1) {
1126 |                             value = this.written[keys[i]].children[names[j]];
1127 |                             if (this.deleted === value) {
1128 |                                 parent[names[j]] = {deleted: true};
1129 |                             } else if (util.isPrimitive(value.value)) {
1130 |                                 parent[names[j]] = value;
1131 |                             } else {
1132 |                                 desc = {};
1133 |                                 util.shallowCopy(value, desc);
1134 |                                 delete desc.value;
1135 |                                 desc.tvar = this.stm.asTVar(value.value).id;
1136 |                                 parent[names[j]] = desc;
1137 |                             }
1138 |                         }
1139 |                     }
1140 |                 }
1141 | 
1142 |                 return obj;
1143 |             }
1144 |         };
1145 | 
1146 | 
1147 |         STM = function () {
1148 |             this.tVarCount = 0;
1149 |             this.txnCount = 0;
1150 | 
1151 |             this.objToTVar = new util.Map();
1152 |             this.proxiedToTVar = new util.Map();
1153 |             this.idToTVar = {};
1154 |             this.retryException = {};
1155 |             this.server = this.noopServer();
1156 |             this.root();
1157 |             this.logPrefix = "";
1158 |         };
1159 | 
1160 |         STM.prototype = {
1161 |             isLogging: false,
1162 | 
1163 |             logging: function (bool) {
1164 |                 this.isLogging = bool;
1165 |             },
1166 | 
1167 |             setLogPrefix: function (prefix) {
1168 |                 this.logPrefix = prefix;
1169 |             },
1170 | 
1171 |             log: function () {
1172 |                 var args;
1173 |                 if (this.isLogging) {
1174 |                     args = Array.prototype.slice.call(arguments, 0);
1175 |                     if (0 !== this.logPrefix.length) {
1176 |                         args.unshift(this.logPrefix);
1177 |                         console.log.apply(console, args);
1178 |                     } else {
1179 |                         console.log.apply(console, args);
1180 |                     }
1181 |                 }
1182 |             },
1183 | 
1184 |             noopServer: function () {
1185 |                 var self = this;
1186 |                 return {
1187 |                     commit: function (txnLog, success, failure) {
1188 |                         self.log("Committing txn log:", txnLog);
1189 |                         return success();
1190 |                     },
1191 | 
1192 |                     retry: function (txnLog, restart) {
1193 |                         // default implementation is just going to spin on
1194 |                         // this for the time being.
1195 |                         self.log("Retry with txn log:", txnLog);
1196 |                         return restart();
1197 |                     }
1198 |                 };
1199 |             },
1200 | 
1201 |             inTransaction: function () {
1202 |                 return util.hasOwnProp.call(this, 'transactionFrame');
1203 |             },
1204 | 
1205 |             orElse: function (funs, cont, abort) {
1206 |                 var parent = this.transactionFrame,
1207 |                     txn;
1208 |                 this.txnCount += 1;
1209 |                 txn = new Transaction(this, this.txnCount, parent, funs, cont, abort);
1210 |                 return txn.run();
1211 |             },
1212 | 
1213 |             atomically: function (fun, cont, abort) {
1214 |                 return this.orElse([fun], cont, abort);
1215 |             },
1216 | 
1217 |             retry: function () {
1218 |                 if (!this.inTransaction()) {
1219 |                     throw new RetryOutsideTransactionException();
1220 |                 }
1221 |                 this.transactionFrame.retry();
1222 |             },
1223 | 
1224 |             recordRead: function (parent) {
1225 |                 if (this.inTransaction()) {
1226 |                     this.transactionFrame.recordRead(parent);
1227 |                 }
1228 |             },
1229 | 
1230 |             recordCreation: function (value, meta) {
1231 |                 if (this.inTransaction()) {
1232 |                     this.transactionFrame.recordCreation(value, meta);
1233 |                 } else {
1234 |                     var self = this;
1235 |                     self.atomically(function () {
1236 |                         self.transactionFrame.recordCreation(value, meta);
1237 |                     });
1238 |                 }
1239 |             },
1240 | 
1241 |             isProxied: function (obj) {
1242 |                 return this.proxiedToTVar.has(obj);
1243 |             },
1244 | 
1245 |             asTVar: function (proxied) {
1246 |                 return this.proxiedToTVar.get(proxied);
1247 |             },
1248 | 
1249 |             // always returns a TVar; not a proxied obj
1250 |             ensureTVar: function (obj, meta) {
1251 |                 var val, parentId;
1252 |                 if (undefined === obj || util.isPrimitive(obj)) {
1253 |                     return {proxied: obj, raw: obj};
1254 |                 }
1255 |                 val = this.proxiedToTVar.get(obj);
1256 |                 if (undefined === val) {
1257 |                     val = this.objToTVar.get(obj);
1258 |                     if (undefined === val) {
1259 |                         this.tVarCount += 1;
1260 |                         val = new TVar(this.tVarCount, obj, this);
1261 |                         this.proxiedToTVar.set(val.proxied, val);
1262 |                         this.objToTVar.set(obj, val);
1263 |                         this.idToTVar[val.id] = val;
1264 |                         this.recordCreation(val, meta);
1265 |                         return val;
1266 |                     } else {
1267 |                         // found it in the cache
1268 |                         return val;
1269 |                     }
1270 |                 } else {
1271 |                     // obj was already proxied
1272 |                     return val;
1273 |                 }
1274 |             },
1275 | 
1276 |             lift: function (obj, meta) {
1277 |                 return this.ensureTVar(obj, meta).proxied;
1278 |             },
1279 | 
1280 |             watch: function () {
1281 |                 var self = this,
1282 |                     objs = Array.prototype.slice.call(arguments, 0),
1283 |                     cont = objs.shift(),
1284 |                     fun, i;
1285 |                 for (i = 0; i < objs.length; i += 1) {
1286 |                     objs[i] = self.lift(objs[i]);
1287 |                 }
1288 |                 fun = function (copies) {
1289 |                     var i, j, obj, keys, seen, delta, prev, field, deltas, copies2, retry;
1290 |                     self.atomically(
1291 |                         function () {
1292 |                             deltas = new util.Map();
1293 |                             copies2 = new util.Map();
1294 |                             retry = true;
1295 |                             for (i = 0; i < objs.length; i += 1) {
1296 |                                 obj = objs[i];
1297 |                                 copies2.set(obj, TVar.prototype.clone(obj));
1298 |                                 delta = { added:    [],
1299 |                                           modified: [],
1300 |                                           deleted:  [] };
1301 |                                 if (undefined === copies) {
1302 |                                     delta.added = Object.keys(obj);
1303 |                                     // first time through, existence
1304 |                                     // of empty obj should be enough
1305 |                                     // to trigger
1306 |                                     retry = false;
1307 |                                     deltas.set(obj, delta);
1308 |                                 } else {
1309 |                                     prev = copies.get(obj);
1310 |                                     seen = {};
1311 |                                     keys = Object.keys(obj).concat(Object.keys(prev));
1312 |                                     for (j = 0; j < keys.length; j += 1) {
1313 |                                         field = keys[j];
1314 |                                         if (util.hasOwnProp.call(seen, field)) {
1315 |                                             continue;
1316 |                                         }
1317 |                                         seen[field] = true;
1318 |                                         if (util.hasOwnProp.call(obj, field) &&
1319 |                                             util.hasOwnProp.call(prev, field)) {
1320 |                                             if (obj[field] !== prev[field]) {
1321 |                                                 delta.modified.push(field);
1322 |                                             }
1323 |                                         } else if (util.hasOwnProp.call(obj, keys[j])) {
1324 |                                             delta.added.push(field);
1325 |                                         } else {
1326 |                                             delta.deleted.push(field);
1327 |                                         }
1328 |                                     }
1329 |                                     if ((delta.added.length + delta.modified.length +
1330 |                                          delta.deleted.length) > 0) {
1331 |                                         deltas.set(obj, delta);
1332 |                                         retry = false;
1333 |                                     }
1334 |                                 }
1335 |                             }
1336 | 
1337 |                             if (retry) {
1338 |                                 self.retry();
1339 |                             } else {
1340 |                                 return {copies: copies2, result: cont(true, deltas)};
1341 |                             }
1342 |                         }, function (result) {
1343 |                             if (cont(false, result.result)) {
1344 |                                 fun(result.copies);
1345 |                             }
1346 |                         });
1347 |                 };
1348 |                 fun(undefined);
1349 |             },
1350 | 
1351 |             access: function (obj, field) {
1352 |                 var tvar, result;
1353 |                 tvar = this.asTVar(obj);
1354 |                 if (undefined === tvar) {
1355 |                     result = obj[field];
1356 |                     if (typeof result === 'function') {
1357 |                         return result.bind(obj);
1358 |                     } else {
1359 |                         return result;
1360 |                     }
1361 |                 } else {
1362 |                     return tvar.handler.get(obj, field);
1363 |                 }
1364 |             },
1365 | 
1366 |             assign: function (obj, field, value) {
1367 |                 var tvar = this.asTVar(obj);
1368 |                 if (undefined === tvar) {
1369 |                     return obj[field] = value;
1370 |                 } else {
1371 |                     return tvar.handler.set(tvar.proxied, field, value);
1372 |                 }
1373 |             },
1374 | 
1375 |             enumerate: function (obj) {
1376 |                 var tvar = this.asTVar(obj);
1377 |                 if (undefined === tvar) {
1378 |                     return obj;
1379 |                 } else {
1380 |                     return tvar.handler.enumerate();
1381 |                 }
1382 |             },
1383 | 
1384 |             has: function (obj, field) {
1385 |                 var tvar = this.asTVar(obj);
1386 |                 if (undefined === tvar) {
1387 |                     return field in obj;
1388 |                 } else {
1389 |                     return tvar.handler.has(field);
1390 |                 }
1391 |             },
1392 | 
1393 |             erase: function (obj, field) {
1394 |                 var tvar = this.asTVar(obj);
1395 |                 if (undefined === tvar) {
1396 |                     return delete obj[field];
1397 |                 } else {
1398 |                     // IE can't cope if you write ...handler.delete(...
1399 |                     return tvar.handler['delete'](field);
1400 |                 }
1401 |             },
1402 | 
1403 |             root: function () {
1404 |                 var obj, val;
1405 |                 if (0 === this.tVarCount) {
1406 |                     obj = {};
1407 |                     this.tVarCount += 1;
1408 |                     val = new TVar(this.tVarCount, obj, this);
1409 |                     this.proxiedToTVar.set(val.proxied, val);
1410 |                     this.objToTVar.set(obj, val);
1411 |                     this.idToTVar[val.id] = val;
1412 |                     val.version = 0;
1413 |                     val.unpopulated = true;
1414 |                     return val.proxied;
1415 |                 } else {
1416 |                     return this.idToTVar[1].proxied;
1417 |                 }
1418 |             },
1419 | 
1420 |             applyUpdates: function (updates) {
1421 |                 var keys, names, update, tvar, i, j, value, obj;
1422 |                 keys = util.keys(updates);
1423 |                 for (i = 0; i < keys.length; i += 1) {
1424 |                     update = updates[keys[i]];
1425 |                     tvar = this.idToTVar[keys[i]];
1426 |                     if (undefined === tvar) {
1427 |                         if (update.isArray) {
1428 |                             obj = [];
1429 |                         } else {
1430 |                             obj = {};
1431 |                         }
1432 |                         tvar = new TVar(keys[i], obj, this);
1433 |                         this.proxiedToTVar.set(tvar.proxied, tvar);
1434 |                         this.objToTVar.set(obj, tvar);
1435 |                         this.idToTVar[tvar.id] = tvar;
1436 |                     }
1437 | 
1438 |                     // It's possible to see an update for a var with
1439 |                     // the same version as we already have due to
1440 |                     // multiple txns being rejected for the same
1441 |                     // reason (or a retry and commit from the same
1442 |                     // client - the commit may alter the var the retry
1443 |                     // is watching and thus prompt an update after the
1444 |                     // commit completes). If the versions are equal,
1445 |                     // then just ignore it.
1446 | 
1447 |                     if (tvar.version > update.version) {
1448 |                         console.error("Invalid update detected: " + tvar.id +
1449 |                                       " local vsn: " + tvar.version + "; remote vsn: " + update.version);
1450 |                     }
1451 |                     tvar.unpopulated = 0 === update.version;
1452 |                     if (tvar.version === update.version) {
1453 |                         continue;
1454 |                     }
1455 | 
1456 |                     tvar.version = update.version;
1457 | 
1458 |                     names = util.keys(tvar.raw);
1459 |                     for (j = 0; j < names.length; j += 1) {
1460 |                         if ("_map" !== names[j] && ! util.hasOwnProp.call(update.value, names[j])) {
1461 |                             delete tvar.raw[names[j]];
1462 |                         }
1463 |                     }
1464 | 
1465 |                     names = util.keys(update.value);
1466 |                     for (j = 0; j < names.length; j += 1) {
1467 |                         this.applyUpdate(tvar, names[j], update.value[names[j]], updates);
1468 |                     }
1469 |                 }
1470 |             },
1471 | 
1472 |             applyUpdate: function (tvar, name, desc, updates) {
1473 |                 var obj, tvar2, desc2 = {};
1474 |                 if (! util.hasOwnProp.call(desc, 'tvar')) {
1475 |                     if (tvar.isArray && 'length' === name) {
1476 |                         tvar.raw[name] = desc.value;
1477 |                     } else {
1478 |                         util.defineProperty(tvar.raw, name, desc);
1479 |                     }
1480 |                 } else {
1481 |                     if (undefined === this.idToTVar[desc.tvar]) {
1482 |                         if (util.hasOwnProp.call(updates, desc.tvar)) {
1483 |                             // we're going to create a new empty var
1484 |                             // so that we can proceed here.
1485 |                             if (updates[desc.tvar].isArray) {
1486 |                                 obj = [];
1487 |                             } else {
1488 |                                 obj = {};
1489 |                             }
1490 |                             tvar2 = new TVar(desc.tvar, obj, this);
1491 |                             this.proxiedToTVar.set(tvar2.proxied, tvar2);
1492 |                             this.objToTVar.set(obj, tvar2);
1493 |                             this.idToTVar[tvar2.id] = tvar2;
1494 |                         } else {
1495 |                             // not known already, and not defined by updates!
1496 |                             throw new InternalException();
1497 |                         }
1498 |                     }
1499 |                     util.shallowCopy(desc, desc2);
1500 |                     desc2.value = this.idToTVar[desc.tvar].proxied;
1501 |                     delete desc2.tvar;
1502 |                     util.defineProperty(tvar.raw, name, desc2);
1503 |                 }
1504 |             }
1505 |         };
1506 | 
1507 |     }());
1508 | 
1509 |     (function () {
1510 |         var compatNeeded = false,
1511 |             publicMethods = ['logging', 'setLogPrefix', 'inTransaction', 'orElse',
1512 |                              'atomically', 'retry', 'lift', 'access', 'assign',
1513 |                              'enumerate', 'has', 'erase', 'watch'],
1514 |             atomizeImpl;
1515 | 
1516 |         Atomize = function () {
1517 |             var args = Array.prototype.slice.call(arguments, 0),
1518 |                 stm = new STM();
1519 |             util.lift(stm, this, publicMethods);
1520 |             this.root = stm.root();
1521 |             atomizeImpl(this, stm, args);
1522 |         };
1523 |         Atomize.prototype = {
1524 |             onPreAuthenticated: function (message, sockjs) {
1525 |                 return true;
1526 |             },
1527 | 
1528 |             onAuthenticated: function () {
1529 |             },
1530 | 
1531 |             connect: function () {
1532 |             },
1533 | 
1534 |             close: function () {
1535 |             }
1536 |         };
1537 | 
1538 |         if (typeof exports !== "undefined") {
1539 |             // we're in node
1540 | 
1541 |             if ("undefined" === typeof Proxy) {
1542 |                 compatNeeded = true;
1543 |             }
1544 | 
1545 |             atomizeImpl = function (external, stm, args) {
1546 |                 var ClientCtor = args[0],
1547 |                     serverEventEmitter = args[1],
1548 |                     inflight = {},
1549 |                     resultFuns = [],
1550 |                     FakeConn, client;
1551 | 
1552 |                 if (compatNeeded) {
1553 |                     require('./compat').compat.load(stm);
1554 |                 }
1555 | 
1556 |                 function runResultFuns () {
1557 |                     while (resultFuns.length > 0) {
1558 |                         (resultFuns.pop())();
1559 |                     }
1560 |                 }
1561 | 
1562 |                 FakeConn = function () {
1563 |                     this.id = "server";
1564 |                     this.emitter = new events.EventEmitter();
1565 |                     util.lift(this.emitter, this,
1566 |                               ['on', 'once', 'removeListener', 'removeAllListeners', 'emit']);
1567 |                 };
1568 |                 FakeConn.prototype = {
1569 |                     write: function (msg) {
1570 |                         // this is the server writing a message back
1571 |                         // to the client.
1572 | 
1573 |                         var txnLog, txnId, txn, fun;
1574 |                         txnLog = Cereal.parse(msg);
1575 |                         switch (txnLog.type) {
1576 |                         case 'result':
1577 |                             txnId = txnLog.txnId;
1578 |                             txn = inflight[txnId];
1579 |                             delete inflight[txnId];
1580 |                             stm.log("[Txn " + txnId + "] response received:", txnLog.result);
1581 |                             fun = txn[txnLog.result];
1582 |                             if (undefined !== fun && undefined !== fun.call) {
1583 |                                 if (txn.runImmediately) {
1584 |                                     runResultFuns();
1585 |                                     fun();
1586 |                                 } else {
1587 |                                     resultFuns.push(fun);
1588 |                                 }
1589 |                             }
1590 |                             break;
1591 |                         case 'updates':
1592 |                             stm.log("Received Updates:", txnLog);
1593 |                             runResultFuns();
1594 |                             stm.applyUpdates(txnLog.updates);
1595 |                             break;
1596 |                         default:
1597 |                             stm.log("Confused");
1598 |                         }
1599 |                     }
1600 |                 };
1601 | 
1602 |                 client = new ClientCtor(new FakeConn(), serverEventEmitter);
1603 | 
1604 |                 stm.server = {
1605 |                     commit: function (txnLog, success, failure, abort) {
1606 |                         var serialised = Cereal.stringify(txnLog),
1607 |                             obj = {txnLog: serialised,
1608 |                                    success: success,
1609 |                                    failure: failure,
1610 |                                    abort: abort};
1611 |                         inflight[txnLog.txnId] = obj;
1612 |                         stm.log("[Txn " + txnLog.txnId + "] sending commit:", txnLog);
1613 |                         client.dispatch(serialised);
1614 |                         // set this *after* we've potentially already run it...!
1615 |                         obj.runImmediately = true;
1616 |                         runResultFuns();
1617 |                     },
1618 | 
1619 |                     retry: function (txnLog, restart, abort) {
1620 |                         var serialised = Cereal.stringify(txnLog),
1621 |                             obj = {txnLog: txnLog,
1622 |                                    restart: restart,
1623 |                                    abort: abort};
1624 |                         inflight[txnLog.txnId] = obj;
1625 |                         stm.log("[Txn " + txnLog.txnId + "] sending retry:", txnLog);
1626 |                         client.dispatch(serialised);
1627 |                         // set this *after* we've potentially already run it...!
1628 |                         obj.runImmediately = true;
1629 |                         runResultFuns();
1630 |                     }
1631 |                 };
1632 |             };
1633 | 
1634 |             exports.Atomize = Atomize;
1635 |             exports.Map = util.Map;
1636 | 
1637 |         } else {
1638 |             (function () {
1639 |                 if ("undefined" === typeof Proxy) {
1640 |                     var scripts = document.getElementsByTagName('script'),
1641 |                         index = scripts.length - 1,
1642 |                         myScript = scripts[index],
1643 |                         script = document.createElement('script');
1644 | 
1645 |                     script.src = myScript.src.substring(0, 1 + (myScript.src.lastIndexOf('/'))) + "compat.js";
1646 | 
1647 |                     document.getElementsByTagName('head')[0].appendChild(script);
1648 | 
1649 |                     compatNeeded = true;
1650 |                 }
1651 |             }());
1652 | 
1653 |             if (undefined === window.SockJS) {
1654 |                 console.warn("SockJS not found. Assuming offline-mode.");
1655 | 
1656 |                 atomizeImpl = function (external, stm) {
1657 |                     if (compatNeeded) {
1658 |                         AtomizeCompat.load(stm);
1659 |                     }
1660 | 
1661 |                     external.connect = function () {
1662 |                         external.onAuthenticated();
1663 |                     };
1664 |                 };
1665 | 
1666 |             } else {
1667 | 
1668 |                 atomizeImpl = function (external, stm, args) {
1669 |                     var url = args[0],
1670 |                         inflight = {},
1671 |                         queue = [],
1672 |                         reconnector,
1673 |                         drainEnqueued,
1674 |                         sockjs;
1675 | 
1676 |                     if (compatNeeded) {
1677 |                         AtomizeCompat.load(stm);
1678 |                     }
1679 | 
1680 |                     if (undefined === url) {
1681 |                         if (location.protocol !== 'http:' &&
1682 |                             location.protocol !== 'https:') {
1683 |                             console.warn("No url provided. Assuming offline-mode.");
1684 |                         } else {
1685 |                             url = location.protocol + '//' + location.host + '/atomize';
1686 |                         }
1687 |                     }
1688 | 
1689 |                     if (undefined !== url) {
1690 |                         external.ready = false;
1691 | 
1692 |                         reconnector = {
1693 |                             initialDelay: 2000, // 2 seconds
1694 |                             maxDelay: 180000,   // 3 minutes
1695 | 
1696 |                             connected: function () {
1697 |                                 stm.log("Connected");
1698 |                                 reconnector.reconnect = true;
1699 |                                 reconnector.delay = reconnector.initialDelay;
1700 |                             },
1701 | 
1702 |                             connect: function () {
1703 |                                 stm.log("Attempting connection");
1704 |                                 external.connect();
1705 |                             },
1706 | 
1707 |                             disconnected: function () {
1708 |                                 stm.log("Disconnected");
1709 |                                 if (reconnector.reconnect) {
1710 |                                     setTimeout(reconnector.connect, reconnector.delay);
1711 |                                     reconnector.delay += Math.floor(Math.random() * reconnector.delay);
1712 |                                     reconnector.delay = reconnector.delay > reconnector.maxDelay
1713 |                                         ? reconnector.maxDelay : reconnector.delay;
1714 |                                 }
1715 |                             }
1716 |                         };
1717 | 
1718 |                         drainEnqueued = function () {
1719 |                             var i;
1720 |                             for (i = 0; i < queue.length; i += 1) {
1721 |                                 sockjs.send(queue[i]);
1722 |                             }
1723 |                             queue = [];
1724 |                         };
1725 | 
1726 |                         external.close = function () {
1727 |                             reconnector.reconnect = false;
1728 |                             sockjs.close();
1729 |                         };
1730 | 
1731 |                         external.connect = function () {
1732 |                             reconnector.connected();
1733 |                             sockjs = new SockJS(url);
1734 | 
1735 |                             sockjs.onopen = function () {
1736 |                                 stm.log("Connected to server", url,
1737 |                                         "(using", sockjs.protocol, ")");
1738 |                                 reconnector.connected();
1739 |                                 external.ready = external.onPreAuthenticated(undefined, sockjs);
1740 |                                 if (external.ready) {
1741 |                                     drainEnqueued();
1742 |                                     external.onAuthenticated();
1743 |                                 } else {
1744 |                                     return;
1745 |                                 }
1746 |                             };
1747 | 
1748 |                             sockjs.onclose = function (e) {
1749 |                                 var keys, i, obj;
1750 |                                 stm.log("Disconnected from server", url,
1751 |                                         "(", e.status, e.reason, ")");
1752 |                                 external.ready = false;
1753 |                                 keys = util.keys(inflight).sort();
1754 |                                 for (i = 0; i < keys.length; i += 1) {
1755 |                                     queue.push(inflight[keys[i]].txnLog);
1756 |                                 }
1757 |                                 reconnector.disconnected();
1758 |                             };
1759 | 
1760 |                             sockjs.onmessage = function (e) {
1761 |                                 var txnLog, txnId, txn, fun;
1762 |                                 if (!external.ready) {
1763 |                                     external.ready = external.onPreAuthenticated(e, sockjs);
1764 |                                     if (external.ready) {
1765 |                                         drainEnqueued();
1766 |                                         external.onAuthenticated();
1767 |                                     }
1768 |                                     return; // authentication consumed e, so return here
1769 |                                 }
1770 |                                 txnLog = Cereal.parse(e.data);
1771 |                                 switch (txnLog.type) {
1772 |                                 case 'result':
1773 |                                     txnId = txnLog.txnId;
1774 |                                     txn = inflight[txnId];
1775 |                                     delete inflight[txnId];
1776 |                                     stm.log("[Txn " + txnId + "] response received:", txnLog.result);
1777 |                                     fun = txn[txnLog.result];
1778 |                                     if (undefined !== fun && undefined !== fun.call) {
1779 |                                         fun();
1780 |                                     }
1781 |                                     break;
1782 |                                 case 'updates':
1783 |                                     stm.log("Received Updates:", txnLog);
1784 |                                     stm.applyUpdates(txnLog.updates);
1785 |                                     break;
1786 |                                 default:
1787 |                                     stm.log("Received unexpected message from server:",
1788 |                                             JSON.stringify(txnLog));
1789 |                                     throw new InternalException();
1790 |                                 }
1791 |                             };
1792 |                         };
1793 | 
1794 |                         stm.server = {
1795 |                             commit: function (txnLog, success, failure, abort) {
1796 |                                 var serialised = Cereal.stringify(txnLog),
1797 |                                     obj = {txnLog: serialised,
1798 |                                            success: success,
1799 |                                            failure: failure,
1800 |                                            abort: abort};
1801 |                                 inflight[txnLog.txnId] = obj;
1802 |                                 if (! external.ready) {
1803 |                                     queue.push(serialised);
1804 |                                     return;
1805 |                                 }
1806 |                                 stm.log("[Txn " + txnLog.txnId + "] sending commit:", txnLog);
1807 |                                 sockjs.send(serialised);
1808 |                             },
1809 | 
1810 |                             retry: function (txnLog, restart, abort) {
1811 |                                 var serialised = Cereal.stringify(txnLog),
1812 |                                     obj = {txnLog: txnLog,
1813 |                                            restart: restart,
1814 |                                            abort: abort};
1815 |                                 inflight[txnLog.txnId] = obj;
1816 |                                 if (! external.ready) {
1817 |                                     queue.push(serialised);
1818 |                                     return;
1819 |                                 }
1820 |                                 stm.log("[Txn " + txnLog.txnId + "] sending retry:", txnLog);
1821 |                                 sockjs.send(serialised);
1822 |                             }
1823 |                         };
1824 |                     }
1825 |                 };
1826 |             }
1827 |         }
1828 | 
1829 |     }());
1830 | 
1831 | }(this));
1832 | 


--------------------------------------------------------------------------------
/lib/compat.js:
--------------------------------------------------------------------------------
  1 | /*global require, exports */
  2 | /*jslint browser: true, devel: true */
  3 | 
  4 | var AtomizeCompat;
  5 | 
  6 | (function (window) {
  7 |     'use strict';
  8 | 
  9 |     if (undefined !== AtomizeCompat) {
 10 |         return;
 11 |     }
 12 | 
 13 |     var atomizeCompat;
 14 | 
 15 |     atomizeCompat = {
 16 |         loaded: false,
 17 | 
 18 |         load: function (stm) {
 19 |             if (this.loaded) {
 20 |                 return;
 21 |             }
 22 |             this.loaded = true;
 23 | 
 24 |             var wrapUnary = function (parent, funName, proxyFunName) {
 25 |                 var origFun = parent[funName];
 26 |                 if (undefined !== origFun && undefined === origFun._origFun) {
 27 |                     if (undefined === proxyFunName) {
 28 |                         proxyFunName = funName;
 29 |                     }
 30 |                     parent[funName] = (function (obj) {
 31 |                         stm.log(["compat lib invocation of ", funName]);
 32 |                         var tvar = stm.asTVar(obj);
 33 |                         if (undefined === tvar) {
 34 |                             return origFun.call(parent, obj);
 35 |                         } else {
 36 |                             return tvar.handler[proxyFunName]();
 37 |                         }
 38 |                     }).bind(parent);
 39 |                     parent[funName]._origFun = origFun.bind(parent);
 40 |                 }
 41 |             };
 42 | 
 43 |             (function () { // Object.defineProperty
 44 |                 var origFun = Object.defineProperty;
 45 | 
 46 |                 if (undefined !== origFun && undefined === origFun._origFun) {
 47 |                     Object.defineProperty = (function (obj, name, desc) {
 48 |                         stm.log("compat lib invocation of defineProperty");
 49 |                         var tvar = stm.asTVar(obj);
 50 |                         if (undefined === tvar) {
 51 |                             return origFun.call(Object, obj, name, desc);
 52 |                         } else {
 53 |                             return tvar.handler.defineProperty(name, desc);
 54 |                         }
 55 |                     }).bind(Object);
 56 |                     Object.defineProperty._origFun = origFun.bind(Object);
 57 |                 }
 58 |             }());
 59 | 
 60 |             (function () { // Object.getPropertyDescriptor
 61 |                 var origFun = Object.getPropertyDescriptor;
 62 | 
 63 |                 if (undefined !== origFun && undefined === origFun._origFun) {
 64 |                     Object.getPropertyDescriptor = (function (obj, name) {
 65 |                         stm.log("compat lib invocation of getPropertyDescriptor");
 66 |                         var tvar = stm.asTVar(obj);
 67 |                         if (undefined === tvar) {
 68 |                             return origFun.call(Object, obj, name);
 69 |                         } else {
 70 |                             return tvar.handler.getPropertyDescriptor(name);
 71 |                         }
 72 |                     }).bind(Object);
 73 |                     Object.getPropertyDescriptor._origFun = origFun.bind(Object);
 74 |                 }
 75 |             }());
 76 | 
 77 |             wrapUnary(Object, 'getPropertyNames');
 78 | 
 79 |             (function () { // Object.getOwnPropertyDescriptor
 80 |                 var origFun = Object.getOwnPropertyDescriptor;
 81 | 
 82 |                 if (undefined !== origFun && undefined === origFun._origFun) {
 83 |                     Object.getOwnPropertyDescriptor = (function (obj, name) {
 84 |                         stm.log("compat lib invocation of getOwnPropertyDescriptor");
 85 |                         var tvar = stm.asTVar(obj);
 86 |                         if (undefined === tvar) {
 87 |                             return origFun.call(Object, obj, name);
 88 |                         } else {
 89 |                             return tvar.handler.getOwnPropertyDescriptor(name);
 90 |                         }
 91 |                     }).bind(Object);
 92 |                     Object.getOwnPropertyDescriptor._origFun = origFun.bind(Object);
 93 |                 }
 94 |             }());
 95 | 
 96 |             wrapUnary(Object, 'getOwnPropertyNames');
 97 |             wrapUnary(Object, 'keys');
 98 | 
 99 |             (function () { // hasOwnProperty NOTE: no bind!
100 |                 var objProto = Object.getPrototypeOf({});
101 |                 var origFun = objProto.hasOwnProperty;
102 | 
103 |                 if (undefined !== origFun && undefined === origFun._origFun) {
104 |                     objProto.hasOwnProperty = function (name) {
105 |                         stm.log("compat lib invocation of hasOwnProperty");
106 |                         var tvar = stm.asTVar(this);
107 |                         if (undefined === tvar) {
108 |                             return origFun.call(this, name);
109 |                         } else {
110 |                             return tvar.handler.has(name);
111 |                         }
112 |                     };
113 |                     Object.hasOwnProperty._origFun = origFun;
114 |                 }
115 |             }());
116 |         }
117 |     };
118 | 
119 |     if ("undefined" !== typeof Proxy) {
120 |         atomizeCompat.loaded = true;
121 |     }
122 | 
123 |     if ("undefined" === typeof exports) {
124 |         AtomizeCompat = atomizeCompat;
125 |     } else {
126 |         exports.compat = atomizeCompat;
127 |     }
128 | 
129 | }());
130 | 


--------------------------------------------------------------------------------
/lib/prettyprinter_test.js:
--------------------------------------------------------------------------------
 1 | /*global exports, require */
 2 | /*jslint devel: true */
 3 | 
 4 | /*
 5 |  * Tests for the pretty printer.
 6 |  */
 7 | 
 8 | var walker = require('./walker');
 9 | 
10 | exports.testASTIdempotency = function (test) {
11 |     // This test ensures that the AST that we get before and after
12 |     // going through the pretty printer is the same (deepEquals).
13 | 
14 |     var i, keys, ast1, ast2, ast3, str, fun;
15 |     keys = Object.keys(walker.PrettyPrinter.prototype);
16 | 
17 |     for (i = 0; i < keys.length; i += 1) {
18 |         if (Function === walker.PrettyPrinter.prototype[keys[i]].constructor) {
19 |             ast1 = walker.parse(walker.PrettyPrinter.prototype[keys[i]].toString());
20 |             str = new walker.PrettyPrinter(ast1).print();
21 |             ast2 = walker.parse(str);
22 |             test.deepEqual(ast1, ast2, "Reformatting PrettyPrinter.prototype." + keys[i] + " is not idempotent.");
23 | 
24 |             fun = eval("(" + str + ")");
25 |             ast3 = walker.parse(fun.toString());
26 |             test.deepEqual(ast1, ast3, "Parsing the eval'd reformatted PrettyPrinter.prototype." + keys[i] + " is not idempotent.\n" + str);
27 |         }
28 |     }
29 | 
30 |     test.done();
31 | };
32 | 


--------------------------------------------------------------------------------
/lib/transform.js:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env node
 2 | 
 3 | /*global process, require */
 4 | /*jslint devel: true */
 5 | 
 6 | var walker = require('./walker');
 7 | var fs = require('fs');
 8 | var input = process.argv[2];
 9 | var output = process.argv[3];
10 | var atomize = process.argv[4];
11 | var ignore = process.argv.slice(5);
12 | 
13 | var dataReady = function (err, data) {
14 |     var ast, pi, pp, result;
15 |     if (err) {
16 |         throw err;
17 |     }
18 |     try {
19 |         ast = walker.parse(data);
20 |         pi = new walker.ProxyInjector(ast, atomize, ignore);
21 |         pi.transform();
22 |         pp = new walker.PrettyPrinter(pi.ast);
23 |         result = pp.print();
24 |         fs.writeFileSync(output, result, 'utf8');
25 |     } catch (err) {
26 |         console.log(err.name + ":\n" + err.message + " at " + err.line + "," + err.column);
27 |     }
28 | };
29 | 
30 | fs.readFile(input, 'utf8', dataReady);
31 | 


--------------------------------------------------------------------------------
/lib/walker.js:
--------------------------------------------------------------------------------
   1 | /*global exports, require */
   2 | /*jslint devel: true */
   3 | 
   4 | (function () {
   5 |     'use strict';
   6 | 
   7 |     var parser = require('./javascript_parser');
   8 | 
   9 | 
  10 |     // In general keep in mind that the stack-based nature of this
  11 |     // visitor is reverse-polish-notation form. I.e. in a sequence of
  12 |     // calls to walk or invoke, they'll actually get visited in LIFO
  13 |     // order.
  14 | 
  15 |     function TreeWalker(ast, recv) {
  16 |         var self = this;
  17 |         this.ast = ast;
  18 |         this.recv = recv;
  19 |         this.stack =
  20 |             [{traverse: ast, parent: undefined, name: undefined},
  21 |              {fun: function () {
  22 |                  if (self.hasProp(self.recv, 'finished') &&
  23 |                      Function === self.recv.finished.constructor) {
  24 |                      return self.recv.finished();
  25 |                  }
  26 |              }}];
  27 |         this.current = undefined;
  28 |     }
  29 | 
  30 |     TreeWalker.prototype = {
  31 |         hasOwnProp: function (obj, prop) {
  32 |             return ({}).hasOwnProperty.call(obj, prop);
  33 |         },
  34 | 
  35 |         hasProp: function (obj, prop) {
  36 |             return undefined !== obj[prop];
  37 |         },
  38 | 
  39 |         isPrimitive: function (obj) {
  40 |             return obj !== Object(obj);
  41 |         },
  42 | 
  43 |         traverse: function () {
  44 |             var item, parent, obj, name, keys, i, key;
  45 |             while (0 !== this.stack.length) {
  46 |                 item = this.stack.shift();
  47 | 
  48 |                 if (this.hasOwnProp(item, 'traverse')) {
  49 |                     obj = item.traverse;
  50 |                     parent = item.parent;
  51 |                     name = item.name;
  52 |                     this.current = obj;
  53 |                     if (this.hasOwnProp(obj, 'type')) {
  54 |                         if (this.hasProp(this.recv, obj.type) &&
  55 |                             Function === this.recv[obj.type].constructor) {
  56 |                             this.recv[obj.type](this, parent, obj, name);
  57 |                         } else {
  58 |                             keys = Object.keys(obj);
  59 |                             for (i = keys.length - 1; i >= 0; i -= 1) {
  60 |                                 key = keys[i];
  61 |                                 if (!this.isPrimitive(obj[key])) {
  62 |                                     this.stack.unshift({traverse: obj[key], parent: obj, name: key});
  63 |                                 }
  64 |                             }
  65 |                         }
  66 |                     } else {
  67 |                         if (Array === obj.constructor) {
  68 |                             for (i = obj.length - 1; i >= 0; i -= 1) {
  69 |                                 this.stack.unshift({traverse: obj[i], parent: obj, name: i});
  70 |                             }
  71 |                         } else {
  72 |                             if (this.hasProp(this.recv, 'unknown') &&
  73 |                                 Function === this.recv.unknown.constructor) {
  74 |                                 this.recv.unknown(this, parent, obj);
  75 |                             }
  76 |                         }
  77 |                     }
  78 |                 } else if (this.hasOwnProp(item, 'fun')) {
  79 |                     this.current = item.current;
  80 |                     item.fun(this, item.current);
  81 |                 }
  82 |             }
  83 |         },
  84 | 
  85 |         walk: function (obj, key) {
  86 |             if (undefined === key) {
  87 |                 // the obj is in fact the name
  88 |                 this.stack.unshift({traverse: this.current[obj], parent: this.current, name: obj});
  89 |             } else {
  90 |                 this.stack.unshift({traverse: obj[key], parent: obj, name: key});
  91 |             }
  92 |         },
  93 | 
  94 |         invoke: function (fun) {
  95 |             this.stack.unshift({fun: fun, current: this.current});
  96 |         }
  97 |     };
  98 | 
  99 | 
 100 |     function PrettyPrinter(ast) {
 101 |         this.ast = ast;
 102 |         this.treeWalker = new TreeWalker(ast, this);
 103 |         this.indentation = 0;
 104 |         this.needsTermination = true;
 105 |     }
 106 | 
 107 |     PrettyPrinter.prototype = {
 108 | 
 109 |         indentUnit: '    ',
 110 | 
 111 |         print: function () {
 112 |             this.text = [];
 113 |             this.whiteSpaceOnly = true;
 114 |             this.lines = [];
 115 |             this.linesState = [];
 116 |             this.treeWalker.traverse();
 117 |             return this.toString();
 118 |         },
 119 | 
 120 |         toString: function () {
 121 |             return this.lines.join("\n") + this.text.join("");
 122 |         },
 123 | 
 124 |         append: function (str) {
 125 |             this.whiteSpaceOnly = false;
 126 |             this.text.push(str);
 127 |         },
 128 | 
 129 |         incDepth: function () {
 130 |             this.indentation += 1;
 131 |         },
 132 | 
 133 |         decDepth: function () {
 134 |             this.indentation -= 1;
 135 |         },
 136 | 
 137 |         freshScope: function () {
 138 |             this.lines.push(this.text);
 139 |             this.linesState.push(this.whiteSpaceOnly);
 140 |             this.text = [];
 141 |             this.whiteSpaceOnly = true;
 142 |             this.needsTermination = true;
 143 |         },
 144 | 
 145 |         popScope: function () {
 146 |             this.text = this.lines.pop();
 147 |             this.whiteSpaceOnly = this.linesState.pop();
 148 |         },
 149 | 
 150 |         popAndFreshScope: function () {
 151 |             this.popScope();
 152 |             this.freshScope();
 153 |         },
 154 | 
 155 |         indent: function () {
 156 |             var i;
 157 |             for (i = 0; i < this.indentation; i += 1) {
 158 |                 this.text.push(this.indentUnit);
 159 |             }
 160 |         },
 161 | 
 162 |         terminate: function () {
 163 |             if (this.needsTermination) {
 164 |                 this.append(";");
 165 |             }
 166 |         },
 167 | 
 168 |         withFreshScopeJoin: function (fun) {
 169 |             this.freshScope();
 170 |             fun();
 171 |             var text = this.text.join("");
 172 |             this.popScope();
 173 |             this.append(text);
 174 |         },
 175 | 
 176 |         formatStatements: function (tw, statements, obj) {
 177 |             var i, self = this;
 178 |             for (i = obj.length - 1; i >= 0; i -= 1) {
 179 |                 tw.invoke(function () {
 180 |                     if (self.whiteSpaceOnly) {
 181 |                         statements.push("\n");
 182 |                     } else {
 183 |                         self.terminate();
 184 |                         statements.push(self.text.join("") + "\n");
 185 |                     }
 186 |                     self.popScope();
 187 |                 });
 188 |                 tw.walk(obj, i);
 189 |                 tw.invoke(function () {
 190 |                     self.freshScope();
 191 |                     self.indent();
 192 |                 });
 193 |             }
 194 |         },
 195 | 
 196 |         forWhileLoop: function (tw, elements, obj, init) {
 197 |             var i, self = this;
 198 |             tw.invoke(function () {
 199 |                 var body = self.text.join("");
 200 |                 self.popScope();
 201 |                 self.withFreshScopeJoin(function () {
 202 |                     self.append(init(elements));
 203 |                     if ("Block" === obj.statement.type) {
 204 |                         self.append(" ");
 205 |                         self.needsTermination = false;
 206 |                     } else {
 207 |                         self.append("\n");
 208 |                         self.incDepth();
 209 |                         self.indent();
 210 |                         self.decDepth();
 211 |                     }
 212 |                     self.append(body);
 213 |                 });
 214 |             });
 215 |             tw.walk('statement');
 216 |             for (i = 0; i < elements.length; i += 1) {
 217 |                 (function () {
 218 |                     var j = i;
 219 |                     if (obj[elements[j]]) {
 220 |                         tw.invoke(function () {
 221 |                             elements[elements[j]] = self.text.join("");
 222 |                             self.popAndFreshScope();
 223 |                         });
 224 |                         tw.walk(elements[j]);
 225 |                     } else {
 226 |                         elements[elements[j]] = '';
 227 |                     }
 228 |                 }());
 229 |             }
 230 |             this.freshScope();
 231 |         },
 232 | 
 233 |         // Visitor Pattern
 234 | 
 235 |         ArrayLiteral: function (tw, parent, obj, name) {
 236 |             var self = this;
 237 |             tw.invoke(function () {
 238 |                 var text = self.text.join(", ");
 239 |                 self.popScope();
 240 |                 self.append("[" + text + "]");
 241 |             });
 242 |             tw.walk('elements');
 243 |             this.freshScope();
 244 |         },
 245 | 
 246 |         AssignmentExpression: function (tw, parent, obj, name) {
 247 |             var result, self = this;
 248 |             tw.invoke(function () { self.needsTermination = true; });
 249 |             result = this.BinaryExpression(tw, parent, obj, name);
 250 |         },
 251 | 
 252 |         BinaryExpression: function (tw, parent, obj, name) {
 253 |             var self = this;
 254 |             tw.invoke(function () {
 255 |                 var lhs, rhs;
 256 |                 rhs = self.text.join("");
 257 |                 if (obj.right.type === "BinaryExpression") {
 258 |                     rhs = "(" + rhs + ")";
 259 |                 }
 260 |                 self.popScope();
 261 |                 lhs = self.text.join("");
 262 |                 if (obj.left.type === "BinaryExpression") {
 263 |                     lhs = "(" + lhs + ")";
 264 |                 }
 265 |                 self.popScope();
 266 |                 self.append(lhs + " " + obj.operator + " " + rhs);
 267 |             });
 268 |             tw.walk('right');
 269 |             tw.invoke(function () {
 270 |                 self.freshScope();
 271 |             });
 272 |             tw.walk('left');
 273 |             this.freshScope();
 274 |         },
 275 | 
 276 |         Block: function (tw, parent, obj, name) {
 277 |             var i, self = this, statements = [];
 278 |             this.incDepth();
 279 |             tw.invoke(function () {
 280 |                 self.decDepth();
 281 |                 var text = statements.join("");
 282 |                 self.withFreshScopeJoin(function () {
 283 |                     self.append("{\n");
 284 |                     self.append(text);
 285 |                     self.indent();
 286 |                     self.append("}");
 287 |                 });
 288 |                 self.needsTermination = false;
 289 |             });
 290 |             this.formatStatements(tw, statements, obj.statements);
 291 |         },
 292 | 
 293 |         BooleanLiteral: function (tw, parent, obj, name) {
 294 |             this.append(obj.value);
 295 |         },
 296 | 
 297 |         BreakStatement: function (tw, parent, obj, name) {
 298 |             if (obj.label) {
 299 |                 this.append("break " + obj.label);
 300 |             } else {
 301 |                 this.append("break");
 302 |             }
 303 |         },
 304 | 
 305 |         CaseClause: function (tw, parent, obj, name) {
 306 |             var i, self = this, statements = [];
 307 |             this.incDepth();
 308 |             tw.invoke(function () {
 309 |                 var text, selector;
 310 |                 self.decDepth();
 311 |                 text = statements.join("");
 312 |                 selector = self.text.join("");
 313 |                 self.popScope();
 314 |                 self.append("case " + selector + ":\n" + text);
 315 |                 self.needsTermination = false;
 316 |             });
 317 |             tw.walk('selector');
 318 |             tw.invoke(function () { self.freshScope(); });
 319 |             this.formatStatements(tw, statements, obj.statements);
 320 |         },
 321 | 
 322 |         Catch: function (tw, parent, obj, name) {
 323 |             var self = this;
 324 |             tw.invoke(function () {
 325 |                 var body = self.text.join("");
 326 |                 self.popScope();
 327 |                 self.append(" catch (" + obj.identifier + ") " + body);
 328 |                 self.needsTermination = false;
 329 |             });
 330 |             tw.walk('block');
 331 |             this.freshScope();
 332 |         },
 333 | 
 334 |         ConditionalExpression: function (tw, parent, obj, name) {
 335 |             var self = this;
 336 |             tw.invoke(function () {
 337 |                 var cond, trueExpr, falseExpr;
 338 |                 falseExpr = self.text.join("");
 339 |                 self.popScope();
 340 |                 trueExpr = self.text.join("");
 341 |                 self.popScope();
 342 |                 cond = self.text.join("");
 343 |                 self.popScope();
 344 |                 // TODO: the surrounding parenthesis are not always needed
 345 |                 self.append("(" + cond + " ? " + trueExpr + " : " + falseExpr + ")");
 346 |             });
 347 |             tw.walk('falseExpression');
 348 |             tw.invoke(function () {
 349 |                 self.freshScope();
 350 |             });
 351 |             tw.walk('trueExpression');
 352 |             tw.invoke(function () {
 353 |                 self.freshScope();
 354 |             });
 355 |             tw.walk('condition');
 356 |             this.freshScope();
 357 |         },
 358 | 
 359 |         ContinueStatement: function (tw, parent, obj, name) {
 360 |             if (obj.label) {
 361 |                 this.append("continue " + obj.label);
 362 |             } else {
 363 |                 this.append("continue");
 364 |             }
 365 |         },
 366 | 
 367 |         DebuggerStatement: function (tw, parent, obj, name) {
 368 |             this.append("debugger");
 369 |         },
 370 | 
 371 |         DefaultClause: function (tw, parent, obj, name) {
 372 |             var i, self = this, statements = [];
 373 |             this.incDepth();
 374 |             tw.invoke(function () {
 375 |                 self.decDepth();
 376 |                 var text = statements.join("");
 377 |                 self.append("default:\n" + text);
 378 |                 self.needsTermination = false;
 379 |             });
 380 |             this.formatStatements(tw, statements, obj.statements);
 381 |         },
 382 | 
 383 |         DoWhileStatement: function (tw, parent, obj, name) {
 384 |             var condition, self = this;
 385 |             tw.invoke(function () {
 386 |                 var body = self.text.join("");
 387 |                 self.popScope();
 388 |                 self.withFreshScopeJoin(function () {
 389 |                     self.append("do");
 390 |                     if (obj.statement.type === "Block") {
 391 |                         self.append(" ");
 392 |                         self.append(body);
 393 |                         self.append(" ");
 394 |                     } else {
 395 |                         self.append("\n");
 396 |                         self.incDepth();
 397 |                         self.indent();
 398 |                         self.decDepth();
 399 |                         self.append(body);
 400 |                         self.terminate();
 401 |                         self.append("\n");
 402 |                         self.indent();
 403 |                     }
 404 |                     self.append("while (" + condition + ")");
 405 |                 });
 406 |                 self.needsTermination = true;
 407 |             });
 408 |             tw.walk('statement');
 409 |             tw.invoke(function () {
 410 |                 condition = self.text.join("");
 411 |                 self.popAndFreshScope();
 412 |             });
 413 |             tw.walk('condition');
 414 |             this.freshScope();
 415 |         },
 416 | 
 417 |         EmptyStatement: function (tw, parent, obj, name) {
 418 |             this.needsTermination = false;
 419 |         },
 420 | 
 421 |         Finally: function (tw, parent, obj, name) {
 422 |             var self = this;
 423 |             tw.invoke(function () {
 424 |                 var body = self.text.join("");
 425 |                 self.popScope();
 426 |                 self.append(" finally " + body);
 427 |                 self.needsTermination = false;
 428 |             });
 429 |             tw.walk('block');
 430 |             this.freshScope();
 431 |         },
 432 | 
 433 |         ForInStatement: function (tw, parent, obj, name) {
 434 |             this.forWhileLoop(
 435 |                 tw, ['iterator', 'collection'], obj,
 436 |                 function (elements) {
 437 |                     if ("VariableDeclaration" === obj.iterator.type) {
 438 |                         elements.iterator = "var " + elements.iterator;
 439 |                     }
 440 |                     return "for (" + elements.iterator + " in " +
 441 |                         elements.collection + ")";
 442 |                 });
 443 |         },
 444 | 
 445 |         ForStatement: function (tw, parent, obj, name) {
 446 |             this.forWhileLoop(
 447 |                 tw, ['initializer', 'test', 'counter'], obj,
 448 |                 function (elements) {
 449 |                     return "for (" + elements.initializer + "; " +
 450 |                         elements.test + "; " + elements.counter + ")";
 451 |                 });
 452 |         },
 453 | 
 454 |         Function: function (tw, parent, obj, name) {
 455 |             var i, self = this, statements = [];
 456 |             this.incDepth();
 457 |             tw.invoke(function () {
 458 |                 self.decDepth();
 459 |                 var text = statements.join("");
 460 |                 self.withFreshScopeJoin(function () {
 461 |                     self.append("function ");
 462 |                     if (obj.name) {
 463 |                         self.append(obj.name + " ");
 464 |                     }
 465 |                     self.append("(");
 466 |                     self.append(obj.params.join(", "));
 467 |                     self.append(") {\n");
 468 |                     self.append(text);
 469 |                     self.indent();
 470 |                     self.append("}");
 471 |                 });
 472 |                 self.needsTermination = false;
 473 |             });
 474 |             this.formatStatements(tw, statements, obj.elements);
 475 |         },
 476 | 
 477 |         FunctionCall: function (tw, parent, obj, name) {
 478 |             var args, self = this;
 479 |             tw.invoke(function () {
 480 |                 var name, postfix;
 481 |                 name = self.text.join("");
 482 |                 postfix = "";
 483 |                 self.popScope();
 484 |                 self.withFreshScopeJoin(function () {
 485 |                     if ("Function" === obj.name.type) {
 486 |                         self.append("(" + name);
 487 |                         postfix = ")";
 488 |                     } else {
 489 |                         self.append(name);
 490 |                     }
 491 |                     self.append("(" + args + ")" + postfix);
 492 |                 });
 493 |             });
 494 |             tw.walk('name');
 495 |             tw.invoke(function () {
 496 |                 var text = self.text.join(", ");
 497 |                 args = text;
 498 |                 self.popAndFreshScope();
 499 |             });
 500 |             tw.walk('arguments');
 501 |             this.freshScope();
 502 |         },
 503 | 
 504 |         GetterDefinition: function (tw, parent, obj, name) {
 505 |             var i, self = this, statements = [];
 506 |             this.incDepth();
 507 |             tw.invoke(function () {
 508 |                 self.decDepth();
 509 |                 var text = statements.join("");
 510 |                 self.withFreshScopeJoin(function () {
 511 |                     self.append("get " + obj.name + "() {\n");
 512 |                     self.append(text);
 513 |                     self.indent();
 514 |                     self.append("}");
 515 |                 });
 516 |             });
 517 |             this.formatStatements(tw, statements, obj.body);
 518 |         },
 519 | 
 520 |         IfStatement: function (tw, parent, obj, name) {
 521 |             var condition, trueSt, falseSt, formatBranch, self = this;
 522 | 
 523 |             formatBranch = function (text, branch, postfix) {
 524 |                 if ("Block" === branch.type) {
 525 |                     self.append(" ");
 526 |                 } else {
 527 |                     self.append("\n");
 528 |                     self.incDepth();
 529 |                     self.indent();
 530 |                     self.decDepth();
 531 |                 }
 532 |                 self.append(text);
 533 |                 if (postfix) {
 534 |                     if ("Block" === branch.type) {
 535 |                         self.append(" ");
 536 |                         self.append(postfix);
 537 |                     } else {
 538 |                         self.append("\n");
 539 |                         self.indent();
 540 |                         self.append(postfix);
 541 |                     }
 542 |                 }
 543 |             };
 544 | 
 545 |             this.incDepth();
 546 |             if (obj.elseStatement) {
 547 |                 tw.invoke(function () {
 548 |                     falseSt = self.text.join("");
 549 |                     self.popScope();
 550 |                     self.withFreshScopeJoin(function () {
 551 |                         self.append("if (" + condition + ")");
 552 |                         formatBranch(trueSt, obj.ifStatement, "else");
 553 |                         formatBranch(falseSt, obj.elseStatement);
 554 |                     });
 555 |                     self.needsTermination = false;
 556 |                 });
 557 |                 tw.walk('elseStatement');
 558 |                 tw.invoke(function () {
 559 |                     trueSt = self.text.join("");
 560 |                     self.popAndFreshScope();
 561 |                 });
 562 |             } else {
 563 |                 tw.invoke(function () {
 564 |                     trueSt = self.text.join("");
 565 |                     self.popScope();
 566 |                     self.withFreshScopeJoin(function () {
 567 |                         self.append("if (" + condition + ")");
 568 |                         formatBranch(trueSt, obj.ifStatement);
 569 |                         condition = self.text.join("");
 570 |                     });
 571 |                     self.needsTermination = false;
 572 |                 });
 573 |             }
 574 |             tw.walk('ifStatement');
 575 |             tw.invoke(function () {
 576 |                 self.decDepth();
 577 |                 condition = self.text.join("");
 578 |                 self.popAndFreshScope();
 579 |             });
 580 |             tw.walk('condition');
 581 |             this.freshScope();
 582 |         },
 583 | 
 584 |         LabelledStatement: function (tw, parent, obj, name) {
 585 |             var self = this;
 586 |             tw.invoke(function () {
 587 |                 var statement = self.text.join("");
 588 |                 self.popScope();
 589 |                 self.append(obj.label + ": " + statement);
 590 |             });
 591 |             tw.walk('statement');
 592 |             this.freshScope();
 593 |         },
 594 | 
 595 |         NewOperator: function (tw, parent, obj, name) {
 596 |             var self = this;
 597 |             tw.invoke(function () {
 598 |                 var ctr, args;
 599 |                 args = self.text.join(", ");
 600 |                 self.popScope();
 601 |                 ctr = self.text.join("");
 602 |                 self.popScope();
 603 |                 self.append("new " + ctr + "(" + args + ")");
 604 |             });
 605 |             tw.walk('arguments');
 606 |             tw.invoke(function () { self.freshScope(); });
 607 |             tw.walk('constructor');
 608 |             this.freshScope();
 609 |         },
 610 | 
 611 |         NullLiteral: function (tw, parent, obj, name) {
 612 |             this.append("null");
 613 |         },
 614 | 
 615 |         NumericLiteral: function (tw, parent, obj, name) {
 616 |             this.append(obj.value);
 617 |         },
 618 | 
 619 |         ObjectLiteral: function (tw, parent, obj, name) {
 620 |             var self = this;
 621 |             tw.invoke(function () {
 622 |                 var props = self.text.join(", ");
 623 |                 self.popScope();
 624 |                 self.append("{" + props + "}");
 625 |             });
 626 |             tw.walk('properties');
 627 |             this.freshScope();
 628 |         },
 629 | 
 630 |         PostfixExpression: function (tw, parent, obj, name) {
 631 |             var self = this;
 632 |             tw.invoke(function () {
 633 |                 var expression = self.text.join("");
 634 |                 self.popScope();
 635 |                 self.append(expression + obj.operator);
 636 |             });
 637 |             tw.walk('expression');
 638 |             this.freshScope();
 639 |         },
 640 | 
 641 |         Program: function (tw, parent, obj, name) {
 642 |             var i, self = this, elements = [];
 643 |             tw.invoke(function () { self.append(elements.join("")); });
 644 |             this.formatStatements(tw, elements, obj.elements);
 645 |         },
 646 | 
 647 |         PropertyAccess: function (tw, parent, obj, name) {
 648 |             var field, self = this, simple = String === obj.name.constructor;
 649 |             tw.invoke(function () {
 650 |                 var base = self.text.join("");
 651 |                 self.popScope();
 652 |                 if (simple) {
 653 |                     self.append(base + "." + field);
 654 |                 } else {
 655 |                     self.append(base + "[" + field + "]");
 656 |                 }
 657 |             });
 658 |             tw.walk('base');
 659 |             this.freshScope();
 660 |             if (simple) {
 661 |                 field = obj.name;
 662 |             } else {
 663 |                 tw.invoke(function () {
 664 |                     field = self.text.join("");
 665 |                     self.popAndFreshScope();
 666 |                 });
 667 |                 tw.walk('name');
 668 |             }
 669 |         },
 670 | 
 671 |         PropertyAssignment: function (tw, parent, obj, name) {
 672 |             var self = this;
 673 |             tw.invoke(function () {
 674 |                 var value = self.text.join("");
 675 |                 self.popScope();
 676 |                 self.append(obj.name + ": " + value);
 677 |             });
 678 |             tw.walk('value');
 679 |             this.freshScope();
 680 |         },
 681 | 
 682 |         RegularExpressionLiteral: function (tw, parent, obj, name) {
 683 |             this.append("/" + obj.body + "/" + obj.flags);
 684 |         },
 685 | 
 686 |         ReturnStatement: function (tw, parent, obj, name) {
 687 |             var self;
 688 |             if (obj.value) {
 689 |                 self = this;
 690 |                 tw.invoke(function () {
 691 |                     var value = self.text.join("");
 692 |                     self.popScope();
 693 |                     self.append("return " + value);
 694 |                 });
 695 |                 tw.walk('value');
 696 |                 this.freshScope();
 697 |             } else {
 698 |                 this.append("return");
 699 |             }
 700 |         },
 701 | 
 702 |         SetterDefinition: function (tw, parent, obj, name) {
 703 |             var i, self = this, statements = [];
 704 |             this.incDepth();
 705 |             tw.invoke(function () {
 706 |                 self.decDepth();
 707 |                 var text = statements.join("");
 708 |                 self.withFreshScopeJoin(function () {
 709 |                     self.append("set " + obj.name + "(" + obj.param + ") {\n");
 710 |                     self.append(text);
 711 |                     self.indent();
 712 |                     self.append("}");
 713 |                 });
 714 |             });
 715 |             this.formatStatements(tw, statements, obj.body);
 716 |         },
 717 | 
 718 |         StringLiteral: function (tw, parent, obj, name) {
 719 |             var str = obj.value;
 720 |             str = str.replace(/\\/g, "\\\\");
 721 |             str = str.replace(/\'/g, "\\\'");
 722 |             str = str.replace(/\"/g, '\\\"');
 723 |             str = str.replace(/[\b]/g, "\\b"); // \b on its own matches boundary
 724 |             str = str.replace(/\f/g, "\\f");
 725 |             str = str.replace(/\r/g, "\\r");
 726 |             str = str.replace(/\n/g, "\\n");
 727 |             str = str.replace(/\t/g, "\\t");
 728 |             this.append('"' + str + '"');
 729 |         },
 730 | 
 731 |         SwitchStatement: function (tw, parent, obj, name) {
 732 |             var i, self = this, clauses = [];
 733 |             tw.invoke(function () {
 734 |                 var condition, body;
 735 |                 self.decDepth();
 736 |                 condition = self.text.join("");
 737 |                 self.popScope();
 738 |                 self.withFreshScopeJoin(function () {
 739 |                     body = clauses.join("");
 740 |                     self.append("switch (" + condition + ") {\n");
 741 |                     self.append(body);
 742 |                     self.indent();
 743 |                     self.append("}");
 744 |                 });
 745 |                 self.needsTermination = false;
 746 |             });
 747 |             tw.walk('expression');
 748 |             tw.invoke(function () {
 749 |                 self.freshScope();
 750 |                 self.incDepth();
 751 |             });
 752 |             this.formatStatements(tw, clauses, obj.clauses);
 753 |         },
 754 | 
 755 |         This: function (tw, parent, obj, name) {
 756 |             this.append("this");
 757 |         },
 758 | 
 759 |         ThrowStatement: function (tw, parent, obj, name) {
 760 |             var self = this;
 761 |             tw.invoke(function () {
 762 |                 var body = self.text.join("");
 763 |                 self.popScope();
 764 |                 self.append("throw " + body);
 765 |             });
 766 |             tw.walk('exception');
 767 |             this.freshScope();
 768 |         },
 769 | 
 770 |         TryStatement: function (tw, parent, obj, name) {
 771 |             var self = this;
 772 |             if (obj['finally']) {
 773 |                 tw.walk('finally');
 774 |             }
 775 |             tw.walk('catch');
 776 |             tw.invoke(function () {
 777 |                 var body = self.text.join("");
 778 |                 self.popScope();
 779 |                 self.append("try " + body);
 780 |                 self.needsTermination = false;
 781 |             });
 782 |             tw.walk('block');
 783 |             this.freshScope();
 784 |         },
 785 | 
 786 |         UnaryExpression: function (tw, parent, obj, name) {
 787 |             var self = this;
 788 |             tw.invoke(function () {
 789 |                 var text = self.text.join("");
 790 |                 self.popScope();
 791 |                 if (obj.operator.length > 2) { // delete, typeof, or void
 792 |                     self.append(obj.operator + " " + text);
 793 |                 } else { // ++, --, +, -, ~, !
 794 |                     self.append(obj.operator + text);
 795 |                 }
 796 |             });
 797 |             tw.walk('expression');
 798 |             this.freshScope();
 799 |         },
 800 | 
 801 |         Variable: function (tw, parent, obj, name) {
 802 |             this.append(obj.name);
 803 |         },
 804 | 
 805 |         VariableDeclaration: function (tw, parent, obj, name) {
 806 |             var self = this;
 807 |             if (obj.value) {
 808 |                 tw.invoke(function () {
 809 |                     var value = self.text.join("");
 810 |                     self.popScope();
 811 |                     self.append(obj.name + " = " + value);
 812 |                 });
 813 |                 tw.walk('value');
 814 |                 this.freshScope();
 815 |             } else {
 816 |                 this.append(obj.name);
 817 |             }
 818 |         },
 819 | 
 820 |         VariableStatement: function (tw, parent, obj, name) {
 821 |             var i, self = this;
 822 |             self = this;
 823 |             tw.invoke(function () {
 824 |                 var decls = self.text.join(", ");
 825 |                 self.popScope();
 826 |                 self.append("var " + decls);
 827 |                 self.needsTermination = true;
 828 |             });
 829 |             tw.walk('declarations');
 830 |             this.freshScope();
 831 |         },
 832 | 
 833 |         WhileStatement: function (tw, parent, obj, name) {
 834 |             this.forWhileLoop(
 835 |                 tw, ['condition'], obj,
 836 |                 function (elements) {
 837 |                     return "while (" + elements.condition + ")";
 838 |                 });
 839 |         },
 840 | 
 841 |         WithStatement: function (tw, parent, obj, name) {
 842 |             this.forWhileLoop(
 843 |                 tw, ['environment'], obj,
 844 |                 function (elements) {
 845 |                     return "with (" + elements.environment + ")";
 846 |                 });
 847 |         }
 848 |     };
 849 | 
 850 |     function ProxyInjector(ast, atomize, ignore) {
 851 |         this.ast = ast;
 852 |         this.treeWalker = new TreeWalker(ast, this);
 853 |         if (undefined !== ignore) {
 854 |             this.ignore = ignore;
 855 |         }
 856 |         if (undefined !== atomize) {
 857 |             this.atomize = atomize;
 858 |             this.ignore.push(atomize);
 859 |         }
 860 |     }
 861 | 
 862 |     ProxyInjector.prototype = {
 863 | 
 864 |         atomize: 'atomize',
 865 |         ignore: ['atomize'],
 866 | 
 867 |         transform: function () {
 868 |             this.treeWalker.traverse();
 869 |         },
 870 | 
 871 |         ignored: function (name) {
 872 |             return -1 !== this.ignore.indexOf(name);
 873 |         },
 874 | 
 875 |         AssignmentExpression: function (tw, parent, obj, name) {
 876 |             var simple, self = this;
 877 |             if (obj.left.type === 'PropertyAccess') {
 878 |                 simple = String === obj.left.name.constructor;
 879 |                 tw.invoke(function () {
 880 |                     var rhs, lhs, body, base, field, setter;
 881 |                     base = new PrettyPrinter(obj.left.base).print();
 882 |                     if (self.ignored(base)) {
 883 |                         return;
 884 |                     }
 885 | 
 886 |                     rhs = new PrettyPrinter(obj.right).print();
 887 | 
 888 |                     if (simple) {
 889 |                         field = obj.left.name;
 890 |                         setter = "'" + field + "'";
 891 |                     } else {
 892 |                         field = new PrettyPrinter(obj.left.name).print();
 893 |                         setter = field;
 894 |                     }
 895 | 
 896 |                     if ("=" !== obj.operator) {
 897 |                         rhs = self.atomize + ".access(" + base + ", " + setter + ") " +
 898 |                             obj.operator.substring(0, obj.operator.length - 1) + " " + rhs;
 899 |                     }
 900 | 
 901 |                     body = self.atomize + ".assign(" + base + ", " + setter + ", " + rhs + ")";
 902 |                     parent[name] = parser.parse(body).elements[0];
 903 |                 });
 904 |                 tw.walk(obj.left, 'base');
 905 |                 if (!simple) {
 906 |                     tw.walk(obj.left, 'name');
 907 |                 }
 908 |             } else {
 909 |                 tw.walk('left');
 910 |             }
 911 |             tw.walk('right');
 912 |         },
 913 | 
 914 |         PropertyAccess: function (tw, parent, obj, name) {
 915 |             var self = this, simple = String === obj.name.constructor;
 916 |             tw.invoke(function () {
 917 |                 var body, base, field, getter;
 918 |                 base = new PrettyPrinter(obj.base).print();
 919 |                 if (self.ignored(base)) {
 920 |                     return;
 921 |                 }
 922 | 
 923 |                 if (simple) {
 924 |                     field = obj.name;
 925 |                     getter = "'" + field + "'";
 926 |                 } else {
 927 |                     field = new PrettyPrinter(obj.name).print();
 928 |                     getter = field;
 929 |                 }
 930 | 
 931 |                 body = self.atomize + ".access(" + base + ", " + getter + ")";
 932 |                 parent[name] = parser.parse(body).elements[0];
 933 |             });
 934 |             tw.walk('base');
 935 |             if (!simple) {
 936 |                 tw.walk('name');
 937 |             }
 938 |         },
 939 | 
 940 |         ForInStatement: function (tw, parent, obj, name) {
 941 |             var self = this;
 942 |             tw.invoke(function () {
 943 |                 var body, collection;
 944 |                 collection = new PrettyPrinter(obj.collection).print();
 945 | 
 946 |                 if (self.ignored(collection)) {
 947 |                     return;
 948 |                 }
 949 | 
 950 |                 body = self.atomize + ".enumerate(" + collection + ")";
 951 |                 obj.collection = parser.parse(body).elements[0];
 952 |             });
 953 |             tw.walk('iterator');
 954 |             tw.walk('collection');
 955 |         },
 956 | 
 957 |         BinaryExpression: function (tw, parent, obj, name) {
 958 |             var self = this;
 959 |             tw.invoke(function () {
 960 |                 if ("in" === obj.operator) {
 961 |                     var body, container;
 962 |                     container = new PrettyPrinter(obj.right).print();
 963 |                     if (self.ignored(container)) {
 964 |                         return;
 965 |                     }
 966 |                     body = self.atomize + ".has(" + container + ", " +
 967 |                         (new PrettyPrinter(obj.left).print()) + ")";
 968 |                     parent[name] = parser.parse(body).elements[0];
 969 |                 }
 970 |             });
 971 |             tw.walk('right');
 972 |             tw.walk('left');
 973 |         },
 974 | 
 975 |         UnaryExpression: function (tw, parent, obj, name) {
 976 |             var self = this, deleting;;
 977 |             deleting = "delete" === obj.operator && "PropertyAccess" === obj.expression.type;
 978 |             if (deleting) {
 979 |                 tw.invoke(function () {
 980 |                     // we just want to swap the 'access' with a 'erase' call...
 981 |                     parent[name].expression.name.name = 'erase'
 982 |                     // ... and wipe out the delete UnaryExpression
 983 |                     parent[name] = parent[name].expression;
 984 |                 });
 985 |             }
 986 |             tw.walk('expression');
 987 |         }
 988 | 
 989 |     };
 990 | 
 991 |     exports.parse = parser.parse;
 992 |     exports.TreeWalker = TreeWalker;
 993 |     exports.PrettyPrinter = PrettyPrinter;
 994 |     exports.ProxyInjector = ProxyInjector;
 995 | 
 996 |     exports.test = function () {
 997 |         var ast, pi, pp;
 998 |         ast = parser.parse("a.b['c'] = d.e = f['' + g]; for (var j in a) { console.log(j); }; console.log('b' in a);");
 999 |         pi = new ProxyInjector(ast);
1000 |         pi.transform();
1001 |         pp = new PrettyPrinter(pi.ast);
1002 |         return pp.print();
1003 |     };
1004 | 
1005 | }());
1006 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "atomize-client",
 3 |     "author": "Matthew Sackman",
 4 |     "version": "0.4.16",
 5 |     "repository": {
 6 |         "type": "git",
 7 |         "url": "git://github.com/atomizejs/atomize-client.git"
 8 |     },
 9 |     "main": "index",
10 |     "bin": {
11 |         "atomize-translate": "./lib/transform.js"
12 |     },
13 |     "description": "Client library for AtomizeJS: JavaScript DSTM",
14 |     "dependencies": {
15 |         "cereal": ">=0.2.0",
16 |         "sockjs": ">=0.3.0"
17 |     },
18 |     "devDependencies": {
19 |         "nodeunit": "*"
20 |     },
21 |     "homepage": "http://atomizejs.github.com/",
22 |     "keywords": ["software transactional memory", "stm",
23 |                  "distribution", "synchronisation", "synchronization",
24 |                  "rpc", "remote procedure call"
25 |                 ]
26 | }
27 | 


--------------------------------------------------------------------------------