gollum 2.0.0 → 2.1.0

data/lib/gollum/frontend/public/gollum/livepreview/js/ace/lib/ace/test/all_browser.js

@@ -0,0 +1,136 @@
+define(function(require, exports, module) {
+"use strict";
+
+require("ace/lib/fixoldbrowsers");
+var AsyncTest = require("asyncjs").test;
+var async = require("asyncjs");
+
+var passed = 0
+var failed = 0
+var log = document.getElementById("log")
+
+var testNames = [
+    "ace/anchor_test",
+    "ace/background_tokenizer_test",
+    "ace/commands/command_manager_test",
+    "ace/document_test",
+    "ace/edit_session_test",
+    "ace/editor_change_document_test",
+    "ace/editor_highlight_selected_word_test",
+    "ace/editor_navigation_test",
+    "ace/editor_text_edit_test",
+    "ace/ext/static_highlight_test",
+    "ace/layer/text_test",
+    "ace/lib/event_emitter_test",
+    "ace/mode/coffee/parser_test",
+    "ace/mode/coffee_highlight_rules_test",
+    "ace/mode/coldfusion_test",
+    "ace/mode/css_test",
+    "ace/mode/css_highlight_rules_test",
+    "ace/mode/css_worker",
+    "ace/mode/html_test",
+    "ace/mode/html_highlight_rules_test",
+    "ace/mode/javascript_test",
+    "ace/mode/javascript_highlight_rules_test",
+    "ace/mode/javascript_worker_test",
+    "ace/mode/python_test",
+    "ace/mode/ruby_highlight_rules_test",
+    "ace/mode/text_test",
+    "ace/mode/xml_test",
+    "ace/mode/xml_highlight_rules_test",
+    "ace/mode/folding/cstyle_test",
+    "ace/mode/folding/html_test",
+    "ace/mode/folding/pythonic_test",
+    "ace/mode/folding/xml_test",
+    "ace/mode/folding/coffee_test",
+    "ace/multi_select_test",
+    "ace/range_test",
+    "ace/range_list_test",
+    "ace/search_test",
+    "ace/selection_test",
+    "ace/token_iterator_test",
+    "ace/virtual_renderer_test"
+];
+
+var html = ["<a href='?'>all tests</a><br>"];
+for (var i in testNames) {
+    var href = testNames[i];
+    html.push("<a href='?", href, "'>", href.replace(/^ace\//, "") ,"</a><br>");
+}
+
+var nav = document.createElement("div");
+nav.innerHTML = html.join("");
+nav.style.cssText = "position:absolute;right:0;top:0"; 
+document.body.appendChild(nav);
+
+if (location.search)
+    testNames = location.search.substr(1).split(",")
+
+require(testNames, function() {
+    var tests = testNames.map(function(x) {
+        var module = require(x);
+        module.href = x;
+        return module;
+    });
+    
+    async.list(tests)
+        .expand(function(test) {
+            return AsyncTest.testcase(test)
+        }, AsyncTest.TestGenerator)
+        .run()
+        .each(function(test, next) {
+            if (test.index == 1 && test.context.href) {
+                var href = test.context.href;
+                var node = document.createElement("div");
+                node.innerHTML = "<a href='?" + href + "'>" + href.replace(/^ace\//, "") + "</a>";
+                log.appendChild(node);
+            }
+            var node = document.createElement("div");
+            node.className = test.passed ? "passed" : "failed";
+
+            var name = test.name
+            if (test.suiteName)
+                name = test.suiteName + ": " + test.name
+
+            var msg = "[" + test.count + "/" + test.index + "] " + name + " " + (test.passed ? "OK" : "FAIL")
+            if (!test.passed) {
+                if (test.err.stack)
+                    var err = test.err.stack
+                else
+                    var err = test.err
+
+                console.error(msg);
+                console.error(err);
+                msg += "<pre class='error'>" + err + "</pre>";
+            } else {
+                console.log(msg);
+            }
+
+            node.innerHTML = msg;
+            log.appendChild(node);
+
+            next()
+        })
+        .each(function(test) {
+            if (test.passed)
+                passed += 1
+            else
+                failed += 1
+        })
+        .end(function() {
+            log.innerHTML += [
+                "<div class='summary'>",
+                "<br>",
+                "Summary: <br>",
+                "<br>",
+                "Total number of tests: " + (passed + failed) + "<br>",
+                (passed ? "Passed tests: " + passed + "<br>" : ""),
+                (failed ? "Failed tests: " + failed + "<br>" : "")
+            ].join("")
+            console.log("Total number of tests: " + (passed + failed));
+            console.log("Passed tests: " + passed);
+            console.log("Failed tests: " + failed);
+        })
+});
+
+});

data/lib/gollum/frontend/public/gollum/livepreview/js/ace/lib/ace/test/assertions.js

@@ -0,0 +1,63 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Ajax.org Code Editor (ACE).
+ *
+ * The Initial Developer of the Original Code is
+ * Ajax.org B.V.
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *      Fabian Jakobs <fabian AT ajax DOT org>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+define(function(require, exports, module) {
+"use strict";
+
+var assert = require("assert");
+    
+assert.position = function(cursor, row, column) {
+    assert.equal(cursor.row, row);
+    assert.equal(cursor.column, column);
+};
+
+assert.range = function(range, startRow, startColumn, endRow, endColumn) {
+    assert.position(range.start, startRow, startColumn);
+    assert.position(range.end, endRow, endColumn);
+};
+
+assert.notOk = function(value) {
+    assert.equal(value, false);   
+};
+
+exports.jsonEquals = function(foundJson, expectedJson) {
+    assert.equal(JSON.stringify(foundJson), JSON.stringify(expectedJson));
+};
+
+module.exports = assert;
+
+});

data/lib/gollum/frontend/public/gollum/livepreview/js/ace/lib/ace/test/asyncjs/assert.js

@@ -0,0 +1,313 @@
+define(function(require, exports, module) {
+    
+// http://wiki.commonjs.org/wiki/Unit_Testing/1.0
+//
+// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!
+//
+// Originally from narwhal.js (http://narwhaljs.org)
+// Copyright (c) 2009 Thomas Robinson <280north.com>
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the 'Software'), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// UTILITY
+var oop = require("ace/lib/oop");
+var pSlice = Array.prototype.slice;
+
+// 1. The assert module provides functions that throw
+// AssertionError's when particular conditions are not met. The
+// assert module must conform to the following interface.
+
+var assert = exports;
+
+// 2. The AssertionError is defined in assert.
+// new assert.AssertionError({ message: message,
+//                             actual: actual,
+//                             expected: expected })
+
+assert.AssertionError = function AssertionError(options) {
+  this.name = 'AssertionError';
+  this.message = options.message;
+  this.actual = options.actual;
+  this.expected = options.expected;
+  this.operator = options.operator;
+  var stackStartFunction = options.stackStartFunction || fail;
+
+  if (Error.captureStackTrace) {
+    Error.captureStackTrace(this, stackStartFunction);
+  }
+};
+oop.inherits(assert.AssertionError, Error);
+
+toJSON = function(obj) {
+    if (typeof JSON !== "undefined")
+        return JSON.stringify(obj);
+    else
+        return obj.toString();
+}
+
+assert.AssertionError.prototype.toString = function() {
+  if (this.message) {
+    return [this.name + ':', this.message].join(' ');
+  } else {
+    return [this.name + ':',
+            toJSON(this.expected),
+            this.operator,
+            toJSON(this.actual)].join(' ');
+  }
+};
+
+// assert.AssertionError instanceof Error
+
+assert.AssertionError.__proto__ = Error.prototype;
+
+// At present only the three keys mentioned above are used and
+// understood by the spec. Implementations or sub modules can pass
+// other keys to the AssertionError's constructor - they will be
+// ignored.
+
+// 3. All of the following functions must throw an AssertionError
+// when a corresponding condition is not met, with a message that
+// may be undefined if not provided.  All assertion methods provide
+// both the actual and expected values to the assertion error for
+// display purposes.
+
+function fail(actual, expected, message, operator, stackStartFunction) {
+  throw new assert.AssertionError({
+    message: message,
+    actual: actual,
+    expected: expected,
+    operator: operator,
+    stackStartFunction: stackStartFunction
+  });
+}
+
+// EXTENSION! allows for well behaved errors defined elsewhere.
+assert.fail = fail;
+
+// 4. Pure assertion tests whether a value is truthy, as determined
+// by !!guard.
+// assert.ok(guard, message_opt);
+// This statement is equivalent to assert.equal(true, guard,
+// message_opt);. To test strictly for the value true, use
+// assert.strictEqual(true, guard, message_opt);.
+
+assert.ok = function ok(value, message) {
+  if (!!!value) fail(value, true, message, '==', assert.ok);
+};
+
+// 5. The equality assertion tests shallow, coercive equality with
+// ==.
+// assert.equal(actual, expected, message_opt);
+
+assert.equal = function equal(actual, expected, message) {
+  if (actual != expected) fail(actual, expected, message, '==', assert.equal);
+};
+
+// 6. The non-equality assertion tests for whether two objects are not equal
+// with != assert.notEqual(actual, expected, message_opt);
+
+assert.notEqual = function notEqual(actual, expected, message) {
+  if (actual == expected) {
+    fail(actual, expected, message, '!=', assert.notEqual);
+  }
+};
+
+// 7. The equivalence assertion tests a deep equality relation.
+// assert.deepEqual(actual, expected, message_opt);
+
+assert.deepEqual = function deepEqual(actual, expected, message) {
+  if (!_deepEqual(actual, expected)) {
+    fail(actual, expected, message, 'deepEqual', assert.deepEqual);
+  }
+};
+
+function _deepEqual(actual, expected) {
+  // 7.1. All identical values are equivalent, as determined by ===.
+  if (actual === expected) {
+    return true;
+
+  } else if (Buffer.isBuffer(actual) && Buffer.isBuffer(expected)) {
+    if (actual.length != expected.length) return false;
+
+    for (var i = 0; i < actual.length; i++) {
+      if (actual[i] !== expected[i]) return false;
+    }
+
+    return true;
+
+  // 7.2. If the expected value is a Date object, the actual value is
+  // equivalent if it is also a Date object that refers to the same time.
+  } else if (actual instanceof Date && expected instanceof Date) {
+    return actual.getTime() === expected.getTime();
+
+  // 7.3. Other pairs that do not both pass typeof value == 'object',
+  // equivalence is determined by ==.
+  } else if (typeof actual != 'object' && typeof expected != 'object') {
+    return actual == expected;
+
+  // 7.4. For all other Object pairs, including Array objects, equivalence is
+  // determined by having the same number of owned properties (as verified
+  // with Object.prototype.hasOwnProperty.call), the same set of keys
+  // (although not necessarily the same order), equivalent values for every
+  // corresponding key, and an identical 'prototype' property. Note: this
+  // accounts for both named and indexed properties on Arrays.
+  } else {
+    return objEquiv(actual, expected);
+  }
+}
+
+function isUndefinedOrNull(value) {
+  return value === null || value === undefined;
+}
+
+function isArguments(object) {
+  return Object.prototype.toString.call(object) == '[object Arguments]';
+}
+
+function objEquiv(a, b) {
+  if (isUndefinedOrNull(a) || isUndefinedOrNull(b))
+    return false;
+  // an identical 'prototype' property.
+  if (a.prototype !== b.prototype) return false;
+  //~~~I've managed to break Object.keys through screwy arguments passing.
+  //   Converting to array solves the problem.
+  if (isArguments(a)) {
+    if (!isArguments(b)) {
+      return false;
+    }
+    a = pSlice.call(a);
+    b = pSlice.call(b);
+    return _deepEqual(a, b);
+  }
+  try {
+    var ka = Object.keys(a),
+        kb = Object.keys(b),
+        key, i;
+  } catch (e) {//happens when one is a string literal and the other isn't
+    return false;
+  }
+  // having the same number of owned properties (keys incorporates
+  // hasOwnProperty)
+  if (ka.length != kb.length)
+    return false;
+  //the same set of keys (although not necessarily the same order),
+  ka.sort();
+  kb.sort();
+  //~~~cheap key test
+  for (i = ka.length - 1; i >= 0; i--) {
+    if (ka[i] != kb[i])
+      return false;
+  }
+  //equivalent values for every corresponding key, and
+  //~~~possibly expensive deep test
+  for (i = ka.length - 1; i >= 0; i--) {
+    key = ka[i];
+    if (!_deepEqual(a[key], b[key])) return false;
+  }
+  return true;
+}
+
+// 8. The non-equivalence assertion tests for any deep inequality.
+// assert.notDeepEqual(actual, expected, message_opt);
+
+assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
+  if (_deepEqual(actual, expected)) {
+    fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);
+  }
+};
+
+// 9. The strict equality assertion tests strict equality, as determined by ===.
+// assert.strictEqual(actual, expected, message_opt);
+
+assert.strictEqual = function strictEqual(actual, expected, message) {
+  if (actual !== expected) {
+    fail(actual, expected, message, '===', assert.strictEqual);
+  }
+};
+
+// 10. The strict non-equality assertion tests for strict inequality, as
+// determined by !==.  assert.notStrictEqual(actual, expected, message_opt);
+
+assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
+  if (actual === expected) {
+    fail(actual, expected, message, '!==', assert.notStrictEqual);
+  }
+};
+
+function expectedException(actual, expected) {
+  if (!actual || !expected) {
+    return false;
+  }
+
+  if (expected instanceof RegExp) {
+    return expected.test(actual);
+  } else if (actual instanceof expected) {
+    return true;
+  } else if (expected.call({}, actual) === true) {
+    return true;
+  }
+
+  return false;
+}
+
+function _throws(shouldThrow, block, expected, message) {
+  var actual;
+
+  if (typeof expected === 'string') {
+    message = expected;
+    expected = null;
+  }
+
+  try {
+    block();
+  } catch (e) {
+    actual = e;
+  }
+
+  message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +
+            (message ? ' ' + message : '.');
+
+  if (shouldThrow && !actual) {
+    fail('Missing expected exception' + message);
+  }
+
+  if (!shouldThrow && expectedException(actual, expected)) {
+    fail('Got unwanted exception' + message);
+  }
+
+  if ((shouldThrow && actual && expected &&
+      !expectedException(actual, expected)) || (!shouldThrow && actual)) {
+    throw actual;
+  }
+}
+
+// 11. Expected to throw an error:
+// assert.throws(block, Error_opt, message_opt);
+
+assert.throws = function(block, /*optional*/error, /*optional*/message) {
+  _throws.apply(this, [true].concat(pSlice.call(arguments)));
+};
+
+// EXTENSION! This is annoying to write outside this module.
+assert.doesNotThrow = function(block, /*optional*/error, /*optional*/message) {
+  _throws.apply(this, [false].concat(pSlice.call(arguments)));
+};
+
+assert.ifError = function(err) { if (err) {throw err;}};
+
+});