RubyGems - old_sql - Versions diffs - 1.12.0 → 1.13.0 - Mend

old_sql 1.12.0 → 1.13.0

Files changed (263) hide show

data/public/javascripts/old_sql/MochiKit-1.4.2/packed/MochiKit/__package__.js ADDED Viewed

@@ -0,0 +1,6 @@
+dojo.kwCompoundRequire({
+    "common": [
+        "MochiKit.MochiKit"
+    ]
+});
+dojo.provide("MochiKit.*");

data/public/javascripts/old_sql/MochiKit-1.4.2/packed/MochiKit/customize.html ADDED Viewed

@@ -0,0 +1,251 @@
+<html>
+  <head>
+    <title>MochiKit Customizer</title>
+    <link type="text/css" rel="stylesheet" href="../../include/css/documentation.css" />
+    <style type="text/css">
+      td {
+          vertical-align: top;
+      }
+      label {
+          font-weight: bold;
+          font-size: 14px;
+      }
+      input {
+          margin: 0;
+          vertical-align: -3px;
+      }
+      .info {
+          color: #888888;
+      }
+    </style>
+    <script type="text/javascript" src="MochiKit.js"></script>
+    <script type="text/javascript">
+// Predefined module sets
+var SETS = {
+    core: { name: "Non-Web Modules", deps: ["Base", "DateTime", "Format", "Iter"] },
+    standard: { name: "Web Modules", deps: ["Base", "DateTime", "Format", "Iter", "Async", "Color", "DOM", "Logging", "LoggingPane", "Selector", "Signal", "Style"] },
+    all: { name: "Extension Modules", deps: null }
+};
+var MODULES = { "Base": { deps: [], packed: "" } };
+// Starts loading the packed library
+function doInit() {
+    var url = $$("head script[src*=MochiKit.js]")[0].src;
+    var d = doSimpleXMLHttpRequest(url);
+    d.addCallback(doParseScript);
+    d.addErrback(function(err) {
+        alert("Error: " + err.toString());
+    });
+}
+// Parses the packed library into modules
+function doParseScript(xhr) {
+    var src = xhr.responseText;
+    var moduleName = "Base";
+    var pos = 0;
+    while ((pos = src.indexOf("MochiKit.Base._deps")) >= 0) {
+        if (pos > 0) {
+            MODULES[moduleName].packed += src.substring(0, pos);
+            src = src.substring(pos);
+        }
+        var names = doFindStringLiterals(src);
+        if (names.length > 0) {
+            moduleName = names[0];
+            MODULES[moduleName] = { deps: names.slice(1), packed: "" };
+        }
+        pos = src.indexOf("MochiKit.Base._exportSymbols");
+        pos = src.indexOf("\n", pos);
+        MODULES[moduleName].packed += src.substring(0, pos + 1);
+        src = src.substring(pos + 1);
+    }
+    MODULES["Base"].packedTail = src;
+    for (var key in MODULES) {
+        var m = MODULES[key];
+        m.size = m.packed.length;
+        if (m.packedTail) {
+            m.size += m.packedTail.length;
+        }
+    }
+    SETS.all.deps = keys(MODULES);
+    for (var key in SETS) {
+        var s = SETS[key];
+        s.size = 0;
+        for (var i = 0; i < s.deps.length; i++) {
+            s.size += MODULES[s.deps[i]].size;
+        }
+    }
+    doRender();
+}
+// Find all string literals on the first line
+function doFindStringLiterals(str) {
+    var res = [];
+    var endPos = str.indexOf("\n");
+    var line = str.substring(0, (endPos > 0) ? endPos : str.length);
+    var matches = line.match(/"([^"]*)"|'([^']*)'/g);
+    for (var i = 0; i < matches.length; i++) {
+        var name = matches[i];
+        res.push(name.substring(1, name.length - 1));
+    }
+    return res;
+}
+// Renders the module selection UI
+function doRender() {
+    var nf = numberFormatter("0.0 kB");
+    var select = $("packSets");
+    var cell = $("packModules");
+    for (var key in SETS) {
+        var s = SETS[key];
+        var text = s.name + " \u2014 " + nf(s.size / 1024);
+        select.appendChild(OPTION({ value: key }, text));
+        if (key != "core") {
+            cell.appendChild(HR());
+        }
+        cell.appendChild(H3({}, s.name, ":"));
+        for (var i = 0; i < s.deps.length; i++) {
+            var name = s.deps[i];
+            var m = MODULES[name];
+            if (m.dom == null) {
+                m.dom = INPUT({ type: "checkbox" });
+                if (name == "Base") {
+                    m.dom.disabled = true;
+                }
+                var text = " \u2014 " + nf(m.size / 1024);
+                if (m.deps.length > 1) {
+                    text += " \u2014 uses " + m.deps.slice(1).join(", ");
+                }
+                var span = SPAN({ "class": "info" }, text);
+                cell.appendChild(LABEL({}, m.dom, " MochiKit." + name, span));
+                cell.appendChild(BR());
+                connect(m.dom, "onclick", partial(doChangeModule, name));
+            }
+        }
+    }
+    select.appendChild(OPTION({ value: "custom" }, "Selected Modules"));
+    select.selectedIndex = 1;
+    connect(select, "onchange", doChangeSet);
+    doChangeSet();
+}
+// Handle module set changes
+function doChangeSet() {
+    var key = $("packSets").value;
+    var s = SETS[key];
+    if (s != null) {
+        doCheckBoxes(s.deps, true);
+        var fun = function(name) { return findValue(s.deps, name) < 0; };
+        var other = filter(fun, keys(MODULES));
+        doCheckBoxes(other, false);
+        doUpdateCustom();
+    }
+}
+// Handle individual module changes
+function doChangeModule(name) {
+    var m = MODULES[name];
+    if (m.dom.checked) {
+        var deps = m.deps.slice(0);
+        for (var i = 0; i < deps.length; i++) {
+            var sub = MODULES[deps[i]].deps;
+            for (var j = 0; j < sub.length; j++) {
+                if (findValue(deps, sub[j]) < 0) {
+                    deps.push(sub[j]);
+                }
+            }
+        }
+    } else {
+        var deps = [name];
+        for (var i = 0; i < deps.length; i++) {
+            for (var id in MODULES) {
+                if (findValue(deps, id) < 0 &&
+                    findValue(MODULES[id].deps, deps[i]) >= 0) {
+                    deps.push(id);
+                }
+            }
+        }
+    }
+    doCheckBoxes(deps, m.dom.checked);
+    doUpdateCustom();
+    var select = $("packSets");
+    select.selectedIndex = 3;
+}
+// Checks or unchecks the specified modules
+function doCheckBoxes(names, checked) {
+    for (var i = 0; i < names.length; i++) {
+        var name = names[i];
+        var input = MODULES[name].dom;
+        if (input.checked != checked) {
+            input.checked = checked;
+            var color = checked ? '#aaffaa' : '#ffaaaa';
+            Highlight(input.parentNode, { startcolor: color });
+        }
+    }
+}
+function doUpdateCustom() {
+    var select = $("packSets");
+    var nf = numberFormatter("0.0 kB");
+    var size = 0;
+    for (var id in MODULES) {
+        var m = MODULES[id];
+        if (m.dom.checked) {
+            size += m.size;
+        }
+    }
+    var option = select.childNodes[3];
+    replaceChildNodes(option, "Selected Modules \u2014 " + nf(size / 1024));
+}
+function doSubmit() {
+    var packed = "";
+    if (!$("packExport").checked) {
+        packed += "// Config options\n";
+        packed += "MochiKit={__export__:false};\n\n";
+    }
+    for (var id in MODULES) {
+        var m = MODULES[id];
+        if (m.dom.checked) {
+            packed += m.packed;
+        }
+    }
+    packed += MODULES["Base"].packedTail;
+    $("packData").value = packed;
+    return true;
+}
+    </script>
+  </head>
+  <body onload="doInit()">
+    <a href="http://mochikit.com/"><img id="mainlink" src="../../include/_img/g_logo_doc.gif" alt="I &hearts; MochiKit" title="I &hearts; MochiKit" /></a>
+    <div class="document">
+      <div class="section">
+        <h1>MochiKit Customizer</h1>
+    <form action="http://mochikit-dot-com.appspot.com/download" method="POST" onsubmit="return doSubmit();">
+      <table>
+        <tbody>
+          <tr>
+            <td style="border-right: 1px solid rgb(204, 204, 204); padding-right: 10px;">
+              <h3>Module Sets:</h3>
+              <select id="packSets"></select>
+              <hr style="margin-top: 200px;">
+              <h3>Additional Options:</h3>
+              <label><input id="packExport" checked="checked" type="checkbox"> Export Globals</label><br>
+            </td>
+            <td id="packModules" style="padding-left: 10px;">
+            </td>
+          </tr>
+          <tr>
+            <td colspan="2" style="padding-top: 20px;">
+              <button type="submit">Create Customized MochiKit</button>
+            </td>
+          </tr>
+        </tbody>
+      </table>
+      <input id="packData" type="hidden" name="data" value="" />
+    </form>
+      </div>
+    </div>
+  </body>
+</html>

