testing/mochitest/MochiKit/Base.js

   1 /***
   2
   3 MochiKit.Base 1.4
   4
   5 See <http://mochikit.com/> for documentation, downloads, license, etc.
   6
   7 (c) 2005 Bob Ippolito.  All rights Reserved.
   8
   9 ***/
  10
  11 if (typeof(dojo) != 'undefined') {
  12     dojo.provide("MochiKit.Base");
  13 }
  14 if (typeof(MochiKit) == 'undefined') {
  15     MochiKit = {};
  16 }
  17 if (typeof(MochiKit.Base) == 'undefined') {
  18     MochiKit.Base = {};
  19 }
  20 if (typeof(MochiKit.__export__) == "undefined") {
  21     MochiKit.__export__ = (MochiKit.__compat__  ||
  22         (typeof(JSAN) == 'undefined' && typeof(dojo) == 'undefined')
  23     );
  24 }
  25
  26 MochiKit.Base.VERSION = "1.4";
  27 MochiKit.Base.NAME = "MochiKit.Base";
  28 /** @id MochiKit.Base.update */
  29 MochiKit.Base.update = function (self, obj/*, ... */) {
  30     if (self === null) {
  31         self = {};
  32     }
  33     for (var i = 1; i < arguments.length; i++) {
  34         var o = arguments[i];
  35         if (typeof(o) != 'undefined' && o !== null) {
  36             for (var k in o) {
  37                 self[k] = o[k];
  38             }
  39         }
  40     }
  41     return self;
  42 };
  43
  44 MochiKit.Base.update(MochiKit.Base, {
  45     __repr__: function () {
  46         return "[" + this.NAME + " " + this.VERSION + "]";
  47     },
  48
  49     toString: function () {
  50         return this.__repr__();
  51     },
  52
  53     /** @id MochiKit.Base.camelize */
  54     camelize: function (selector) {
  55         /* from dojo.style.toCamelCase */
  56         var arr = selector.split('-');
  57         var cc = arr[0];
  58         for (var i = 1; i < arr.length; i++) {
  59             cc += arr[i].charAt(0).toUpperCase() + arr[i].substring(1);
  60         }
  61         return cc;
  62     },
  63
  64     /** @id MochiKit.Base.counter */
  65     counter: function (n/* = 1 */) {
  66         if (arguments.length === 0) {
  67             n = 1;
  68         }
  69         return function () {
  70             return n++;
  71         };
  72     },
  73
  74     /** @id MochiKit.Base.clone */
  75     clone: function (obj) {
  76         var me = arguments.callee;
  77         if (arguments.length == 1) {
  78             me.prototype = obj;
  79             return new me();
  80         }
  81     },
  82
  83     _flattenArray: function (res, lst) {
  84         for (var i = 0; i < lst.length; i++) {
  85             var o = lst[i];
  86             if (o instanceof Array) {
  87                 arguments.callee(res, o);
  88             } else {
  89                 res.push(o);
  90             }
  91         }
  92         return res;
  93     },
  94
  95     /** @id MochiKit.Base.flattenArray */
  96     flattenArray: function (lst) {
  97         return MochiKit.Base._flattenArray([], lst);
  98     },
  99
 100     /** @id MochiKit.Base.flattenArguments */
 101     flattenArguments: function (lst/* ...*/) {
 102         var res = [];
 103         var m = MochiKit.Base;
 104         var args = m.extend(null, arguments);
 105         while (args.length) {
 106             var o = args.shift();
 107             if (o && typeof(o) == "object" && typeof(o.length) == "number") {
 108                 for (var i = o.length - 1; i >= 0; i--) {
 109                     args.unshift(o[i]);
 110                 }
 111             } else {
 112                 res.push(o);
 113             }
 114         }
 115         return res;
 116     },
 117
 118     /** @id MochiKit.Base.extend */
 119     extend: function (self, obj, /* optional */skip) {
 120         // Extend an array with an array-like object starting
 121         // from the skip index
 122         if (!skip) {
 123             skip = 0;
 124         }
 125         if (obj) {
 126             // allow iterable fall-through, but skip the full isArrayLike
 127             // check for speed, this is called often.
 128             var l = obj.length;
 129             if (typeof(l) != 'number' /* !isArrayLike(obj) */) {
 130                 if (typeof(MochiKit.Iter) != "undefined") {
 131                     obj = MochiKit.Iter.list(obj);
 132                     l = obj.length;
 133                 } else {
 134                     throw new TypeError("Argument not an array-like and MochiKit.Iter not present");
 135                 }
 136             }
 137             if (!self) {
 138                 self = [];
 139             }
 140             for (var i = skip; i < l; i++) {
 141                 self.push(obj[i]);
 142             }
 143         }
 144         // This mutates, but it's convenient to return because
 145         // it's often used like a constructor when turning some
 146         // ghetto array-like to a real array
 147         return self;
 148     },
 149
 150
 151     /** @id MochiKit.Base.updatetree */
 152     updatetree: function (self, obj/*, ...*/) {
 153         if (self === null) {
 154             self = {};
 155         }
 156         for (var i = 1; i < arguments.length; i++) {
 157             var o = arguments[i];
 158             if (typeof(o) != 'undefined' && o !== null) {
 159                 for (var k in o) {
 160                     var v = o[k];
 161                     if (typeof(self[k]) == 'object' && typeof(v) == 'object') {
 162                         arguments.callee(self[k], v);
 163                     } else {
 164                         self[k] = v;
 165                     }
 166                 }
 167             }
 168         }
 169         return self;
 170     },
 171
 172     /** @id MochiKit.Base.setdefault */
 173     setdefault: function (self, obj/*, ...*/) {
 174         if (self === null) {
 175             self = {};
 176         }
 177         for (var i = 1; i < arguments.length; i++) {
 178             var o = arguments[i];
 179             for (var k in o) {
 180                 if (!(k in self)) {
 181                     self[k] = o[k];
 182                 }
 183             }
 184         }
 185         return self;
 186     },
 187
 188     /** @id MochiKit.Base.keys */
 189     keys: function (obj) {
 190         var rval = [];
 191         for (var prop in obj) {
 192             rval.push(prop);
 193         }
 194         return rval;
 195     },
 196
 197     /** @id MochiKit.Base.values */
 198     values: function (obj) {
 199         var rval = [];
 200         for (var prop in obj) {
 201             rval.push(obj[prop]);
 202         }
 203         return rval;
 204     },
 205
 206      /** @id MochiKit.Base.items */
 207     items: function (obj) {
 208         var rval = [];
 209         var e;
 210         for (var prop in obj) {
 211             var v;
 212             try {
 213                 v = obj[prop];
 214             } catch (e) {
 215                 continue;
 216             }
 217             rval.push([prop, v]);
 218         }
 219         return rval;
 220     },
 221
 222
 223     _newNamedError: function (module, name, func) {
 224         func.prototype = new MochiKit.Base.NamedError(module.NAME + "." + name);
 225         module[name] = func;
 226     },
 227
 228
 229     /** @id MochiKit.Base.operator */
 230     operator: {
 231         // unary logic operators
 232         /** @id MochiKit.Base.truth */
 233         truth: function (a) { return !!a; },
 234         /** @id MochiKit.Base.lognot */
 235         lognot: function (a) { return !a; },
 236         /** @id MochiKit.Base.identity */
 237         identity: function (a) { return a; },
 238
 239         // bitwise unary operators
 240         /** @id MochiKit.Base.not */
 241         not: function (a) { return ~a; },
 242         /** @id MochiKit.Base.neg */
 243         neg: function (a) { return -a; },
 244
 245         // binary operators
 246         /** @id MochiKit.Base.add */
 247         add: function (a, b) { return a + b; },
 248         /** @id MochiKit.Base.sub */
 249         sub: function (a, b) { return a - b; },
 250         /** @id MochiKit.Base.div */
 251         div: function (a, b) { return a / b; },
 252         /** @id MochiKit.Base.mod */
 253         mod: function (a, b) { return a % b; },
 254         /** @id MochiKit.Base.mul */
 255         mul: function (a, b) { return a * b; },
 256
 257         // bitwise binary operators
 258         /** @id MochiKit.Base.and */
 259         and: function (a, b) { return a & b; },
 260         /** @id MochiKit.Base.or */
 261         or: function (a, b) { return a | b; },
 262         /** @id MochiKit.Base.xor */
 263         xor: function (a, b) { return a ^ b; },
 264         /** @id MochiKit.Base.lshift */
 265         lshift: function (a, b) { return a << b; },
 266         /** @id MochiKit.Base.rshift */
 267         rshift: function (a, b) { return a >> b; },
 268         /** @id MochiKit.Base.zrshift */
 269         zrshift: function (a, b) { return a >>> b; },
 270
 271         // near-worthless built-in comparators
 272         /** @id MochiKit.Base.eq */
 273         eq: function (a, b) { return a == b; },
 274         /** @id MochiKit.Base.ne */
 275         ne: function (a, b) { return a != b; },
 276         /** @id MochiKit.Base.gt */
 277         gt: function (a, b) { return a > b; },
 278         /** @id MochiKit.Base.ge */
 279         ge: function (a, b) { return a >= b; },
 280         /** @id MochiKit.Base.lt */
 281         lt: function (a, b) { return a < b; },
 282         /** @id MochiKit.Base.le */
 283         le: function (a, b) { return a <= b; },
 284
 285         // strict built-in comparators
 286         seq: function (a, b) { return a === b; },
 287         sne: function (a, b) { return a !== b; },
 288
 289         // compare comparators
 290         /** @id MochiKit.Base.ceq */
 291         ceq: function (a, b) { return MochiKit.Base.compare(a, b) === 0; },
 292         /** @id MochiKit.Base.cne */
 293         cne: function (a, b) { return MochiKit.Base.compare(a, b) !== 0; },
 294         /** @id MochiKit.Base.cgt */
 295         cgt: function (a, b) { return MochiKit.Base.compare(a, b) == 1; },
 296         /** @id MochiKit.Base.cge */
 297         cge: function (a, b) { return MochiKit.Base.compare(a, b) != -1; },
 298         /** @id MochiKit.Base.clt */
 299         clt: function (a, b) { return MochiKit.Base.compare(a, b) == -1; },
 300         /** @id MochiKit.Base.cle */
 301         cle: function (a, b) { return MochiKit.Base.compare(a, b) != 1; },
 302
 303         // binary logical operators
 304         /** @id MochiKit.Base.logand */
 305         logand: function (a, b) { return a && b; },
 306         /** @id MochiKit.Base.logor */
 307         logor: function (a, b) { return a || b; },
 308         /** @id MochiKit.Base.contains */
 309         contains: function (a, b) { return b in a; }
 310     },
 311
 312     /** @id MochiKit.Base.forwardCall */
 313     forwardCall: function (func) {
 314         return function () {
 315             return this[func].apply(this, arguments);
 316         };
 317     },
 318
 319     /** @id MochiKit.Base.itemgetter */
 320     itemgetter: function (func) {
 321         return function (arg) {
 322             return arg[func];
 323         };
 324     },
 325
 326     /** @id MochiKit.Base.typeMatcher */
 327     typeMatcher: function (/* typ */) {
 328         var types = {};
 329         for (var i = 0; i < arguments.length; i++) {
 330             var typ = arguments[i];
 331             types[typ] = typ;
 332         }
 333         return function () {
 334             for (var i = 0; i < arguments.length; i++) {
 335                 if (!(typeof(arguments[i]) in types)) {
 336                     return false;
 337                 }
 338             }
 339             return true;
 340         };
 341     },
 342
 343     /** @id MochiKit.Base.isNull */
 344     isNull: function (/* ... */) {
 345         for (var i = 0; i < arguments.length; i++) {
 346             if (arguments[i] !== null) {
 347                 return false;
 348             }
 349         }
 350         return true;
 351     },
 352
 353     /** @id MochiKit.Base.isUndefinedOrNull */
 354     isUndefinedOrNull: function (/* ... */) {
 355         for (var i = 0; i < arguments.length; i++) {
 356             var o = arguments[i];
 357             if (!(typeof(o) == 'undefined' || o === null)) {
 358                 return false;
 359             }
 360         }
 361         return true;
 362     },
 363
 364     /** @id MochiKit.Base.isEmpty */
 365     isEmpty: function (obj) {
 366         return !MochiKit.Base.isNotEmpty.apply(this, arguments);
 367     },
 368
 369     /** @id MochiKit.Base.isNotEmpty */
 370     isNotEmpty: function (obj) {
 371         for (var i = 0; i < arguments.length; i++) {
 372             var o = arguments[i];
 373             if (!(o && o.length)) {
 374                 return false;
 375             }
 376         }
 377         return true;
 378     },
 379
 380     /** @id MochiKit.Base.isArrayLike */
 381     isArrayLike: function () {
 382         for (var i = 0; i < arguments.length; i++) {
 383             var o = arguments[i];
 384             var typ = typeof(o);
 385             if (
 386                 (typ != 'object' && !(typ == 'function' && typeof(o.item) == 'function')) ||
 387                 o === null ||
 388                 typeof(o.length) != 'number' ||
 389                 o.nodeType === 3
 390             ) {
 391                 return false;
 392             }
 393         }
 394         return true;
 395     },
 396
 397     /** @id MochiKit.Base.isDateLike */
 398     isDateLike: function () {
 399         for (var i = 0; i < arguments.length; i++) {
 400             var o = arguments[i];
 401             if (typeof(o) != "object" || o === null
 402                     || typeof(o.getTime) != 'function') {
 403                 return false;
 404             }
 405         }
 406         return true;
 407     },
 408
 409
 410     /** @id MochiKit.Base.xmap */
 411     xmap: function (fn/*, obj... */) {
 412         if (fn === null) {
 413             return MochiKit.Base.extend(null, arguments, 1);
 414         }
 415         var rval = [];
 416         for (var i = 1; i < arguments.length; i++) {
 417             rval.push(fn(arguments[i]));
 418         }
 419         return rval;
 420     },
 421
 422     /** @id MochiKit.Base.map */
 423     map: function (fn, lst/*, lst... */) {
 424         var m = MochiKit.Base;
 425         var itr = MochiKit.Iter;
 426         var isArrayLike = m.isArrayLike;
 427         if (arguments.length <= 2) {
 428             // allow an iterable to be passed
 429             if (!isArrayLike(lst)) {
 430                 if (itr) {
 431                     // fast path for map(null, iterable)
 432                     lst = itr.list(lst);
 433                     if (fn === null) {
 434                         return lst;
 435                     }
 436                 } else {
 437                     throw new TypeError("Argument not an array-like and MochiKit.Iter not present");
 438                 }
 439             }
 440             // fast path for map(null, lst)
 441             if (fn === null) {
 442                 return m.extend(null, lst);
 443             }
 444             // disabled fast path for map(fn, lst)
 445             /*
 446             if (false && typeof(Array.prototype.map) == 'function') {
 447                 // Mozilla fast-path
 448                 return Array.prototype.map.call(lst, fn);
 449             }
 450             */
 451             var rval = [];
 452             for (var i = 0; i < lst.length; i++) {
 453                 rval.push(fn(lst[i]));
 454             }
 455             return rval;
 456         } else {
 457             // default for map(null, ...) is zip(...)
 458             if (fn === null) {
 459                 fn = Array;
 460             }
 461             var length = null;
 462             for (i = 1; i < arguments.length; i++) {
 463                 // allow iterables to be passed
 464                 if (!isArrayLike(arguments[i])) {
 465                     if (itr) {
 466                         return itr.list(itr.imap.apply(null, arguments));
 467                     } else {
 468                         throw new TypeError("Argument not an array-like and MochiKit.Iter not present");
 469                     }
 470                 }
 471                 // find the minimum length
 472                 var l = arguments[i].length;
 473                 if (length === null || length > l) {
 474                     length = l;
 475                 }
 476             }
 477             rval = [];
 478             for (i = 0; i < length; i++) {
 479                 var args = [];
 480                 for (var j = 1; j < arguments.length; j++) {
 481                     args.push(arguments[j][i]);
 482                 }
 483                 rval.push(fn.apply(this, args));
 484             }
 485             return rval;
 486         }
 487     },
 488
 489     /** @id MochiKit.Base.xfilter */
 490     xfilter: function (fn/*, obj... */) {
 491         var rval = [];
 492         if (fn === null) {
 493             fn = MochiKit.Base.operator.truth;
 494         }
 495         for (var i = 1; i < arguments.length; i++) {
 496             var o = arguments[i];
 497             if (fn(o)) {
 498                 rval.push(o);
 499             }
 500         }
 501         return rval;
 502     },
 503
 504     /** @id MochiKit.Base.filter */
 505     filter: function (fn, lst, self) {
 506         var rval = [];
 507         // allow an iterable to be passed
 508         var m = MochiKit.Base;
 509         if (!m.isArrayLike(lst)) {
 510             if (MochiKit.Iter) {
 511                 lst = MochiKit.Iter.list(lst);
 512             } else {
 513                 throw new TypeError("Argument not an array-like and MochiKit.Iter not present");
 514             }
 515         }
 516         if (fn === null) {
 517             fn = m.operator.truth;
 518         }
 519         if (typeof(Array.prototype.filter) == 'function') {
 520             // Mozilla fast-path
 521             return Array.prototype.filter.call(lst, fn, self);
 522         } else if (typeof(self) == 'undefined' || self === null) {
 523             for (var i = 0; i < lst.length; i++) {
 524                 var o = lst[i];
 525                 if (fn(o)) {
 526                     rval.push(o);
 527                 }
 528             }
 529         } else {
 530             for (i = 0; i < lst.length; i++) {
 531                 o = lst[i];
 532                 if (fn.call(self, o)) {
 533                     rval.push(o);
 534                 }
 535             }
 536         }
 537         return rval;
 538     },
 539
 540
 541     _wrapDumbFunction: function (func) {
 542         return function () {
 543             // fast path!
 544             switch (arguments.length) {
 545                 case 0: return func();
 546                 case 1: return func(arguments[0]);
 547                 case 2: return func(arguments[0], arguments[1]);
 548                 case 3: return func(arguments[0], arguments[1], arguments[2]);
 549             }
 550             var args = [];
 551             for (var i = 0; i < arguments.length; i++) {
 552                 args.push("arguments[" + i + "]");
 553             }
 554             return eval("(func(" + args.join(",") + "))");
 555         };
 556     },
 557
 558     /** @id MochiKit.Base.methodcaller */
 559     methodcaller: function (func/*, args... */) {
 560         var args = MochiKit.Base.extend(null, arguments, 1);
 561         if (typeof(func) == "function") {
 562             return function (obj) {
 563                 return func.apply(obj, args);
 564             };
 565         } else {
 566             return function (obj) {
 567                 return obj[func].apply(obj, args);
 568             };
 569         }
 570     },
 571
 572     /** @id MochiKit.Base.method */
 573     method: function (self, func) {
 574         var m = MochiKit.Base;
 575         return m.bind.apply(this, m.extend([func, self], arguments, 2));
 576     },
 577
 578     /** @id MochiKit.Base.compose */
 579     compose: function (f1, f2/*, f3, ... fN */) {
 580         var fnlist = [];
 581         var m = MochiKit.Base;
 582         if (arguments.length === 0) {
 583             throw new TypeError("compose() requires at least one argument");
 584         }
 585         for (var i = 0; i < arguments.length; i++) {
 586             var fn = arguments[i];
 587             if (typeof(fn) != "function") {
 588                 throw new TypeError(m.repr(fn) + " is not a function");
 589             }
 590             fnlist.push(fn);
 591         }
 592         return function () {
 593             var args = arguments;
 594             for (var i = fnlist.length - 1; i >= 0; i--) {
 595                 args = [fnlist[i].apply(this, args)];
 596             }
 597             return args[0];
 598         };
 599     },
 600
 601     /** @id MochiKit.Base.bind */
 602     bind: function (func, self/* args... */) {
 603         if (typeof(func) == "string") {
 604             func = self[func];
 605         }
 606         var im_func = func.im_func;
 607         var im_preargs = func.im_preargs;
 608         var im_self = func.im_self;
 609         var m = MochiKit.Base;
 610         if (typeof(func) == "function" && typeof(func.apply) == "undefined") {
 611             // this is for cases where JavaScript sucks ass and gives you a
 612             // really dumb built-in function like alert() that doesn't have
 613             // an apply
 614             func = m._wrapDumbFunction(func);
 615         }
 616         if (typeof(im_func) != 'function') {
 617             im_func = func;
 618         }
 619         if (typeof(self) != 'undefined') {
 620             im_self = self;
 621         }
 622         if (typeof(im_preargs) == 'undefined') {
 623             im_preargs = [];
 624         } else  {
 625             im_preargs = im_preargs.slice();
 626         }
 627         m.extend(im_preargs, arguments, 2);
 628         var newfunc = function () {
 629             var args = arguments;
 630             var me = arguments.callee;
 631             if (me.im_preargs.length > 0) {
 632                 args = m.concat(me.im_preargs, args);
 633             }
 634             var self = me.im_self;
 635             if (!self) {
 636                 self = this;
 637             }
 638             return me.im_func.apply(self, args);
 639         };
 640         newfunc.im_self = im_self;
 641         newfunc.im_func = im_func;
 642         newfunc.im_preargs = im_preargs;
 643         return newfunc;
 644     },
 645
 646     /** @id MochiKit.Base.bindMethods */
 647     bindMethods: function (self) {
 648         var bind = MochiKit.Base.bind;
 649         for (var k in self) {
 650             var func = self[k];
 651             if (typeof(func) == 'function') {
 652                 self[k] = bind(func, self);
 653             }
 654         }
 655     },
 656
 657     /** @id MochiKit.Base.registerComparator */
 658     registerComparator: function (name, check, comparator, /* optional */ override) {
 659         MochiKit.Base.comparatorRegistry.register(name, check, comparator, override);
 660     },
 661
 662     _primitives: {'boolean': true, 'string': true, 'number': true},
 663
 664     /** @id MochiKit.Base.compare */
 665     compare: function (a, b) {
 666         if (a == b) {
 667             return 0;
 668         }
 669         var aIsNull = (typeof(a) == 'undefined' || a === null);
 670         var bIsNull = (typeof(b) == 'undefined' || b === null);
 671         if (aIsNull && bIsNull) {
 672             return 0;
 673         } else if (aIsNull) {
 674             return -1;
 675         } else if (bIsNull) {
 676             return 1;
 677         }
 678         var m = MochiKit.Base;
 679         // bool, number, string have meaningful comparisons
 680         var prim = m._primitives;
 681         if (!(typeof(a) in prim && typeof(b) in prim)) {
 682             try {
 683                 return m.comparatorRegistry.match(a, b);
 684             } catch (e) {
 685                 if (e != m.NotFound) {
 686                     throw e;
 687                 }
 688             }
 689         }
 690         if (a < b) {
 691             return -1;
 692         } else if (a > b) {
 693             return 1;
 694         }
 695         // These types can't be compared
 696         var repr = m.repr;
 697         throw new TypeError(repr(a) + " and " + repr(b) + " can not be compared");
 698     },
 699
 700     /** @id MochiKit.Base.compareDateLike */
 701     compareDateLike: function (a, b) {
 702         return MochiKit.Base.compare(a.getTime(), b.getTime());
 703     },
 704
 705     /** @id MochiKit.Base.compareArrayLike */
 706     compareArrayLike: function (a, b) {
 707         var compare = MochiKit.Base.compare;
 708         var count = a.length;
 709         var rval = 0;
 710         if (count > b.length) {
 711             rval = 1;
 712             count = b.length;
 713         } else if (count < b.length) {
 714             rval = -1;
 715         }
 716         for (var i = 0; i < count; i++) {
 717             var cmp = compare(a[i], b[i]);
 718             if (cmp) {
 719                 return cmp;
 720             }
 721         }
 722         return rval;
 723     },
 724
 725     /** @id MochiKit.Base.registerRepr */
 726     registerRepr: function (name, check, wrap, /* optional */override) {
 727         MochiKit.Base.reprRegistry.register(name, check, wrap, override);
 728     },
 729
 730     /** @id MochiKit.Base.repr */
 731     repr: function (o) {
 732         if (typeof(o) == "undefined") {
 733             return "undefined";
 734         } else if (o === null) {
 735             return "null";
 736         }
 737         try {
 738             if (typeof(o.__repr__) == 'function') {
 739                 return o.__repr__();
 740             } else if (typeof(o.repr) == 'function' && o.repr != arguments.callee) {
 741                 return o.repr();
 742             }
 743             return MochiKit.Base.reprRegistry.match(o);
 744         } catch (e) {
 745             try {
 746                 if (typeof(o.NAME) == 'string' && (
 747                         o.toString == Function.prototype.toString ||
 748                         o.toString == Object.prototype.toString
 749                     )) {
 750                     return o.NAME;
 751                 }
 752             } catch (e) {
 753             }
 754         }
 755         try {
 756             var ostring = (o + "");
 757         } catch (e) {
 758             return "[" + typeof(o) + "]";
 759         }
 760         if (typeof(o) == "function") {
 761             o = ostring.replace(/^\s+/, "");
 762             var idx = o.indexOf("{");
 763             if (idx != -1) {
 764                 o = o.substr(0, idx) + "{...}";
 765             }
 766         }
 767         return ostring;
 768     },
 769
 770     /** @id MochiKit.Base.reprArrayLike */
 771     reprArrayLike: function (o) {
 772         var m = MochiKit.Base;
 773         return "[" + m.map(m.repr, o).join(", ") + "]";
 774     },
 775
 776     /** @id MochiKit.Base.reprString */
 777     reprString: function (o) {
 778         return ('"' + o.replace(/(["\\])/g, '\\$1') + '"'
 779             ).replace(/[\f]/g, "\\f"
 780             ).replace(/[\b]/g, "\\b"
 781             ).replace(/[\n]/g, "\\n"
 782             ).replace(/[\t]/g, "\\t"
 783             ).replace(/[\r]/g, "\\r");
 784     },
 785
 786     /** @id MochiKit.Base.reprNumber */
 787     reprNumber: function (o) {
 788         return o + "";
 789     },
 790
 791     /** @id MochiKit.Base.registerJSON */
 792     registerJSON: function (name, check, wrap, /* optional */override) {
 793         MochiKit.Base.jsonRegistry.register(name, check, wrap, override);
 794     },
 795
 796
 797     /** @id MochiKit.Base.evalJSON */
 798     evalJSON: function () {
 799         return eval("(" + arguments[0] + ")");
 800     },
 801
 802     /** @id MochiKit.Base.serializeJSON */
 803     serializeJSON: function (o) {
 804         var objtype = typeof(o);
 805         if (objtype == "number" || objtype == "boolean") {
 806             return o + "";
 807         } else if (o === null) {
 808             return "null";
 809         }
 810         var m = MochiKit.Base;
 811         var reprString = m.reprString;
 812         if (objtype == "string") {
 813             return reprString(o);
 814         }
 815         // recurse
 816         var me = arguments.callee;
 817         // short-circuit for objects that support "json" serialization
 818         // if they return "self" then just pass-through...
 819         var newObj;
 820         if (typeof(o.__json__) == "function") {
 821             newObj = o.__json__();
 822             if (o !== newObj) {
 823                 return me(newObj);
 824             }
 825         }
 826         if (typeof(o.json) == "function") {
 827             newObj = o.json();
 828             if (o !== newObj) {
 829                 return me(newObj);
 830             }
 831         }
 832         // array
 833         if (objtype != "function" && typeof(o.length) == "number") {
 834             var res = [];
 835             for (var i = 0; i < o.length; i++) {
 836                 var val = me(o[i]);
 837                 if (typeof(val) != "string") {
 838                     val = "undefined";
 839                 }
 840                 res.push(val);
 841             }
 842             return "[" + res.join(", ") + "]";
 843         }
 844         // look in the registry
 845         try {
 846             newObj = m.jsonRegistry.match(o);
 847             if (o !== newObj) {
 848                 return me(newObj);
 849             }
 850         } catch (e) {
 851             if (e != m.NotFound) {
 852                 // something really bad happened
 853                 throw e;
 854             }
 855         }
 856         // undefined is outside of the spec
 857         if (objtype == "undefined") {
 858             throw new TypeError("undefined can not be serialized as JSON");
 859         }
 860         // it's a function with no adapter, bad
 861         if (objtype == "function") {
 862             return null;
 863         }
 864         // generic object code path
 865         res = [];
 866         for (var k in o) {
 867             var useKey;
 868             if (typeof(k) == "number") {
 869                 useKey = '"' + k + '"';
 870             } else if (typeof(k) == "string") {
 871                 useKey = reprString(k);
 872             } else {
 873                 // skip non-string or number keys
 874                 continue;
 875             }
 876             val = me(o[k]);
 877             if (typeof(val) != "string") {
 878                 // skip non-serializable values
 879                 continue;
 880             }
 881             res.push(useKey + ":" + val);
 882         }
 883         return "{" + res.join(", ") + "}";
 884     },
 885
 886
 887     /** @id MochiKit.Base.objEqual */
 888     objEqual: function (a, b) {
 889         return (MochiKit.Base.compare(a, b) === 0);
 890     },
 891
 892     /** @id MochiKit.Base.arrayEqual */
 893     arrayEqual: function (self, arr) {
 894         if (self.length != arr.length) {
 895             return false;
 896         }
 897         return (MochiKit.Base.compare(self, arr) === 0);
 898     },
 899
 900     /** @id MochiKit.Base.concat */
 901     concat: function (/* lst... */) {
 902         var rval = [];
 903         var extend = MochiKit.Base.extend;
 904         for (var i = 0; i < arguments.length; i++) {
 905             extend(rval, arguments[i]);
 906         }
 907         return rval;
 908     },
 909
 910     /** @id MochiKit.Base.keyComparator */
 911     keyComparator: function (key/* ... */) {
 912         // fast-path for single key comparisons
 913         var m = MochiKit.Base;
 914         var compare = m.compare;
 915         if (arguments.length == 1) {
 916             return function (a, b) {
 917                 return compare(a[key], b[key]);
 918             };
 919         }
 920         var compareKeys = m.extend(null, arguments);
 921         return function (a, b) {
 922             var rval = 0;
 923             // keep comparing until something is inequal or we run out of
 924             // keys to compare
 925             for (var i = 0; (rval === 0) && (i < compareKeys.length); i++) {
 926                 var key = compareKeys[i];
 927                 rval = compare(a[key], b[key]);
 928             }
 929             return rval;
 930         };
 931     },
 932
 933     /** @id MochiKit.Base.reverseKeyComparator */
 934     reverseKeyComparator: function (key) {
 935         var comparator = MochiKit.Base.keyComparator.apply(this, arguments);
 936         return function (a, b) {
 937             return comparator(b, a);
 938         };
 939     },
 940
 941     /** @id MochiKit.Base.partial */
 942     partial: function (func) {
 943         var m = MochiKit.Base;
 944         return m.bind.apply(this, m.extend([func, undefined], arguments, 1));
 945     },
 946
 947     /** @id MochiKit.Base.listMinMax */
 948     listMinMax: function (which, lst) {
 949         if (lst.length === 0) {
 950             return null;
 951         }
 952         var cur = lst[0];
 953         var compare = MochiKit.Base.compare;
 954         for (var i = 1; i < lst.length; i++) {
 955             var o = lst[i];
 956             if (compare(o, cur) == which) {
 957                 cur = o;
 958             }
 959         }
 960         return cur;
 961     },
 962
 963     /** @id MochiKit.Base.objMax */
 964     objMax: function (/* obj... */) {
 965         return MochiKit.Base.listMinMax(1, arguments);
 966     },
 967
 968     /** @id MochiKit.Base.objMin */
 969     objMin: function (/* obj... */) {
 970         return MochiKit.Base.listMinMax(-1, arguments);
 971     },
 972
 973     /** @id MochiKit.Base.findIdentical */
 974     findIdentical: function (lst, value, start/* = 0 */, /* optional */end) {
 975         if (typeof(end) == "undefined" || end === null) {
 976             end = lst.length;
 977         }
 978         if (typeof(start) == "undefined" || start === null) {
 979             start = 0;
 980         }
 981         for (var i = start; i < end; i++) {
 982             if (lst[i] === value) {
 983                 return i;
 984             }
 985         }
 986         return -1;
 987     },
 988
 989     /** @id MochiKit.Base.mean */
 990     mean: function(/* lst... */) {
 991         /* http://www.nist.gov/dads/HTML/mean.html */
 992         var sum = 0;
 993
 994         var m = MochiKit.Base;
 995         var args = m.extend(null, arguments);
 996         var count = args.length;
 997
 998         while (args.length) {
 999             var o = args.shift();
1000             if (o && typeof(o) == "object" && typeof(o.length) == "number") {
1001                 count += o.length - 1;
1002                 for (var i = o.length - 1; i >= 0; i--) {
1003                     sum += o[i];
1004                 }
1005             } else {
1006                 sum += o;
1007             }
1008         }
1009
1010         if (count <= 0) {
1011             throw new TypeError('mean() requires at least one argument');
1012         }
1013
1014         return sum/count;
1015     },
1016
1017     /** @id MochiKit.Base.median */
1018     median: function(/* lst... */) {
1019         /* http://www.nist.gov/dads/HTML/median.html */
1020         var data = MochiKit.Base.flattenArguments(arguments);
1021         if (data.length === 0) {
1022             throw new TypeError('median() requires at least one argument');
1023         }
1024         data.sort(compare);
1025         if (data.length % 2 == 0) {
1026             var upper = data.length / 2;
1027             return (data[upper] + data[upper - 1]) / 2;
1028         } else {
1029             return data[(data.length - 1) / 2];
1030         }
1031     },
1032
1033     /** @id MochiKit.Base.findValue */
1034     findValue: function (lst, value, start/* = 0 */, /* optional */end) {
1035         if (typeof(end) == "undefined" || end === null) {
1036             end = lst.length;
1037         }
1038         if (typeof(start) == "undefined" || start === null) {
1039             start = 0;
1040         }
1041         var cmp = MochiKit.Base.compare;
1042         for (var i = start; i < end; i++) {
1043             if (cmp(lst[i], value) === 0) {
1044                 return i;
1045             }
1046         }
1047         return -1;
1048     },
1049
1050     /** @id MochiKit.Base.nodeWalk */
1051     nodeWalk: function (node, visitor) {
1052         var nodes = [node];
1053         var extend = MochiKit.Base.extend;
1054         while (nodes.length) {
1055             var res = visitor(nodes.shift());
1056             if (res) {
1057                 extend(nodes, res);
1058             }
1059         }
1060     },
1061
1062
1063     /** @id MochiKit.Base.nameFunctions */
1064     nameFunctions: function (namespace) {
1065         var base = namespace.NAME;
1066         if (typeof(base) == 'undefined') {
1067             base = '';
1068         } else {
1069             base = base + '.';
1070         }
1071         for (var name in namespace) {
1072             var o = namespace[name];
1073             if (typeof(o) == 'function' && typeof(o.NAME) == 'undefined') {
1074                 try {
1075                     o.NAME = base + name;
1076                 } catch (e) {
1077                     // pass
1078                 }
1079             }
1080         }
1081     },
1082
1083
1084     /** @id MochiKit.Base.queryString */
1085     queryString: function (names, values) {
1086         // check to see if names is a string or a DOM element, and if
1087         // MochiKit.DOM is available.  If so, drop it like it's a form
1088         // Ugliest conditional in MochiKit?  Probably!
1089         if (typeof(MochiKit.DOM) != "undefined" && arguments.length == 1
1090             && (typeof(names) == "string" || (
1091                 typeof(names.nodeType) != "undefined" && names.nodeType > 0
1092             ))
1093         ) {
1094             var kv = MochiKit.DOM.formContents(names);
1095             names = kv[0];
1096             values = kv[1];
1097         } else if (arguments.length == 1) {
1098             var o = names;
1099             names = [];
1100             values = [];
1101             for (var k in o) {
1102                 var v = o[k];
1103                 if (typeof(v) == "function") {
1104                     continue;
1105                 } else if (typeof(v) != "string" &&
1106                         typeof(v.length) == "number") {
1107                     for (var i = 0; i < v.length; i++) {
1108                         names.push(k);
1109                         values.push(v[i]);
1110                     }
1111                 } else {
1112                     names.push(k);
1113                     values.push(v);
1114                 }
1115             }
1116         }
1117         var rval = [];
1118         var len = Math.min(names.length, values.length);
1119         var urlEncode = MochiKit.Base.urlEncode;
1120         for (var i = 0; i < len; i++) {
1121             v = values[i];
1122             if (typeof(v) != 'undefined' && v !== null) {
1123                 rval.push(urlEncode(names[i]) + "=" + urlEncode(v));
1124             }
1125         }
1126         return rval.join("&");
1127     },
1128
1129
1130     /** @id MochiKit.Base.parseQueryString */
1131     parseQueryString: function (encodedString, useArrays) {
1132         // strip a leading '?' from the encoded string
1133         var qstr = (encodedString[0] == "?") ? encodedString.substring(1) :
1134                                                encodedString;
1135         var pairs = qstr.replace(/\+/g, "%20").split(/(\&amp\;|\&\#38\;|\&#x26;|\&)/);
1136         var o = {};
1137         var decode;
1138         if (typeof(decodeURIComponent) != "undefined") {
1139             decode = decodeURIComponent;
1140         } else {
1141             decode = unescape;
1142         }
1143         if (useArrays) {
1144             for (var i = 0; i < pairs.length; i++) {
1145                 var pair = pairs[i].split("=");
1146                 if (pair.length !== 2) {
1147                     continue;
1148                 }
1149                 var name = decode(pair[0]);
1150                 var arr = o[name];
1151                 if (!(arr instanceof Array)) {
1152                     arr = [];
1153                     o[name] = arr;
1154                 }
1155                 arr.push(decode(pair[1]));
1156             }
1157         } else {
1158             for (i = 0; i < pairs.length; i++) {
1159                 pair = pairs[i].split("=");
1160                 if (pair.length !== 2) {
1161                     continue;
1162                 }
1163                 o[decode(pair[0])] = decode(pair[1]);
1164             }
1165         }
1166         return o;
1167     }
1168 });
1169
1170 /** @id MochiKit.Base.AdapterRegistry */
1171 MochiKit.Base.AdapterRegistry = function () {
1172     this.pairs = [];
1173 };
1174
1175 MochiKit.Base.AdapterRegistry.prototype = {
1176     /** @id MochiKit.Base.AdapterRegistry.prototype.register */
1177     register: function (name, check, wrap, /* optional */ override) {
1178         if (override) {
1179             this.pairs.unshift([name, check, wrap]);
1180         } else {
1181             this.pairs.push([name, check, wrap]);
1182         }
1183     },
1184
1185     /** @id MochiKit.Base.AdapterRegistry.prototype.match */
1186     match: function (/* ... */) {
1187         for (var i = 0; i < this.pairs.length; i++) {
1188             var pair = this.pairs[i];
1189             if (pair[1].apply(this, arguments)) {
1190                 return pair[2].apply(this, arguments);
1191             }
1192         }
1193         throw MochiKit.Base.NotFound;
1194     },
1195
1196     /** @id MochiKit.Base.AdapterRegistry.prototype.unregister */
1197     unregister: function (name) {
1198         for (var i = 0; i < this.pairs.length; i++) {
1199             var pair = this.pairs[i];
1200             if (pair[0] == name) {
1201                 this.pairs.splice(i, 1);
1202                 return true;
1203             }
1204         }
1205         return false;
1206     }
1207 };
1208
1209
1210 MochiKit.Base.EXPORT = [
1211     "flattenArray",
1212     "noop",
1213     "camelize",
1214     "counter",
1215     "clone",
1216     "extend",
1217     "update",
1218     "updatetree",
1219     "setdefault",
1220     "keys",
1221     "values",
1222     "items",
1223     "NamedError",
1224     "operator",
1225     "forwardCall",
1226     "itemgetter",
1227     "typeMatcher",
1228     "isCallable",
1229     "isUndefined",
1230     "isUndefinedOrNull",
1231     "isNull",
1232     "isEmpty",
1233     "isNotEmpty",
1234     "isArrayLike",
1235     "isDateLike",
1236     "xmap",
1237     "map",
1238     "xfilter",
1239     "filter",
1240     "methodcaller",
1241     "compose",
1242     "bind",
1243     "bindMethods",
1244     "NotFound",
1245     "AdapterRegistry",
1246     "registerComparator",
1247     "compare",
1248     "registerRepr",
1249     "repr",
1250     "objEqual",
1251     "arrayEqual",
1252     "concat",
1253     "keyComparator",
1254     "reverseKeyComparator",
1255     "partial",
1256     "merge",
1257     "listMinMax",
1258     "listMax",
1259     "listMin",
1260     "objMax",
1261     "objMin",
1262     "nodeWalk",
1263     "zip",
1264     "urlEncode",
1265     "queryString",
1266     "serializeJSON",
1267     "registerJSON",
1268     "evalJSON",
1269     "parseQueryString",
1270     "findValue",
1271     "findIdentical",
1272     "flattenArguments",
1273     "method",
1274     "average",
1275     "mean",
1276     "median"
1277 ];
1278
1279 MochiKit.Base.EXPORT_OK = [
1280     "nameFunctions",
1281     "comparatorRegistry",
1282     "reprRegistry",
1283     "jsonRegistry",
1284     "compareDateLike",
1285     "compareArrayLike",
1286     "reprArrayLike",
1287     "reprString",
1288     "reprNumber"
1289 ];
1290
1291 MochiKit.Base._exportSymbols = function (globals, module) {
1292     if (!MochiKit.__export__) {
1293         return;
1294     }
1295     var all = module.EXPORT_TAGS[":all"];
1296     for (var i = 0; i < all.length; i++) {
1297         globals[all[i]] = module[all[i]];
1298     }
1299 };
1300
1301 MochiKit.Base.__new__ = function () {
1302     // A singleton raised when no suitable adapter is found
1303     var m = this;
1304
1305     // convenience
1306     /** @id MochiKit.Base.noop */
1307     m.noop = m.operator.identity;
1308
1309     // Backwards compat
1310     m.forward = m.forwardCall;
1311     m.find = m.findValue;
1312
1313     if (typeof(encodeURIComponent) != "undefined") {
1314         /** @id MochiKit.Base.urlEncode */
1315         m.urlEncode = function (unencoded) {
1316             return encodeURIComponent(unencoded).replace(/\'/g, '%27');
1317         };
1318     } else {
1319         m.urlEncode = function (unencoded) {
1320             return escape(unencoded
1321                 ).replace(/\+/g, '%2B'
1322                 ).replace(/\"/g,'%22'
1323                 ).rval.replace(/\'/g, '%27');
1324         };
1325     }
1326
1327     /** @id MochiKit.Base.NamedError */
1328     m.NamedError = function (name) {
1329         this.message = name;
1330         this.name = name;
1331     };
1332     m.NamedError.prototype = new Error();
1333     m.update(m.NamedError.prototype, {
1334         repr: function () {
1335             if (this.message && this.message != this.name) {
1336                 return this.name + "(" + m.repr(this.message) + ")";
1337             } else {
1338                 return this.name + "()";
1339             }
1340         },
1341         toString: m.forwardCall("repr")
1342     });
1343
1344     /** @id MochiKit.Base.NotFound */
1345     m.NotFound = new m.NamedError("MochiKit.Base.NotFound");
1346
1347
1348     /** @id MochiKit.Base.listMax */
1349     m.listMax = m.partial(m.listMinMax, 1);
1350     /** @id MochiKit.Base.listMin */
1351     m.listMin = m.partial(m.listMinMax, -1);
1352
1353     /** @id MochiKit.Base.isCallable */
1354     m.isCallable = m.typeMatcher('function');
1355     /** @id MochiKit.Base.isUndefined */
1356     m.isUndefined = m.typeMatcher('undefined');
1357
1358     /** @id MochiKit.Base.merge */
1359     m.merge = m.partial(m.update, null);
1360     /** @id MochiKit.Base.zip */
1361     m.zip = m.partial(m.map, null);
1362
1363     /** @id MochiKit.Base.average */
1364     m.average = m.mean;
1365
1366     /** @id MochiKit.Base.comparatorRegistry */
1367     m.comparatorRegistry = new m.AdapterRegistry();
1368     m.registerComparator("dateLike", m.isDateLike, m.compareDateLike);
1369     m.registerComparator("arrayLike", m.isArrayLike, m.compareArrayLike);
1370
1371     /** @id MochiKit.Base.reprRegistry */
1372     m.reprRegistry = new m.AdapterRegistry();
1373     m.registerRepr("arrayLike", m.isArrayLike, m.reprArrayLike);
1374     m.registerRepr("string", m.typeMatcher("string"), m.reprString);
1375     m.registerRepr("numbers", m.typeMatcher("number", "boolean"), m.reprNumber);
1376
1377     /** @id MochiKit.Base.jsonRegistry */
1378     m.jsonRegistry = new m.AdapterRegistry();
1379
1380     var all = m.concat(m.EXPORT, m.EXPORT_OK);
1381     m.EXPORT_TAGS = {
1382         ":common": m.concat(m.EXPORT_OK),
1383         ":all": all
1384     };
1385
1386     m.nameFunctions(this);
1387
1388 };
1389
1390 MochiKit.Base.__new__();
1391
1392 //
1393 // XXX: Internet Explorer blows
1394 //
1395 if (MochiKit.__export__) {
1396     compare = MochiKit.Base.compare;
1397     compose = MochiKit.Base.compose;
1398     serializeJSON = MochiKit.Base.serializeJSON;
1399 }
1400
1401 MochiKit.Base._exportSymbols(this, MochiKit.Base);