Diffstat (limited to 'frontend/beta/js/MochiKit/Base.js') (more/less context) (ignore whitespace changes)
-rw-r--r-- | frontend/beta/js/MochiKit/Base.js | 1403 |
1 files changed, 1403 insertions, 0 deletions
diff --git a/frontend/beta/js/MochiKit/Base.js b/frontend/beta/js/MochiKit/Base.js new file mode 100644 index 0000000..67f4499 --- a/dev/null +++ b/frontend/beta/js/MochiKit/Base.js | |||
@@ -0,0 +1,1403 @@ | |||
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 | if (typeof(o.NAME) == 'string' && ( | ||
746 | o.toString == Function.prototype.toString || | ||
747 | o.toString == Object.prototype.toString | ||
748 | )) { | ||
749 | return o.NAME; | ||
750 | } | ||
751 | } | ||
752 | try { | ||
753 | var ostring = (o + ""); | ||
754 | } catch (e) { | ||
755 | return "[" + typeof(o) + "]"; | ||
756 | } | ||
757 | if (typeof(o) == "function") { | ||
758 | o = ostring.replace(/^\s+/, ""); | ||
759 | var idx = o.indexOf("{"); | ||
760 | if (idx != -1) { | ||
761 | o = o.substr(0, idx) + "{...}"; | ||
762 | } | ||
763 | } | ||
764 | return ostring; | ||
765 | }, | ||
766 | |||
767 | /** @id MochiKit.Base.reprArrayLike */ | ||
768 | reprArrayLike: function (o) { | ||
769 | var m = MochiKit.Base; | ||
770 | return "[" + m.map(m.repr, o).join(", ") + "]"; | ||
771 | }, | ||
772 | |||
773 | /** @id MochiKit.Base.reprString */ | ||
774 | reprString: function (o) { | ||
775 | return ('"' + o.replace(/(["\\])/g, '\\$1') + '"' | ||
776 | ).replace(/[\f]/g, "\\f" | ||
777 | ).replace(/[\b]/g, "\\b" | ||
778 | ).replace(/[\n]/g, "\\n" | ||
779 | ).replace(/[\t]/g, "\\t" | ||
780 | ).replace(/[\r]/g, "\\r"); | ||
781 | }, | ||
782 | |||
783 | /** @id MochiKit.Base.reprNumber */ | ||
784 | reprNumber: function (o) { | ||
785 | return o + ""; | ||
786 | }, | ||
787 | |||
788 | /** @id MochiKit.Base.registerJSON */ | ||
789 | registerJSON: function (name, check, wrap, /* optional */override) { | ||
790 | MochiKit.Base.jsonRegistry.register(name, check, wrap, override); | ||
791 | }, | ||
792 | |||
793 | |||
794 | /** @id MochiKit.Base.evalJSON */ | ||
795 | evalJSON: function () { | ||
796 | return eval("(" + arguments[0] + ")"); | ||
797 | }, | ||
798 | |||
799 | /** @id MochiKit.Base.serializeJSON */ | ||
800 | serializeJSON: function (o) { | ||
801 | var objtype = typeof(o); | ||
802 | if (objtype == "number" || objtype == "boolean") { | ||
803 | return o + ""; | ||
804 | } else if (o === null) { | ||
805 | return "null"; | ||
806 | } | ||
807 | var m = MochiKit.Base; | ||
808 | var reprString = m.reprString; | ||
809 | if (objtype == "string") { | ||
810 | return reprString(o); | ||
811 | } | ||
812 | // recurse | ||
813 | var me = arguments.callee; | ||
814 | // short-circuit for objects that support "json" serialization | ||
815 | // if they return "self" then just pass-through... | ||
816 | var newObj; | ||
817 | if (typeof(o.__json__) == "function") { | ||
818 | newObj = o.__json__(); | ||
819 | if (o !== newObj) { | ||
820 | return me(newObj); | ||
821 | } | ||
822 | } | ||
823 | if (typeof(o.json) == "function") { | ||
824 | newObj = o.json(); | ||
825 | if (o !== newObj) { | ||
826 | return me(newObj); | ||
827 | } | ||
828 | } | ||
829 | // array | ||
830 | if (objtype != "function" && typeof(o.length) == "number") { | ||
831 | var res = []; | ||
832 | for (var i = 0; i < o.length; i++) { | ||
833 | var val = me(o[i]); | ||
834 | if (typeof(val) != "string") { | ||
835 | val = "undefined"; | ||
836 | } | ||
837 | res.push(val); | ||
838 | } | ||
839 | return "[" + res.join(", ") + "]"; | ||
840 | } | ||
841 | // look in the registry | ||
842 | try { | ||
843 | newObj = m.jsonRegistry.match(o); | ||
844 | if (o !== newObj) { | ||
845 | return me(newObj); | ||
846 | } | ||
847 | } catch (e) { | ||
848 | if (e != m.NotFound) { | ||
849 | // something really bad happened | ||
850 | throw e; | ||
851 | } | ||
852 | } | ||
853 | // undefined is outside of the spec | ||
854 | if (objtype == "undefined") { | ||
855 | throw new TypeError("undefined can not be serialized as JSON"); | ||
856 | } | ||
857 | // it's a function with no adapter, bad | ||
858 | if (objtype == "function") { | ||
859 | return null; | ||
860 | } | ||
861 | // generic object code path | ||
862 | res = []; | ||
863 | for (var k in o) { | ||
864 | var useKey; | ||
865 | if (typeof(k) == "number") { | ||
866 | useKey = '"' + k + '"'; | ||
867 | } else if (typeof(k) == "string") { | ||
868 | useKey = reprString(k); | ||
869 | } else { | ||
870 | // skip non-string or number keys | ||
871 | continue; | ||
872 | } | ||
873 | val = me(o[k]); | ||
874 | if (typeof(val) != "string") { | ||
875 | // skip non-serializable values | ||
876 | continue; | ||
877 | } | ||
878 | res.push(useKey + ":" + val); | ||
879 | } | ||
880 | return "{" + res.join(", ") + "}"; | ||
881 | }, | ||
882 | |||
883 | |||
884 | /** @id MochiKit.Base.objEqual */ | ||
885 | objEqual: function (a, b) { | ||
886 | return (MochiKit.Base.compare(a, b) === 0); | ||
887 | }, | ||
888 | |||
889 | /** @id MochiKit.Base.arrayEqual */ | ||
890 | arrayEqual: function (self, arr) { | ||
891 | if (self.length != arr.length) { | ||
892 | return false; | ||
893 | } | ||
894 | return (MochiKit.Base.compare(self, arr) === 0); | ||
895 | }, | ||
896 | |||
897 | /** @id MochiKit.Base.concat */ | ||
898 | concat: function (/* lst... */) { | ||
899 | var rval = []; | ||
900 | var extend = MochiKit.Base.extend; | ||
901 | for (var i = 0; i < arguments.length; i++) { | ||
902 | extend(rval, arguments[i]); | ||
903 | } | ||
904 | return rval; | ||
905 | }, | ||
906 | |||
907 | /** @id MochiKit.Base.keyComparator */ | ||
908 | keyComparator: function (key/* ... */) { | ||
909 | // fast-path for single key comparisons | ||
910 | var m = MochiKit.Base; | ||
911 | var compare = m.compare; | ||
912 | if (arguments.length == 1) { | ||
913 | return function (a, b) { | ||
914 | return compare(a[key], b[key]); | ||
915 | }; | ||
916 | } | ||
917 | var compareKeys = m.extend(null, arguments); | ||
918 | return function (a, b) { | ||
919 | var rval = 0; | ||
920 | // keep comparing until something is inequal or we run out of | ||
921 | // keys to compare | ||
922 | for (var i = 0; (rval === 0) && (i < compareKeys.length); i++) { | ||
923 | var key = compareKeys[i]; | ||
924 | rval = compare(a[key], b[key]); | ||
925 | } | ||
926 | return rval; | ||
927 | }; | ||
928 | }, | ||
929 | |||
930 | /** @id MochiKit.Base.reverseKeyComparator */ | ||
931 | reverseKeyComparator: function (key) { | ||
932 | var comparator = MochiKit.Base.keyComparator.apply(this, arguments); | ||
933 | return function (a, b) { | ||
934 | return comparator(b, a); | ||
935 | }; | ||
936 | }, | ||
937 | |||
938 | /** @id MochiKit.Base.partial */ | ||
939 | partial: function (func) { | ||
940 | var m = MochiKit.Base; | ||
941 | return m.bind.apply(this, m.extend([func, undefined], arguments, 1)); | ||
942 | }, | ||
943 | |||
944 | /** @id MochiKit.Base.listMinMax */ | ||
945 | listMinMax: function (which, lst) { | ||
946 | if (lst.length === 0) { | ||
947 | return null; | ||
948 | } | ||
949 | var cur = lst[0]; | ||
950 | var compare = MochiKit.Base.compare; | ||
951 | for (var i = 1; i < lst.length; i++) { | ||
952 | var o = lst[i]; | ||
953 | if (compare(o, cur) == which) { | ||
954 | cur = o; | ||
955 | } | ||
956 | } | ||
957 | return cur; | ||
958 | }, | ||
959 | |||
960 | /** @id MochiKit.Base.objMax */ | ||
961 | objMax: function (/* obj... */) { | ||
962 | return MochiKit.Base.listMinMax(1, arguments); | ||
963 | }, | ||
964 | |||
965 | /** @id MochiKit.Base.objMin */ | ||
966 | objMin: function (/* obj... */) { | ||
967 | return MochiKit.Base.listMinMax(-1, arguments); | ||
968 | }, | ||
969 | |||
970 | /** @id MochiKit.Base.findIdentical */ | ||
971 | findIdentical: function (lst, value, start/* = 0 */, /* optional */end) { | ||
972 | if (typeof(end) == "undefined" || end === null) { | ||
973 | end = lst.length; | ||
974 | } | ||
975 | if (typeof(start) == "undefined" || start === null) { | ||
976 | start = 0; | ||
977 | } | ||
978 | for (var i = start; i < end; i++) { | ||
979 | if (lst[i] === value) { | ||
980 | return i; | ||
981 | } | ||
982 | } | ||
983 | return -1; | ||
984 | }, | ||
985 | |||
986 | /** @id MochiKit.Base.mean */ | ||
987 | mean: function(/* lst... */) { | ||
988 | /* http://www.nist.gov/dads/HTML/mean.html */ | ||
989 | var sum = 0; | ||
990 | |||
991 | var m = MochiKit.Base; | ||
992 | var args = m.extend(null, arguments); | ||
993 | var count = args.length; | ||
994 | |||
995 | while (args.length) { | ||
996 | var o = args.shift(); | ||
997 | if (o && typeof(o) == "object" && typeof(o.length) == "number") { | ||
998 | count += o.length - 1; | ||
999 | for (var i = o.length - 1; i >= 0; i--) { | ||
1000 | sum += o[i]; | ||
1001 | } | ||
1002 | } else { | ||
1003 | sum += o; | ||
1004 | } | ||
1005 | } | ||
1006 | |||
1007 | if (count <= 0) { | ||
1008 | throw new TypeError('mean() requires at least one argument'); | ||
1009 | } | ||
1010 | |||
1011 | return sum/count; | ||
1012 | }, | ||
1013 | |||
1014 | /** @id MochiKit.Base.median */ | ||
1015 | median: function(/* lst... */) { | ||
1016 | /* http://www.nist.gov/dads/HTML/median.html */ | ||
1017 | var data = MochiKit.Base.flattenArguments(arguments); | ||
1018 | if (data.length === 0) { | ||
1019 | throw new TypeError('median() requires at least one argument'); | ||
1020 | } | ||
1021 | data.sort(compare); | ||
1022 | if (data.length % 2 == 0) { | ||
1023 | var upper = data.length / 2; | ||
1024 | return (data[upper] + data[upper - 1]) / 2; | ||
1025 | } else { | ||
1026 | return data[(data.length - 1) / 2]; | ||
1027 | } | ||
1028 | }, | ||
1029 | |||
1030 | /** @id MochiKit.Base.findValue */ | ||
1031 | findValue: function (lst, value, start/* = 0 */, /* optional */end) { | ||
1032 | if (typeof(end) == "undefined" || end === null) { | ||
1033 | end = lst.length; | ||
1034 | } | ||
1035 | if (typeof(start) == "undefined" || start === null) { | ||
1036 | start = 0; | ||
1037 | } | ||
1038 | var cmp = MochiKit.Base.compare; | ||
1039 | for (var i = start; i < end; i++) { | ||
1040 | if (cmp(lst[i], value) === 0) { | ||
1041 | return i; | ||
1042 | } | ||
1043 | } | ||
1044 | return -1; | ||
1045 | }, | ||
1046 | |||
1047 | /** @id MochiKit.Base.nodeWalk */ | ||
1048 | nodeWalk: function (node, visitor) { | ||
1049 | var nodes = [node]; | ||
1050 | var extend = MochiKit.Base.extend; | ||
1051 | while (nodes.length) { | ||
1052 | var res = visitor(nodes.shift()); | ||
1053 | if (res) { | ||
1054 | extend(nodes, res); | ||
1055 | } | ||
1056 | } | ||
1057 | }, | ||
1058 | |||
1059 | |||
1060 | /** @id MochiKit.Base.nameFunctions */ | ||
1061 | nameFunctions: function (namespace) { | ||
1062 | var base = namespace.NAME; | ||
1063 | if (typeof(base) == 'undefined') { | ||
1064 | base = ''; | ||
1065 | } else { | ||
1066 | base = base + '.'; | ||
1067 | } | ||
1068 | for (var name in namespace) { | ||
1069 | var o = namespace[name]; | ||
1070 | if (typeof(o) == 'function' && typeof(o.NAME) == 'undefined') { | ||
1071 | try { | ||
1072 | o.NAME = base + name; | ||
1073 | } catch (e) { | ||
1074 | // pass | ||
1075 | } | ||
1076 | } | ||
1077 | } | ||
1078 | }, | ||
1079 | |||
1080 | |||
1081 | /** @id MochiKit.Base.queryString */ | ||
1082 | queryString: function (names, values) { | ||
1083 | // check to see if names is a string or a DOM element, and if | ||
1084 | // MochiKit.DOM is available. If so, drop it like it's a form | ||
1085 | // Ugliest conditional in MochiKit? Probably! | ||
1086 | if (typeof(MochiKit.DOM) != "undefined" && arguments.length == 1 | ||
1087 | && (typeof(names) == "string" || ( | ||
1088 | typeof(names.nodeType) != "undefined" && names.nodeType > 0 | ||
1089 | )) | ||
1090 | ) { | ||
1091 | var kv = MochiKit.DOM.formContents(names); | ||
1092 | names = kv[0]; | ||
1093 | values = kv[1]; | ||
1094 | } else if (arguments.length == 1) { | ||
1095 | // Allow the return value of formContents to be passed directly | ||
1096 | if (typeof(names.length) == "number" && names.length == 2) { | ||
1097 | return arguments.callee(names[0], names[1]); | ||
1098 | } | ||
1099 | var o = names; | ||
1100 | names = []; | ||
1101 | values = []; | ||
1102 | for (var k in o) { | ||
1103 | var v = o[k]; | ||
1104 | if (typeof(v) == "function") { | ||
1105 | continue; | ||
1106 | } else if (typeof(v) != "string" && | ||
1107 | typeof(v.length) == "number") { | ||
1108 | for (var i = 0; i < v.length; i++) { | ||
1109 | names.push(k); | ||
1110 | values.push(v[i]); | ||
1111 | } | ||
1112 | } else { | ||
1113 | names.push(k); | ||
1114 | values.push(v); | ||
1115 | } | ||
1116 | } | ||
1117 | } | ||
1118 | var rval = []; | ||
1119 | var len = Math.min(names.length, values.length); | ||
1120 | var urlEncode = MochiKit.Base.urlEncode; | ||
1121 | for (var i = 0; i < len; i++) { | ||
1122 | v = values[i]; | ||
1123 | if (typeof(v) != 'undefined' && v !== null) { | ||
1124 | rval.push(urlEncode(names[i]) + "=" + urlEncode(v)); | ||
1125 | } | ||
1126 | } | ||
1127 | return rval.join("&"); | ||
1128 | }, | ||
1129 | |||
1130 | |||
1131 | /** @id MochiKit.Base.parseQueryString */ | ||
1132 | parseQueryString: function (encodedString, useArrays) { | ||
1133 | // strip a leading '?' from the encoded string | ||
1134 | var qstr = (encodedString.charAt(0) == "?") | ||
1135 | ? encodedString.substring(1) | ||
1136 | : encodedString; | ||
1137 | var pairs = qstr.replace(/\+/g, "%20").split(/(\&\;|\&\#38\;|\&|\&)/); | ||
1138 | var o = {}; | ||
1139 | var decode; | ||
1140 | if (typeof(decodeURIComponent) != "undefined") { | ||
1141 | decode = decodeURIComponent; | ||
1142 | } else { | ||
1143 | decode = unescape; | ||
1144 | } | ||
1145 | if (useArrays) { | ||
1146 | for (var i = 0; i < pairs.length; i++) { | ||
1147 | var pair = pairs[i].split("="); | ||
1148 | if (pair.length !== 2) { | ||
1149 | continue; | ||
1150 | } | ||
1151 | var name = decode(pair[0]); | ||
1152 | var arr = o[name]; | ||
1153 | if (!(arr instanceof Array)) { | ||
1154 | arr = []; | ||
1155 | o[name] = arr; | ||
1156 | } | ||
1157 | arr.push(decode(pair[1])); | ||
1158 | } | ||
1159 | } else { | ||
1160 | for (i = 0; i < pairs.length; i++) { | ||
1161 | pair = pairs[i].split("="); | ||
1162 | if (pair.length !== 2) { | ||
1163 | continue; | ||
1164 | } | ||
1165 | o[decode(pair[0])] = decode(pair[1]); | ||
1166 | } | ||
1167 | } | ||
1168 | return o; | ||
1169 | } | ||
1170 | }); | ||
1171 | |||
1172 | /** @id MochiKit.Base.AdapterRegistry */ | ||
1173 | MochiKit.Base.AdapterRegistry = function () { | ||
1174 | this.pairs = []; | ||
1175 | }; | ||
1176 | |||
1177 | MochiKit.Base.AdapterRegistry.prototype = { | ||
1178 | /** @id MochiKit.Base.AdapterRegistry.prototype.register */ | ||
1179 | register: function (name, check, wrap, /* optional */ override) { | ||
1180 | if (override) { | ||
1181 | this.pairs.unshift([name, check, wrap]); | ||
1182 | } else { | ||
1183 | this.pairs.push([name, check, wrap]); | ||
1184 | } | ||
1185 | }, | ||
1186 | |||
1187 | /** @id MochiKit.Base.AdapterRegistry.prototype.match */ | ||
1188 | match: function (/* ... */) { | ||
1189 | for (var i = 0; i < this.pairs.length; i++) { | ||
1190 | var pair = this.pairs[i]; | ||
1191 | if (pair[1].apply(this, arguments)) { | ||
1192 | return pair[2].apply(this, arguments); | ||
1193 | } | ||
1194 | } | ||
1195 | throw MochiKit.Base.NotFound; | ||
1196 | }, | ||
1197 | |||
1198 | /** @id MochiKit.Base.AdapterRegistry.prototype.unregister */ | ||
1199 | unregister: function (name) { | ||
1200 | for (var i = 0; i < this.pairs.length; i++) { | ||
1201 | var pair = this.pairs[i]; | ||
1202 | if (pair[0] == name) { | ||
1203 | this.pairs.splice(i, 1); | ||
1204 | return true; | ||
1205 | } | ||
1206 | } | ||
1207 | return false; | ||
1208 | } | ||
1209 | }; | ||
1210 | |||
1211 | |||
1212 | MochiKit.Base.EXPORT = [ | ||
1213 | "flattenArray", | ||
1214 | "noop", | ||
1215 | "camelize", | ||
1216 | "counter", | ||
1217 | "clone", | ||
1218 | "extend", | ||
1219 | "update", | ||
1220 | "updatetree", | ||
1221 | "setdefault", | ||
1222 | "keys", | ||
1223 | "values", | ||
1224 | "items", | ||
1225 | "NamedError", | ||
1226 | "operator", | ||
1227 | "forwardCall", | ||
1228 | "itemgetter", | ||
1229 | "typeMatcher", | ||
1230 | "isCallable", | ||
1231 | "isUndefined", | ||
1232 | "isUndefinedOrNull", | ||
1233 | "isNull", | ||
1234 | "isEmpty", | ||
1235 | "isNotEmpty", | ||
1236 | "isArrayLike", | ||
1237 | "isDateLike", | ||
1238 | "xmap", | ||
1239 | "map", | ||
1240 | "xfilter", | ||
1241 | "filter", | ||
1242 | "methodcaller", | ||
1243 | "compose", | ||
1244 | "bind", | ||
1245 | "bindMethods", | ||
1246 | "NotFound", | ||
1247 | "AdapterRegistry", | ||
1248 | "registerComparator", | ||
1249 | "compare", | ||
1250 | "registerRepr", | ||
1251 | "repr", | ||
1252 | "objEqual", | ||
1253 | "arrayEqual", | ||
1254 | "concat", | ||
1255 | "keyComparator", | ||
1256 | "reverseKeyComparator", | ||
1257 | "partial", | ||
1258 | "merge", | ||
1259 | "listMinMax", | ||
1260 | "listMax", | ||
1261 | "listMin", | ||
1262 | "objMax", | ||
1263 | "objMin", | ||
1264 | "nodeWalk", | ||
1265 | "zip", | ||
1266 | "urlEncode", | ||
1267 | "queryString", | ||
1268 | "serializeJSON", | ||
1269 | "registerJSON", | ||
1270 | "evalJSON", | ||
1271 | "parseQueryString", | ||
1272 | "findValue", | ||
1273 | "findIdentical", | ||
1274 | "flattenArguments", | ||
1275 | "method", | ||
1276 | "average", | ||
1277 | "mean", | ||
1278 | "median" | ||
1279 | ]; | ||
1280 | |||
1281 | MochiKit.Base.EXPORT_OK = [ | ||
1282 | "nameFunctions", | ||
1283 | "comparatorRegistry", | ||
1284 | "reprRegistry", | ||
1285 | "jsonRegistry", | ||
1286 | "compareDateLike", | ||
1287 | "compareArrayLike", | ||
1288 | "reprArrayLike", | ||
1289 | "reprString", | ||
1290 | "reprNumber" | ||
1291 | ]; | ||
1292 | |||
1293 | MochiKit.Base._exportSymbols = function (globals, module) { | ||
1294 | if (!MochiKit.__export__) { | ||
1295 | return; | ||
1296 | } | ||
1297 | var all = module.EXPORT_TAGS[":all"]; | ||
1298 | for (var i = 0; i < all.length; i++) { | ||
1299 | globals[all[i]] = module[all[i]]; | ||
1300 | } | ||
1301 | }; | ||
1302 | |||
1303 | MochiKit.Base.__new__ = function () { | ||
1304 | // A singleton raised when no suitable adapter is found | ||
1305 | var m = this; | ||
1306 | |||
1307 | // convenience | ||
1308 | /** @id MochiKit.Base.noop */ | ||
1309 | m.noop = m.operator.identity; | ||
1310 | |||
1311 | // Backwards compat | ||
1312 | m.forward = m.forwardCall; | ||
1313 | m.find = m.findValue; | ||
1314 | |||
1315 | if (typeof(encodeURIComponent) != "undefined") { | ||
1316 | /** @id MochiKit.Base.urlEncode */ | ||
1317 | m.urlEncode = function (unencoded) { | ||
1318 | return encodeURIComponent(unencoded).replace(/\'/g, '%27'); | ||
1319 | }; | ||
1320 | } else { | ||
1321 | m.urlEncode = function (unencoded) { | ||
1322 | return escape(unencoded | ||
1323 | ).replace(/\+/g, '%2B' | ||
1324 | ).replace(/\"/g,'%22' | ||
1325 | ).rval.replace(/\'/g, '%27'); | ||
1326 | }; | ||
1327 | } | ||
1328 | |||
1329 | /** @id MochiKit.Base.NamedError */ | ||
1330 | m.NamedError = function (name) { | ||
1331 | this.message = name; | ||
1332 | this.name = name; | ||
1333 | }; | ||
1334 | m.NamedError.prototype = new Error(); | ||
1335 | m.update(m.NamedError.prototype, { | ||
1336 | repr: function () { | ||
1337 | if (this.message && this.message != this.name) { | ||
1338 | return this.name + "(" + m.repr(this.message) + ")"; | ||
1339 | } else { | ||
1340 | return this.name + "()"; | ||
1341 | } | ||
1342 | }, | ||
1343 | toString: m.forwardCall("repr") | ||
1344 | }); | ||
1345 | |||
1346 | /** @id MochiKit.Base.NotFound */ | ||
1347 | m.NotFound = new m.NamedError("MochiKit.Base.NotFound"); | ||
1348 | |||
1349 | |||
1350 | /** @id MochiKit.Base.listMax */ | ||
1351 | m.listMax = m.partial(m.listMinMax, 1); | ||
1352 | /** @id MochiKit.Base.listMin */ | ||
1353 | m.listMin = m.partial(m.listMinMax, -1); | ||
1354 | |||
1355 | /** @id MochiKit.Base.isCallable */ | ||
1356 | m.isCallable = m.typeMatcher('function'); | ||
1357 | /** @id MochiKit.Base.isUndefined */ | ||
1358 | m.isUndefined = m.typeMatcher('undefined'); | ||
1359 | |||
1360 | /** @id MochiKit.Base.merge */ | ||
1361 | m.merge = m.partial(m.update, null); | ||
1362 | /** @id MochiKit.Base.zip */ | ||
1363 | m.zip = m.partial(m.map, null); | ||
1364 | |||
1365 | /** @id MochiKit.Base.average */ | ||
1366 | m.average = m.mean; | ||
1367 | |||
1368 | /** @id MochiKit.Base.comparatorRegistry */ | ||
1369 | m.comparatorRegistry = new m.AdapterRegistry(); | ||
1370 | m.registerComparator("dateLike", m.isDateLike, m.compareDateLike); | ||
1371 | m.registerComparator("arrayLike", m.isArrayLike, m.compareArrayLike); | ||
1372 | |||
1373 | /** @id MochiKit.Base.reprRegistry */ | ||
1374 | m.reprRegistry = new m.AdapterRegistry(); | ||
1375 | m.registerRepr("arrayLike", m.isArrayLike, m.reprArrayLike); | ||
1376 | m.registerRepr("string", m.typeMatcher("string"), m.reprString); | ||
1377 | m.registerRepr("numbers", m.typeMatcher("number", "boolean"), m.reprNumber); | ||
1378 | |||
1379 | /** @id MochiKit.Base.jsonRegistry */ | ||
1380 | m.jsonRegistry = new m.AdapterRegistry(); | ||
1381 | |||
1382 | var all = m.concat(m.EXPORT, m.EXPORT_OK); | ||
1383 | m.EXPORT_TAGS = { | ||
1384 | ":common": m.concat(m.EXPORT_OK), | ||
1385 | ":all": all | ||
1386 | }; | ||
1387 | |||
1388 | m.nameFunctions(this); | ||
1389 | |||
1390 | }; | ||
1391 | |||
1392 | MochiKit.Base.__new__(); | ||
1393 | |||
1394 | // | ||
1395 | // XXX: Internet Explorer blows | ||
1396 | // | ||
1397 | if (MochiKit.__export__) { | ||
1398 | compare = MochiKit.Base.compare; | ||
1399 | compose = MochiKit.Base.compose; | ||
1400 | serializeJSON = MochiKit.Base.serializeJSON; | ||
1401 | } | ||
1402 | |||
1403 | MochiKit.Base._exportSymbols(this, MochiKit.Base); | ||