data/public/javascripts/old_sql/MochiKit-1.4.2/tests/FakeJSAN.js ADDED Viewed

@@ -0,0 +1,40 @@
+var JSAN = {
+    global: this,
+    use: function (module, symbols) {
+        var components = module.split(/\./);
+        var fn = components.join('/') + '.js';
+        var o = JSAN.global;
+        var i, c;
+        for (i = 0; i < components.length; i++) {
+            o = o[components[i]];
+            if (typeof(o) == 'undefined') {
+                break;
+            }
+        }
+        if (typeof(o) != 'undefined') {
+            return o;
+        }
+        load(fn);
+        o = JSAN.global;
+        for (i = 0; i < components.length; i++) {
+            o = o[components[i]];
+            if (typeof(o) == 'undefined') {
+                return undefined;
+            }
+        }
+        if (!symbols) {
+            var tags = o.EXPORT_TAGS;
+            if (tags) {
+                symbols = tags[':common'] || tags[':all'];
+            }
+        }
+        if (symbols) {
+            for (i = 0; i < symbols.length; i++) {
+                c = symbols[i];
+                JSAN.global[c] = o[c];
+            }
+        }
+        return o;
+    }
+};

data/public/javascripts/old_sql/MochiKit-1.4.2/tests/SimpleTest/SimpleTest.js ADDED Viewed

