RubyGems - old_sql - Versions diffs - 1.16.0 → 1.17.0 - Mend

old_sql 1.16.0 → 1.17.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (273) hide show

data/public/javascripts/old_sql/MochiKit-1.4.2/tests/test_Logging.js DELETED Viewed

@@ -1,88 +0,0 @@
-if (typeof(dojo) != 'undefined') { dojo.require('MochiKit.Logging'); }
-if (typeof(JSAN) != 'undefined') { JSAN.use('MochiKit.Logging'); }
-if (typeof(tests) == 'undefined') { tests = {}; }
-tests.test_Logging = function (t) {
-    // just in case
-    logger.clear();
-    t.is( logLevelAtLeast('DEBUG')('INFO'), false, 'logLevelAtLeast false' );
-    t.is( logLevelAtLeast('WARNING')('INFO'), false, 'logLevelAtLeast true' );
-    t.ok( logger instanceof Logger, "global logger installed" );
-    var allMessages = [];
-    logger.addListener("allMessages", null,
-        bind(allMessages.push, allMessages));
-    var fatalMessages = [];
-    logger.addListener("fatalMessages", "FATAL",
-        bind(fatalMessages.push, fatalMessages));
-    var firstTwo = [];
-    logger.addListener("firstTwo", null,
-        bind(firstTwo.push, firstTwo));
-    log("foo");
-    var msgs = logger.getMessages();
-    t.is( msgs.length, 1, 'global log() put one message in queue' );
-    t.is( compare(allMessages, msgs), 0, "allMessages listener" );
-    var msg = msgs.pop();
-    t.is( compare(msg.info, ["foo"]), 0, "info matches" );
-    t.is( msg.level, "INFO", "level matches" );
-    logDebug("debugFoo");
-    t.is( msgs.length, 0, 'getMessages() returns copy' );
-    msgs = logger.getMessages();
-    t.is( compare(allMessages, msgs), 0, "allMessages listener" );
-    t.is( msgs.length, 2, 'logDebug()' );
-    msg = msgs.pop();
-    t.is( compare(msg.info, ["debugFoo"]), 0, "info matches" );
-    t.is( msg.level, "DEBUG", "level matches" );
-    logger.removeListener("firstTwo");
-    logError("errorFoo");
-    msgs = logger.getMessages();
-    t.is( compare(allMessages, msgs), 0, "allMessages listener" );
-    t.is( msgs.length, 3, 'logError()' );
-    msg = msgs.pop();
-    t.is( compare(msg.info, ["errorFoo"]), 0, "info matches" );
-    t.is( msg.level, "ERROR", "level matches" );
-    logWarning("warningFoo");
-    msgs = logger.getMessages();
-    t.is( compare(allMessages, msgs), 0, "allMessages listener" );
-    t.is( msgs.length, 4, 'logWarning()' );
-    msg = msgs.pop();
-    t.is( compare(msg.info, ["warningFoo"]), 0, "info matches" );
-    t.is( msg.level, "WARNING", "level matches" );
-    logFatal("fatalFoo");
-    msgs = logger.getMessages();
-    t.is( compare(allMessages, msgs), 0, "allMessages listener" );
-    t.is( msgs.length, 5, 'logFatal()' );
-    msg = msgs.pop();
-    t.is( compare(fatalMessages, [msg]), 0, "fatalMessages listener" );
-    t.is( compare(msg.info, ["fatalFoo"]), 0, "info matches" );
-    t.is( msg.level, "FATAL", "level matches" );
-    msgs = logger.getMessages(1);
-    t.is( compare(fatalMessages, msgs), 0, "getMessages with limit returns latest" );
-    logger.removeListener("allMessages");
-    logger.removeListener("fatalMessages");
-    t.is( compare(firstTwo, logger.getMessages().slice(0, 2)), 0, "firstTwo" );
-    logger.clear();
-    msgs = logger.getMessages();
-    t.is(msgs.length, 0, "clear removes existing messages");
-    logger.baseLog(LogLevel.INFO, 'infoFoo');
-    msg = logger.getMessages().pop();
-    t.is(msg.level, "INFO", "baseLog converts level")
-    logger.baseLog(45, 'errorFoo');
-    msg = logger.getMessages().pop();
-    t.is(msg.level, "ERROR", "baseLog converts ad-hoc level")
-};

data/public/javascripts/old_sql/MochiKit-1.4.2/tests/test_MochiKit-Async.html DELETED Viewed