@@ -0,0 +1,381 @@
+/**
+ * SimpleTest, a partial Test.Simple/Test.More API compatible test library.
+ *
+ * Why?
+ *
+ * Test.Simple doesn't work on IE < 6.
+ * TODO:
+ *  * Support the Test.Simple API used by MochiKit, to be able to test MochiKit
+ * itself against IE 5.5
+ *
+**/
+if (typeof(SimpleTest) == "undefined") {
+    var SimpleTest = {};
+}
+// Check to see if the TestRunner is present and has logging
+if (typeof(parent) != "undefined" && parent.TestRunner) {
+    SimpleTest._logEnabled = parent.TestRunner.logEnabled;
+}
+SimpleTest._tests = [];
+SimpleTest._stopOnLoad = true;
+/**
+ * Something like assert.
+ */
+SimpleTest.ok = function (condition, name, diag) {
+    var test = {'result': !!condition, 'name': name, 'diag': diag || ""};
+    if (SimpleTest._logEnabled) {
+        var msg = test.result ? "PASS" : "FAIL";
+        msg += " | " + test.name;
+        if (test.result) {
+            parent.TestRunner.logger.log(msg);
+        } else {
+            msg += " | " + test.diag;
+            parent.TestRunner.logger.error(msg);
+        }
+    }
+    SimpleTest._tests.push(test);
+};
+/**
+ * Roughly equivalent to ok(a==b, name)
+ */
+SimpleTest.is = function (a, b, name) {
+    var repr = MochiKit.Base.repr;
+    SimpleTest.ok(a == b, name, "got " + repr(a) + ", expected " + repr(b));
+};
+/**
+ * Roughly equivalent to ok(compare(a,b)==0, name)
+ */
+SimpleTest.eq = function (a, b, name) {
+    var repr = MochiKit.Base.repr;
+    try {
+        SimpleTest.ok(compare(a, b) == 0, name, "got " + repr(a) + ", expected " + repr(b));
+    } catch (e) {
+        SimpleTest.ok(false, name, "exception in compare: " + repr(e));
+    }
+};
+/**
+ * Makes a test report, returns it as a DIV element.
+**/
+SimpleTest.report = function () {
+    var DIV = MochiKit.DOM.DIV;
+    var passed = 0;
+    var failed = 0;
+    var results = MochiKit.Base.map(
+        function (test) {
+            var cls, msg;
+            if (test.result) {
+                passed++;
+                cls = "test_ok";
+                msg = "ok - " + test.name;
+            } else {
+                failed++;
+                cls = "test_not_ok";
+                msg = "not ok - " + test.name;
+                if (test.diag != null && test.diag != "") {
+                    msg += ": " + test.diag;
+                }
+            }
+            return DIV({"class": cls}, msg);
+        },
+        SimpleTest._tests
+    );
+    var summary_class = ((failed == 0) ? 'all_pass' : 'some_fail');
+    return DIV({'class': 'tests_report'},
+        DIV({'class': 'tests_summary ' + summary_class},
+            DIV({'class': 'tests_passed'}, "Passed: " + passed),
+            DIV({'class': 'tests_failed'}, "Failed: " + failed)),
+        results
+    );
+};
+/**
+ * Toggle element visibility
+**/
+SimpleTest.toggle = function(el) {
+    if (MochiKit.Style.getStyle(el, 'display') == 'block') {
+        el.style.display = 'none';
+    } else {
+        el.style.display = 'block';
+    }
+};
+/**
+ * Toggle visibility for divs with a specific class.
+**/
+SimpleTest.toggleByClass = function (cls) {
+    var elems = getElementsByTagAndClassName('div', cls);
+    MochiKit.Base.map(SimpleTest.toggle, elems);
+};
+/**
+ * Shows the report in the browser
+**/
+SimpleTest.showReport = function() {
+    var togglePassed = A({'href': '#'}, "Toggle passed tests");
+    var toggleFailed = A({'href': '#'}, "Toggle failed tests");
+    togglePassed.onclick = partial(SimpleTest.toggleByClass, 'test_ok');
+    toggleFailed.onclick = partial(SimpleTest.toggleByClass, 'test_not_ok');
+    var body = document.getElementsByTagName("body")[0];
+    var firstChild = body.childNodes[0];
+    var addNode;
+    if (firstChild) {
+        addNode = function (el) {
+            body.insertBefore(el, firstChild);
+        };
+    } else {
+        addNode = function (el) {
+            body.appendChild(el)
+        };
+    }
+    addNode(togglePassed);
+    addNode(SPAN(null, " "));
+    addNode(toggleFailed);
+    addNode(SimpleTest.report());
+};
+/**
+ * Tells SimpleTest to don't finish the test when the document is loaded,
+ * useful for asynchronous tests.
+ *
+ * When SimpleTest.waitForExplicitFinish is called,
+ * explicit SimpleTest.finish() is required.
+**/
+SimpleTest.waitForExplicitFinish = function () {
+    SimpleTest._stopOnLoad = false;
+};
+/**
+ * Talks to the TestRunner if being ran on a iframe and the parent has a
+ * TestRunner object.
+**/
+SimpleTest.talkToRunner = function () {
+    if (typeof(parent) != "undefined" && parent.TestRunner) {
+        parent.TestRunner.testFinished(document);
+    }
+};
+/**
+ * Finishes the tests. This is automatically called, except when
+ * SimpleTest.waitForExplicitFinish() has been invoked.
+**/
+SimpleTest.finish = function () {
+    SimpleTest.showReport();
+    SimpleTest.talkToRunner();
+};
+addLoadEvent(function() {
+    if (SimpleTest._stopOnLoad) {
+        SimpleTest.finish();
+    }
+});
+//  --------------- Test.Builder/Test.More isDeeply() -----------------
+SimpleTest.DNE = {dne: 'Does not exist'};
+SimpleTest.LF = "\r\n";
+SimpleTest._isRef = function (object) {
+    var type = typeof(object);
+    return type == 'object' || type == 'function';
+};
+SimpleTest._deepCheck = function (e1, e2, stack, seen) {
+    var ok = false;
+    // Either they're both references or both not.
+    var sameRef = !(!SimpleTest._isRef(e1) ^ !SimpleTest._isRef(e2));
+    if (e1 == null && e2 == null) {
+        ok = true;
+    } else if (e1 != null ^ e2 != null) {
+        ok = false;
+    } else if (e1 == SimpleTest.DNE ^ e2 == SimpleTest.DNE) {
+        ok = false;
+    } else if (sameRef && e1 == e2) {
+        // Handles primitives and any variables that reference the same
+        // object, including functions.
+        ok = true;
+    } else if (SimpleTest.isa(e1, 'Array') && SimpleTest.isa(e2, 'Array')) {
+        ok = SimpleTest._eqArray(e1, e2, stack, seen);
+    } else if (typeof e1 == "object" && typeof e2 == "object") {
+        ok = SimpleTest._eqAssoc(e1, e2, stack, seen);
+    } else {
+        // If we get here, they're not the same (function references must
+        // always simply rererence the same function).
+        stack.push({ vals: [e1, e2] });
+        ok = false;
+    }
+    return ok;
+};
+SimpleTest._eqArray = function (a1, a2, stack, seen) {
+    // Return if they're the same object.
+    if (a1 == a2) return true;
+    // JavaScript objects have no unique identifiers, so we have to store
+    // references to them all in an array, and then compare the references
+    // directly. It's slow, but probably won't be much of an issue in
+    // practice. Start by making a local copy of the array to as to avoid
+    // confusing a reference seen more than once (such as [a, a]) for a
+    // circular reference.
+    for (var j = 0; j < seen.length; j++) {
+        if (seen[j][0] == a1) {
+            return seen[j][1] == a2;
+        }
+    }
+    // If we get here, we haven't seen a1 before, so store it with reference
+    // to a2.
+    seen.push([ a1, a2 ]);
+    var ok = true;
+    // Only examines enumerable attributes. Only works for numeric arrays!
+    // Associative arrays return 0. So call _eqAssoc() for them, instead.
+    var max = a1.length > a2.length ? a1.length : a2.length;
+    if (max == 0) return SimpleTest._eqAssoc(a1, a2, stack, seen);
+    for (var i = 0; i < max; i++) {
+        var e1 = i > a1.length - 1 ? SimpleTest.DNE : a1[i];
+        var e2 = i > a2.length - 1 ? SimpleTest.DNE : a2[i];
+        stack.push({ type: 'Array', idx: i, vals: [e1, e2] });
+        if (ok = SimpleTest._deepCheck(e1, e2, stack, seen)) {
+            stack.pop();
+        } else {
+            break;
+        }
+    }
+    return ok;
+};
+SimpleTest._eqAssoc = function (o1, o2, stack, seen) {
+    // Return if they're the same object.
+    if (o1 == o2) return true;
+    // JavaScript objects have no unique identifiers, so we have to store
+    // references to them all in an array, and then compare the references
+    // directly. It's slow, but probably won't be much of an issue in
+    // practice. Start by making a local copy of the array to as to avoid
+    // confusing a reference seen more than once (such as [a, a]) for a
+    // circular reference.
+    seen = seen.slice(0);
+    for (var j = 0; j < seen.length; j++) {
+        if (seen[j][0] == o1) {
+            return seen[j][1] == o2;
+        }
+    }
+    // If we get here, we haven't seen o1 before, so store it with reference
+    // to o2.
+    seen.push([ o1, o2 ]);
+    // They should be of the same class.
+    var ok = true;
+    // Only examines enumerable attributes.
+    var o1Size = 0; for (var i in o1) o1Size++;
+    var o2Size = 0; for (var i in o2) o2Size++;
+    var bigger = o1Size > o2Size ? o1 : o2;
+    for (var i in bigger) {
+        var e1 = o1[i] == undefined ? SimpleTest.DNE : o1[i];
+        var e2 = o2[i] == undefined ? SimpleTest.DNE : o2[i];
+        stack.push({ type: 'Object', idx: i, vals: [e1, e2] });
+        if (ok = SimpleTest._deepCheck(e1, e2, stack, seen)) {
+            stack.pop();
+        } else {
+            break;
+        }
+    }
+    return ok;
+};
+SimpleTest._formatStack = function (stack) {
+    var variable = '$Foo';
+    for (var i = 0; i < stack.length; i++) {
+        var entry = stack[i];
+        var type = entry['type'];
+        var idx = entry['idx'];
+        if (idx != null) {
+            if (/^\d+$/.test(idx)) {
+                // Numeric array index.
+                variable += '[' + idx + ']';
+            } else {
+                // Associative array index.
+                idx = idx.replace("'", "\\'");
+                variable += "['" + idx + "']";
+            }
+        }
+    }
+    var vals = stack[stack.length-1]['vals'].slice(0, 2);
+    var vars = [
+        variable.replace('$Foo',     'got'),
+        variable.replace('$Foo',     'expected')
+    ];
+    var out = "Structures begin differing at:" + SimpleTest.LF;
+    for (var i = 0; i < vals.length; i++) {
+        var val = vals[i];
+        if (val == null) {
+            val = 'undefined';
+        } else {
+             val == SimpleTest.DNE ? "Does not exist" : "'" + val + "'";
+        }
+    }
+    out += vars[0] + ' = ' + vals[0] + SimpleTest.LF;
+    out += vars[1] + ' = ' + vals[1] + SimpleTest.LF;
+    return '    ' + out;
+};
+SimpleTest.isDeeply = function (it, as, name) {
+    var ok;
+    // ^ is the XOR operator.
+    if (SimpleTest._isRef(it) ^ SimpleTest._isRef(as)) {
+        // One's a reference, one isn't.
+        ok = false;
+    } else if (!SimpleTest._isRef(it) && !SimpleTest._isRef(as)) {
+        // Neither is an object.
+        ok = SimpleTest.is(it, as, name);
+    } else {
+        // We have two objects. Do a deep comparison.
+        var stack = [], seen = [];
+        if ( SimpleTest._deepCheck(it, as, stack, seen)) {
+            ok = SimpleTest.ok(true, name);
+        } else {
+            ok = SimpleTest.ok(false, name, SimpleTest._formatStack(stack));
+        }
+    }
+    return ok;
+};
+SimpleTest.typeOf = function (object) {
+    var c = Object.prototype.toString.apply(object);
+    var name = c.substring(8, c.length - 1);
+    if (name != 'Object') return name;
+    // It may be a non-core class. Try to extract the class name from
+    // the constructor function. This may not work in all implementations.
+    if (/function ([^(\s]+)/.test(Function.toString.call(object.constructor))) {
+        return RegExp.$1;
+    }
+    // No idea. :-(
+    return name;
+};
+SimpleTest.isa = function (object, clas) {
+    return SimpleTest.typeOf(object) == clas;
+};
+// Global symbols:
+var ok = SimpleTest.ok;
+var is = SimpleTest.is;
+var isDeeply = SimpleTest.isDeeply;