@@ -1,408 +0,0 @@
-<html>
-<head>
-    <script type="text/javascript" src="../lib/MochiKit/Base.js"></script>
-    <script type="text/javascript" src="../lib/MochiKit/Async.js"></script>
-    <script type="text/javascript" src="../lib/MochiKit/Iter.js"></script>
-    <script type="text/javascript" src="../lib/MochiKit/DOM.js"></script>
-    <script type="text/javascript" src="../lib/MochiKit/Style.js"></script>
-    <script type="text/javascript" src="SimpleTest/SimpleTest.js"></script>
-    <link rel="stylesheet" type="text/css" href="SimpleTest/test.css">
-</head>
-<body>
-<pre id="test">
-<script type="text/javascript">
-try {
-    var increment = function (res) {
-        return res + 1;
-    }
-    var throwStuff = function (res) {
-        throw new GenericError(res);
-    }
-    var catchStuff = function (res) {
-        return res.message;
-    }
-    var returnError = function (res) {
-        return new GenericError(res);
-    }
-    var anythingOkCallback = function (msg) {
-        return function (res) {
-            ok(true, msg);
-            return res;
-        }
-    }
-    var testEqCallback = function () {
-        /*
-            sort of emulate how deferreds work in Twisted
-            for "convenient" testing
-        */
-        var args = [];
-        for (var i = 0; i < arguments.length; i++) {
-            args.push(arguments[i]);
-        }
-        return function (res) {
-            var nargs = args.slice();
-            nargs.unshift(res);
-            is.apply(this, nargs);
-            return res;
-        }
-    }
-    var neverHappen = function (d) {
-        ok(false, "this should never happen");
-    }
-    /*
-        Test normal Deferred operation
-    */
-    var d = new Deferred();
-    d.addCallback(testEqCallback(1, "pre-deferred callback"));
-    d.callback(1);
-    d.addCallback(increment);
-    d.addCallback(testEqCallback(2, "post-deferred callback"));
-    d.addCallback(throwStuff);
-    d.addCallback(neverHappen);
-    d.addErrback(catchStuff);
-    d.addCallback(testEqCallback(2, "throw -> err, catch -> success"));
-    d.addCallback(returnError);
-    d.addCallback(neverHappen);
-    d.addErrback(catchStuff);
-    d.addCallback(testEqCallback(2, "return -> err, catch -> succcess"));
-    /*
-        Test Deferred cancellation
-    */
-    var cancelled = function (d) {
-        ok(true, "canceller called!");
-    }
-    var cancelledError = function (res) {
-        ok(res instanceof CancelledError, "CancelledError here");
-    }
-    d = new Deferred(cancelled);
-    d.addCallback(neverHappen);
-    d.addErrback(cancelledError);
-    d.cancel();
-    /*
-        Test succeed / fail
-    */
-    d = succeed(1).addCallback(testEqCallback(1, "succeed"));
-    // default error
-    d = fail().addCallback(neverHappen);
-    d = d.addErrback(anythingOkCallback("default fail"));
-    // default wrapped error
-    d = fail("web taco").addCallback(neverHappen).addErrback(catchStuff);
-    d = d.addCallback(testEqCallback("web taco", "wrapped fail"));
-    // default unwrapped error
-    d = fail(new GenericError("ugh")).addCallback(neverHappen).addErrback(catchStuff);
-    d = d.addCallback(testEqCallback("ugh", "unwrapped fail"));
-    /*
-        Test deferred dependencies
-    */
-    var deferredIncrement = function (res) {
-        var rval = succeed(res);
-        rval.addCallback(increment);
-        return rval;
-    }
-    d = succeed(1).addCallback(deferredIncrement);
-    d = d.addCallback(testEqCallback(2, "dependent deferred succeed"));
-    var deferredFailure = function (res) {
-        return fail(res);
-    }
-    d = succeed("ugh").addCallback(deferredFailure).addErrback(catchStuff);
-    d = d.addCallback(testEqCallback("ugh", "dependent deferred fail"));
-    /*
-        Test double-calling, double-failing, etc.
-    */
-    try {
-        succeed(1).callback(2);
-        neverHappen();
-    } catch (e) {
-        ok(e instanceof AlreadyCalledError, "double-call");
-    }
-    try {
-        fail(1).errback(2);
-        neverHappen();
-    } catch (e) {
-        ok(e instanceof AlreadyCalledError, "double-fail");
-    }
-    try {
-        d = succeed(1);
-        d.cancel();
-        d = d.callback(2);
-        ok(true, "swallowed one callback, no canceller");
-        d.callback(3);
-        neverHappen();
-    } catch (e) {
-        ok(e instanceof AlreadyCalledError, "swallow cancel");
-    }
-    try {
-        d = new Deferred(cancelled);
-        d.cancel();
-        d = d.callback(1);
-        neverHappen();
-    } catch (e) {
-        ok(e instanceof AlreadyCalledError, "non-swallowed cancel");
-    }
-    /* Test incorrect Deferred usage */
-    d = new Deferred();
-    try {
-        d.callback(new Deferred());
-        neverHappen();
-    } catch (e) {
-        ok (e instanceof Error, "deferred not allowed for callback");
-    }
-    d = new Deferred();
-    try {
-        d.errback(new Deferred());
-        neverHappen();
-    } catch (e) {
-        ok (e instanceof Error, "deferred not allowed for errback");
-    }
-    d = new Deferred();
-    (new Deferred()).addCallback(function () { return d; }).callback(1);
-    try {
-        d.addCallback(function () {});
-        neverHappen();
-    } catch (e) {
-        ok (e instanceof Error, "chained deferred not allowed to be re-used");
-    }
-    /*
-        evalJSONRequest test
-    */
-    var fakeReq = {"responseText":'[1,2,3,4,"asdf",{"a":["b", "c"]}]'};
-    var obj = [1,2,3,4,"asdf",{"a":["b", "c"]}];
-    isDeeply(obj, evalJSONRequest(fakeReq), "evalJSONRequest");
-    try {
-        MochiKit.Async.getXMLHttpRequest();
-        ok(true, "getXMLHttpRequest");
-    } catch (e) {
-        ok(false, "no love from getXMLHttpRequest");
-    }
-    var lock = new DeferredLock();
-    var lst = [];
-    var pushNumber = function (x) {
-        return function (res) { lst.push(x); }
-    };
-    lock.acquire().addCallback(pushNumber(1));
-    is( compare(lst, [1]), 0, "lock acquired" );
-    lock.acquire().addCallback(pushNumber(2));
-    is( compare(lst, [1]), 0, "lock waiting for release" );
-    lock.acquire().addCallback(pushNumber(3));
-    is( compare(lst, [1]), 0, "lock waiting for release" );
-    lock.release();
-    is( compare(lst, [1, 2]), 0, "lock passed on" );
-    lock.release();
-    is( compare(lst, [1, 2, 3]), 0, "lock passed on" );
-    lock.release();
-    try {
-        lock.release();
-        ok( false, "over-release didn't raise" );
-    } catch (e) {
-        ok( true, "over-release raised" );
-    }
-    lock.acquire().addCallback(pushNumber(1));
-    is( compare(lst, [1, 2, 3, 1]), 0, "lock acquired" );
-    lock.release();
-    is( compare(lst, [1, 2, 3, 1]), 0, "lock released" );
-    var d = new Deferred();
-    lst = [];
-    d.addCallback(operator.add, 2);
-    d.addBoth(operator.add, 4);
-    d.addCallback(bind(lst.push, lst));
-    d.callback(1);
-    is( lst[0], 7, "auto-partial addCallback addBoth" );
-    d.addCallback(function () { throw new Error(); });
-    ebTest = function(a, b) {
-        map(bind(lst.push, lst), arguments);
-    };
-    d.addErrback(ebTest, "foo");
-    is( lst[1], "foo", "auto-partial errback" );
-    is( lst.length, 3, "auto-partial errback" );
-    /*
-        Test DeferredList
-    */
-    var callList = [new Deferred(), new Deferred(), new Deferred()];
-    callList[0].addCallback(increment);
-    callList[1].addCallback(increment);
-    callList[2].addCallback(increment);
-    var defList = new DeferredList(callList);
-    ok(defList instanceof Deferred, "DeferredList looks like a Deferred");
-    callList[0].callback(3);
-    callList[1].callback(5);
-    callList[2].callback(4);
-    defList.addCallback(function (lst) {
-        is( arrayEqual(lst, [[true, 4], [true, 6], [true, 5]]), 1,
-           "deferredlist result ok" );
-    });
-    /*
-        Test fireOnOneCallback
-    */
-    var callList2 = [new Deferred(), new Deferred(), new Deferred()];
-    callList2[0].addCallback(increment);
-    callList2[1].addCallback(increment);
-    callList2[2].addCallback(increment);
-    var defList2 = new DeferredList(callList2, true);
-    callList2[1].callback(5);
-    callList2[0].callback(3);
-    callList2[2].callback(4);
-    defList2.addCallback(function (lst) {
-        is( arrayEqual(lst, [1, 6]), 1, "deferredlist fireOnOneCallback ok" );
-    });
-    /*
-        Test fireOnOneErrback
-    */
-    var callList3 = [new Deferred(), new Deferred(), new Deferred()];
-    callList3[0].addCallback(increment);
-    callList3[1].addCallback(throwStuff);
-    callList3[2].addCallback(increment);
-    var defList3 = new DeferredList(callList3, false, true);
-    defList3.callback = neverHappen;
-    callList3[0].callback(3);
-    callList3[1].callback("foo");
-    callList3[2].callback(4);
-    defList3.addErrback(function (err) {
-        is( err.message, "foo", "deferredlist fireOnOneErrback ok" );
-    });
-    /*
-        Test consumeErrors
-    */
-    var callList4 = [new Deferred(), new Deferred(), new Deferred()];
-    callList4[0].addCallback(increment);
-    callList4[1].addCallback(throwStuff);
-    callList4[2].addCallback(increment);
-    var defList4 = new DeferredList(callList4, false, false, true);
-    defList4.addErrback(neverHappen);
-    callList4[1].addCallback(function (arg) {
-        is(arg, null, "deferredlist consumeErrors ok" );
-    });
-    callList4[0].callback(3);
-    callList4[1].callback("foo");
-    callList4[2].callback(4);
-    /*
-        Test gatherResults
-    */
-    var callList5 = [new Deferred(), new Deferred(), new Deferred()];
-    callList5[0].addCallback(increment);
-    callList5[1].addCallback(increment);
-    callList5[2].addCallback(increment);
-    var gatherRet = gatherResults(callList5);
-    callList5[0].callback(3);
-    callList5[1].callback(5);
-    callList5[2].callback(4);
-    gatherRet.addCallback(function (lst) {
-        is( arrayEqual(lst, [4, 6, 5]), 1,
-           "gatherResults result ok" );
-    });
-    /*
-        Test maybeDeferred
-    */
-    var maybeDef = maybeDeferred(increment, 4);
-    maybeDef.addCallback(testEqCallback(5, "maybeDeferred sync ok"));
-    var maybeDef2 = deferredIncrement(8);
-    maybeDef2.addCallback(testEqCallback(9, "maybeDeferred async ok"));
-    ok( true, "synchronous test suite finished!");
-    var t = (new Date().getTime());
-    SimpleTest.waitForExplicitFinish();
-    checkCallLater = function (originalTime) {
-        is(originalTime, t, "argument passed in OK");
-        is(arguments.length, 1, "argument count right");
-    };
-    var lock = new DeferredLock();
-    withLock = function (msg) {
-        var cb = partial.apply(null, extend(null, arguments, 1));
-        var d = lock.acquire().addCallback(cb);
-        d.addErrback(ok, false, msg);
-        d.addCallback(function () {
-            ok(true, msg);
-            lock.release();
-        });
-        return d;
-    }
-    withLock("callLater", function () {
-        return callLater(0.05, checkCallLater, t);
-    });
-    withLock("wait", function () {
-        return wait(0.05, t).addCallback(checkCallLater);
-    });
-    withLock("loadJSONDoc", function () {
-        var d = loadJSONDoc("test_MochiKit-Async.json");
-        d.addCallback(function (doc) {
-            is(doc.passed,  true, "loadJSONDoc passed");
-        });
-        d.addErrback(function (doc) {
-            ok(false, "loadJSONDoc failed");
-        });
-        return d;
-    });
-    lock.acquire().addCallback(function () {
-        ok(true, "async suite finished");
-        SimpleTest.finish();
-    });
-} catch (err) {
-    var s = "test suite failure!\n";
-    var o = {};
-    var k = null;
-    for (k in err) {
-        // ensure unique keys?!
-        if (!o[k]) {
-            s +=  k + ": " + err[k] + "\n";
-            o[k] = err[k];
-        }
-    }
-    ok ( false, s );
-    SimpleTest.finish();
-}
-</script>
-</pre>
-</body>
-</html>