Datasets:

---

CM

/

codexglue_code2text_javascript

like 12

[ "function", "setDatabaseSecurity", "(", "name", ",", "cb", ")", "{", "// Get _security first", "getSecurity", "(", "name", ",", "function", "(", "err", ",", "d", ")", "{", "if", "(", "err", ")", "return", "cb", "(", "err", ")", "// Make name an admin", "if", "(", "d", ".", "admins", ".", "names", ".", "indexOf", "(", "name", ")", "===", "-", "1", ")", "{", "d", ".", "admins", ".", "names", ".", "push", "(", "name", ")", "}", "// Make name a reader", "if", "(", "d", ".", "readers", ".", "names", ".", "indexOf", "(", "name", ")", "===", "-", "1", ")", "{", "d", ".", "readers", ".", "names", ".", "push", "(", "name", ")", "}", "// Merge with _security template", "d", "=", "mergeSecurity", "(", "_security", ",", "d", ")", "// Apply changes", "setSecurity", "(", "name", ",", "d", ",", "function", "(", "err", ")", "{", "if", "(", "err", ")", "return", "cb", "(", "err", ")", "cb", "(", ")", "}", ")", "}", ")", "}" ]

[ "Sets", "the", "_security", "document", "of", "a", "database" ]

[ "function", "loginUser", "(", "name", ",", "pass", ",", "cb", ")", "{", "// Get the user", "var", "db", "=", "nano", "(", ")", ".", "use", "(", "user_dbname", ")", "db", ".", "get", "(", "user_namespace", "+", "':'", "+", "name", ",", "function", "(", "err", ",", "doc", ")", "{", "if", "(", "err", ")", "return", "cb", "(", "err", ")", "// Check pass", "var", "hash", "=", "crypto", ".", "createHash", "(", "'sha1'", ")", "hash", ".", "update", "(", "pass", ")", "hash", ".", "update", "(", "doc", ".", "salt", ")", "var", "password_sha", "=", "hash", ".", "digest", "(", "'hex'", ")", "if", "(", "doc", ".", "password_sha", "===", "password_sha", ")", "{", "return", "cb", "(", "null", ",", "doc", ")", "}", "cb", "(", "new", "Error", "(", "'Access denied.'", ")", ")", "}", ")", "}" ]

[ "Checks", "loginUser", "credenciales" ]

[ "function", "destroyDatabase", "(", "name", ",", "cb", ")", "{", "if", "(", "name", "===", "user_dbname", ")", "throw", "new", "Error", "(", "'We never ever delete that database.'", ")", "nano", "(", ")", ".", "db", ".", "destroy", "(", "name", ",", "function", "(", "err", ")", "{", "if", "(", "err", "&&", "err", ".", "status_code", "!==", "404", ")", "return", "cb", "(", "err", ")", "cb", "(", "null", ",", "err", "?", "false", ":", "true", ")", "}", ")", "}" ]

[ "Destroys", "a", "database" ]

[ "function", "destroyUser", "(", "name", ",", "pass", ",", "cb", ")", "{", "loginUser", "(", "name", ",", "pass", ",", "function", "(", "err", ",", "user", ")", "{", "if", "(", "err", ")", "return", "cb", "(", "err", ")", "nano", "(", ")", ".", "use", "(", "user_dbname", ")", ".", "destroy", "(", "user", ".", "_id", ",", "user", ".", "_rev", ",", "function", "(", "err", ",", "doc", ")", "{", "if", "(", "err", ")", "return", "cb", "(", "err", ")", "user", ".", "_id", "=", "doc", ".", "id", "user", ".", "_rev", "=", "doc", ".", "rev", "destroyDatabase", "(", "name", ",", "function", "(", "err", ")", "{", "if", "(", "err", ")", "return", "cb", "(", "err", ")", "cb", "(", "null", ",", "user", ")", "}", ")", "}", ")", "}", ")", "// var db = nano().use(user_dbname)", "// db.head(user_namespace+':'+name, function(err, b, h) {", "// if(err) return cb(err)", "// db.destroy(user_namespace+':'+name, JSON.parse(h.etag), function(err, doc) {", "// if(err) return cb(err)", "// destroyDatabase(name, function(err) {", "// if(err) return cb(err)", "// cb(null, doc)", "// })", "// })", "// })", "}" ]

[ "Destroys", "a", "user", "AND", "her", "database" ]

[ "function", "JsonArray", "(", "options", ")", "{", "if", "(", "!", "(", "this", "instanceof", "JsonArray", ")", ")", "{", "return", "new", "JsonArray", "(", "options", ")", "}", "this", ".", "options", "=", "Object", ".", "assign", "(", "{", "}", ",", "options", ",", "{", "objectMode", ":", "true", "}", ")", "this", ".", "count", "=", "0", "this", ".", "map", "=", "[", "'[\\n'", ",", "',\\n'", ",", "'\\n]\\n'", "]", "if", "(", "this", ".", "options", ".", "validJson", "===", "false", ")", "{", "this", ".", "map", "=", "[", "''", ",", "'\\n'", ",", "'\\n'", "]", "}", "if", "(", "this", ".", "options", ".", "stringify", ")", "{", "this", ".", "_transform", "=", "this", ".", "_stringify", "this", ".", "_flush", "=", "function", "(", "done", ")", "{", "this", ".", "push", "(", "this", ".", "map", "[", "2", "]", ")", "setTimeout", "(", "function", "(", ")", "{", "done", "(", ")", "}", ",", "2", ")", "}", "}", "else", "{", "this", ".", "_transform", "=", "this", ".", "_parse", "}", "Transform", ".", "call", "(", "this", ",", "_omit", "(", "this", ".", "options", ",", "[", "'error'", ",", "'validJson'", ",", "'stringify'", "]", ")", ")", "return", "this", "}" ]

[ "JSON", ".", "parse", "a", "line", "and", "push", "as", "object", "down", "the", "pipe", "." ]

[ "function", "pr_parse", "(", "options", ")", "{", "this", ".", "traverse", "(", "options", ",", "function", "(", "dir", ",", "item", ",", "out", ")", "{", "fs", ".", "readFile", "(", "dir", "+", "item", ",", "function", "(", "err", ",", "data", ")", "{", "console", ".", "log", "(", "'adding log '", "+", "dir", "+", "item", ")", ";", "if", "(", "err", ")", "{", "console", ".", "log", "(", "err", ")", ";", "console", ".", "log", "(", "data", ")", ";", "return", ";", "}", "var", "source", "=", "data", ".", "toString", "(", ")", ";", "var", "output", ";", "// if no match in the file", "if", "(", "!", "source", ".", "match", "(", "regex", ")", ")", "{", "return", ";", "}", "output", "=", "source", ".", "replace", "(", "regex", ",", "replacer", ")", ";", "fs", ".", "writeFile", "(", "out", "+", "item", ",", "output", ",", "function", "(", "err", ")", "{", "if", "(", "err", ")", "{", "console", ".", "log", "(", "err", ")", ";", "}", "else", "{", "console", ".", "log", "(", "out", "+", "item", "+", "' was saved!'", ")", ";", "}", "}", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Replace", "debuguy", "comments", "to", "predifined", "condole", "logs", "." ]

[ "function", "pr_autolog", "(", "options", ")", "{", "function", "espectRewrite", "(", "filepath", ",", "outpath", ",", "template", ")", "{", "var", "autologret", "=", "require", "(", "template", ")", ";", "autologret", "(", "filepath", ",", "outpath", ")", ";", "}", "function", "insertReturnLog", "(", "source", ",", "endLine", ")", "{", "var", "sourceRet", ";", "// Insert ending log at return statement.", "sourceRet", "=", "source", ".", "replace", "(", "/", "(\\s|;)return(\\s|;)", "/", "g", ",", "\"$1\"", "+", "endLine", "+", "\"return$2\"", ")", ";", "// Remove any ending log that added twice.", "while", "(", "sourceRet", ".", "indexOf", "(", "endLine", "+", "endLine", ")", "!==", "-", "1", ")", "{", "sourceRet", "=", "sourceRet", ".", "replace", "(", "endLine", "+", "endLine", ",", "endLine", ")", ";", "}", "return", "sourceRet", ";", "}", "function", "insertEnterAndLeaveLog", "(", "item", ",", "node", ",", "functionName", ")", "{", "var", "fnoutLine", "=", "'var DEBOUT=\"debuguy,\"'", "+", "' + (new Date()).getTime() + \",'", "+", "item", ".", "substring", "(", "0", ",", "item", ".", "lastIndexOf", "(", "'.'", ")", ")", "+", "'.'", "+", "functionName", "+", "'@'", "+", "node", ".", "loc", ".", "start", ".", "line", "+", "'\";console.log(DEBOUT + \",ENTER,\" + Date.now());'", ";", "var", "fnEndLine", "=", "'console.log(DEBOUT + \",LEAVE,\" + Date.now());'", ";", "var", "startLine", "=", "node", ".", "getSource", "(", ")", ".", "indexOf", "(", "'{'", ")", "+", "1", ";", "var", "endLine", "=", "node", ".", "getSource", "(", ")", ".", "lastIndexOf", "(", "'}'", ")", ";", "var", "source", "=", "node", ".", "getSource", "(", ")", ".", "substr", "(", "0", ",", "startLine", ")", "+", "fnoutLine", "+", "node", ".", "getSource", "(", ")", ".", "substr", "(", "startLine", ",", "endLine", "-", "startLine", ")", "+", "fnEndLine", "+", "node", ".", "getSource", "(", ")", ".", "substr", "(", "endLine", ")", ";", "source", "=", "insertReturnLog", "(", "source", ",", "fnEndLine", ")", ";", "return", "source", ";", "}", "function", "insertEnterLog", "(", "item", ",", "node", ",", "functionName", ")", "{", "var", "fnoutLine", "=", "'\\nconsole.log(\"debuguy,\"'", "+", "' + (new Date()).getTime() + \",'", "+", "item", ".", "substring", "(", "0", ",", "item", ".", "lastIndexOf", "(", "'.'", ")", ")", "+", "'.'", "+", "functionName", "+", "'@'", "+", "node", ".", "loc", ".", "start", ".", "line", "+", "'\");'", ";", "var", "startLine", "=", "node", ".", "getSource", "(", ")", ".", "indexOf", "(", "'{'", ")", "+", "1", ";", "var", "source", "=", "node", ".", "getSource", "(", ")", ".", "substr", "(", "0", ",", "startLine", ")", "+", "fnoutLine", "+", "node", ".", "getSource", "(", ")", ".", "substr", "(", "startLine", ")", ";", "return", "source", ";", "}", "this", ".", "traverse", "(", "options", ",", "function", "insertLog", "(", "dir", ",", "item", ",", "out", ")", "{", "if", "(", "options", ".", "xEspect", ")", "{", "var", "templatefile", "=", "__dirname", "+", "'/autolog.esp.js'", ";", "if", "(", "'string'", "===", "typeof", "options", ".", "xEspect", ")", "{", "templatefile", "=", "options", ".", "xEspect", ";", "}", "espectRewrite", "(", "dir", "+", "item", ",", "out", "+", "item", ",", "templatefile", ")", ";", "return", ";", "}", "fs", ".", "readFile", "(", "dir", "+", "item", ",", "function", "(", "err", ",", "data", ")", "{", "console", ".", "log", "(", "'adding log '", "+", "dir", "+", "item", ")", ";", "if", "(", "err", ")", "{", "console", ".", "log", "(", "err", ")", ";", "console", ".", "log", "(", "data", ")", ";", "return", ";", "}", "var", "text", "=", "data", ".", "toString", "(", ")", ";", "var", "output", ";", "try", "{", "output", "=", "esprimaTraversal", "(", "text", ",", "{", "loc", ":", "true", "}", ")", ".", "traverse", "(", "function", "(", "node", ")", "{", "if", "(", "node", ".", "type", "===", "'ArrowFunctionExpression'", "||", "node", ".", "type", "===", "'FunctionDeclaration'", "||", "node", ".", "type", "===", "'FunctionExpression'", ")", "{", "// Get the name of the function", "var", "functionName", "=", "'anonymous'", ";", "if", "(", "node", ".", "id", ")", "{", "functionName", "=", "node", ".", "id", ".", "name", ";", "}", "else", "if", "(", "node", ".", "parent", ")", "{", "switch", "(", "node", ".", "parent", ".", "type", ")", "{", "case", "'VariableDeclarator'", ":", "functionName", "=", "node", ".", "parent", ".", "id", ".", "name", ";", "break", ";", "case", "'Property'", ":", "functionName", "=", "node", ".", "parent", ".", "key", ".", "name", ";", "break", ";", "case", "'AssignmentExpression'", ":", "if", "(", "node", ".", "parent", ".", "left", ".", "type", "===", "'MemberExpression'", ")", "{", "functionName", "=", "node", ".", "parent", ".", "left", ".", "property", ".", "name", "||", "node", ".", "parent", ".", "left", ".", "property", ".", "value", ";", "}", "else", "if", "(", "node", ".", "parent", ".", "left", ".", "type", "===", "'Identifier'", ")", "{", "functionName", "=", "node", ".", "parent", ".", "left", ".", "name", ";", "}", "break", ";", "}", "}", "// Build the console log output", "var", "source", ";", "if", "(", "options", ".", "callStackGraph", ")", "{", "source", "=", "insertEnterAndLeaveLog", "(", "item", ",", "node", ",", "functionName", ")", ";", "}", "else", "{", "source", "=", "insertEnterLog", "(", "item", ",", "node", ",", "functionName", ")", ";", "}", "node", ".", "updateSource", "(", "source", ")", ";", "}", "}", ")", ";", "fs", ".", "writeFile", "(", "out", "+", "item", ",", "output", ",", "function", "(", "err", ")", "{", "if", "(", "err", ")", "{", "console", ".", "log", "(", "err", ")", ";", "}", "else", "{", "console", ".", "log", "(", "out", "+", "item", "+", "' was saved!'", ")", ";", "}", "}", ")", ";", "}", "catch", "(", "e", ")", "{", "console", ".", "log", "(", "'parsing failed: '", "+", "dir", "+", "item", ")", ";", "console", ".", "log", "(", "e", ")", ";", "}", "}", ")", ";", "}", ")", ";", "}" ]

[ "Automatically", "insert", "console", "logs", "in", "javascript", "functions", "." ]

[ "function", "(", "callback", ",", "timeInMs", ")", "{", "var", "timeout", "=", "makeTimeout", "(", "callback", ")", ";", "setTriggerTime", "(", "timeout", ",", "timeInMs", ")", ";", "s_timeoutsToInsert", ".", "push", "(", "timeout", ")", ";", "return", "timeout", ".", "id", ";", "}" ]

[ "Same", "as", "normal", "setTimeout" ]

[ "function", "(", "callback", ",", "timeInMs", ")", "{", "var", "timeout", "=", "makeTimeout", "(", "function", "(", ")", "{", "setTriggerTime", "(", "timeout", ",", "timeout", ".", "timeInMs", ")", ";", "s_timeoutsToInsert", ".", "push", "(", "timeout", ")", ";", "callback", "(", ")", ";", "}", ")", ";", "timeout", ".", "timeInMs", "=", "timeInMs", ";", "s_timeoutsToInsert", ".", "push", "(", "timeout", ")", ";", "return", "timeout", ".", "id", ";", "}" ]

[ "Same", "as", "normal", "setInterval" ]

[ "function", "(", "elapsedTimeInSeconds", ")", "{", "// insert any unscheduled timeouts", "if", "(", "s_timeoutsToInsert", ".", "length", ")", "{", "s_timeoutsToInsert", ".", "forEach", "(", "insertTimeout", ")", ";", "s_timeoutsToInsert", "=", "[", "]", ";", "}", "// Now remove any", "if", "(", "s_timeoutsToRemoveById", ".", "length", ")", "{", "s_timeoutsToRemoveById", ".", "forEach", "(", "removeTimeoutById", ")", ";", "s_timeoutsToRemoveById", "=", "[", "]", ";", "}", "s_clockInMs", "+=", "elapsedTimeInSeconds", "*", "1000", ";", "// process timeouts", "for", "(", "var", "ii", "=", "0", ";", "ii", "<", "s_timeouts", ".", "length", ";", "++", "ii", ")", "{", "var", "timeout", "=", "s_timeouts", "[", "ii", "]", ";", "if", "(", "s_clockInMs", "<", "timeout", ".", "timeToTrigger", ")", "{", "break", ";", "}", "timeout", ".", "callback", "(", ")", ";", "}", "// remove expired timeouts", "s_timeouts", ".", "splice", "(", "0", ",", "ii", ")", ";", "}" ]

[ "Processes", "the", "intervals", "and", "timeouts" ]

[ "function", "(", ")", "{", "const", "result", "=", "Array", ".", "prototype", ".", "pop", ".", "apply", "(", "arr", ")", "fn", "(", "'pop'", ",", "arr", ",", "{", "value", ":", "result", "}", ")", "return", "result", "}" ]

[ "Proxied", "array", "mutators", "methods" ]

[ "function", "process", "(", "data", ")", "{", "//", "// Apply previous post processing.", "//", "data", "=", "Pagelet", ".", "prototype", ".", "postprocess", ".", "call", "(", "this", ",", "data", ")", ";", "data", ".", "stats", "=", "{", "outofdate", ":", "0", ",", "uptodate", ":", "0", ",", "pinned", ":", "0", "}", ";", "data", ".", "shrinkwrap", ".", "forEach", "(", "function", "shrinkwrap", "(", "module", ")", "{", "if", "(", "module", ".", "pinned", ")", "data", ".", "stats", ".", "pinned", "++", ";", "if", "(", "module", ".", "uptodate", ")", "data", ".", "stats", ".", "uptodate", "++", ";", "else", "data", ".", "stats", ".", "outofdate", "++", ";", "}", ")", ";", "return", "data", ";", "}" ]

[ "Remove", "JS", "dependency", ".", "Final", "post", "processing", "step", "on", "the", "data", "." ]

[ "function", "Session", "(", "identity", ",", "connection", ",", "options", ")", "{", "if", "(", "!", "(", "this", "instanceof", "Session", ")", ")", "{", "return", "new", "Session", "(", "identity", ",", "connection", ",", "options", ")", ";", "}", "assert", "(", "identity", "instanceof", "Identity", ",", "'Invalid identity supplied'", ")", ";", "if", "(", "!", "(", "connection", "instanceof", "Connection", ")", ")", "{", "options", "=", "connection", "||", "{", "}", ";", "options", ".", "passive", "=", "true", ";", "}", "this", ".", "options", "=", "merge", "(", "Object", ".", "create", "(", "Session", ".", "DEFAULTS", ")", ",", "options", ")", ";", "this", ".", "client", "=", "new", "Client", "(", "identity", ")", ";", "this", ".", "_identity", "=", "identity", ";", "if", "(", "!", "this", ".", "options", ".", "passive", ")", "{", "this", ".", "_connection", "=", "connection", ";", "this", ".", "_connection", ".", "open", "(", "this", ".", "_onConnect", ".", "bind", "(", "this", ")", ")", ";", "}", "else", "{", "this", ".", "_onConnect", "(", ")", ";", "}", "if", "(", "this", ".", "options", ".", "subscribe", ")", "{", "this", ".", "client", ".", "on", "(", "'message'", ",", "this", ".", "_onMessage", ".", "bind", "(", "this", ")", ")", ".", "subscribe", "(", ")", ";", "}", "}" ]

[ "Creates", "a", "sandbox", "for", "Muttr", "apps", "by", "the", "given", "identity" ]

[ "function", "(", ")", "{", "var", "self", "=", "this", ",", "logs", "=", "self", ".", "_filterLogs", "(", ")", ",", "all", "=", "logs", ".", "all", ",", "keys", "=", "logs", ".", "keys", ",", "time", "=", "munit", ".", "_relativeTime", "(", "self", ".", "end", "-", "self", ".", "start", ")", ";", "// Root module", "if", "(", "!", "self", ".", "callback", ")", "{", "munit", ".", "color", ".", "green", "(", "\"=== All submodules of \"", "+", "self", ".", "nsPath", "+", "\" have finished ===\"", ")", ";", "return", ";", "}", "// Content", "munit", ".", "color", ".", "blue", "(", "\"\\n\"", "+", "self", ".", "nsPath", ")", ";", "munit", ".", "each", "(", "self", ".", "tests", ",", "function", "(", "test", ")", "{", "if", "(", "keys", "[", "test", ".", "name", "]", "&&", "keys", "[", "test", ".", "name", "]", ".", "length", ")", "{", "keys", "[", "test", ".", "name", "]", ".", "forEach", "(", "function", "(", "args", ")", "{", "munit", ".", "log", ".", "apply", "(", "munit", ",", "args", ")", ";", "}", ")", ";", "}", "if", "(", "test", ".", "error", ")", "{", "munit", ".", "color", ".", "red", "(", "test", ".", "ns", ")", ";", "munit", ".", "log", "(", "\"\\n\"", ",", "test", ".", "error", ".", "stack", ")", ";", "munit", ".", "log", "(", "\"\\n\"", ")", ";", "}", "else", "if", "(", "test", ".", "skip", ")", "{", "munit", ".", "color", ".", "gray", "(", "\"[skipped] \"", "+", "test", ".", "ns", ")", ";", "munit", ".", "color", ".", "gray", "(", "\"\\treason: \"", "+", "test", ".", "skip", ")", ";", "}", "else", "{", "munit", ".", "color", ".", "green", "(", "test", ".", "ns", ")", ";", "}", "}", ")", ";", "// Logs made after the final test", "if", "(", "all", ".", "length", ")", "{", "all", ".", "forEach", "(", "function", "(", "args", ")", "{", "munit", ".", "log", ".", "apply", "(", "munit", ",", "args", ")", ";", "}", ")", ";", "}", "// Final Output", "if", "(", "self", ".", "failed", ")", "{", "munit", ".", "color", ".", "red", "(", "\"\\n-- \"", "+", "self", ".", "failed", "+", "\" tests failed on \"", "+", "self", ".", "nsPath", "+", "\" (\"", "+", "time", "+", "\") --\\n\"", ")", ";", "}", "else", "{", "munit", ".", "color", ".", "green", "(", "\"\\n-- All \"", "+", "self", ".", "passed", "+", "\" tests passed on \"", "+", "self", ".", "nsPath", "+", "\" (\"", "+", "time", "+", "\") --\\n\"", ")", ";", "}", "}" ]

[ "Prints", "module", "results", "to", "cli" ]

[ "function", "(", ")", "{", "var", "self", "=", "this", ",", "all", "=", "[", "]", ",", "keys", "=", "{", "}", ",", "current", "=", "null", ";", "self", ".", "_logs", ".", "reverse", "(", ")", ".", "forEach", "(", "function", "(", "log", ")", "{", "if", "(", "log", "instanceof", "AssertResult", ")", "{", "current", "=", "log", ".", "name", ";", "return", ";", "}", "var", "name", "=", "log", "[", "0", "]", ";", "if", "(", "log", ".", "length", ">", "1", "&&", "munit", ".", "isString", "(", "name", ")", "&&", "self", ".", "tests", "[", "name", "]", ")", "{", "if", "(", "!", "keys", "[", "name", "]", ")", "{", "keys", "[", "name", "]", "=", "[", "]", ";", "}", "keys", "[", "name", "]", ".", "unshift", "(", "log", ".", "slice", "(", "1", ")", ")", ";", "}", "else", "if", "(", "current", "&&", "self", ".", "tests", "[", "current", "]", ")", "{", "if", "(", "!", "keys", "[", "current", "]", ")", "{", "keys", "[", "current", "]", "=", "[", "]", ";", "}", "keys", "[", "current", "]", ".", "unshift", "(", "log", ")", ";", "}", "else", "{", "all", ".", "unshift", "(", "log", ")", ";", "}", "}", ")", ";", "return", "{", "all", ":", "all", ",", "keys", ":", "keys", "}", ";", "}" ]

[ "Generates", "log", "arrays", "based", "on", "current", "test", "keys" ]

[ "function", "(", "name", ",", "error", ",", "skip", ")", "{", "var", "self", "=", "this", ",", "now", "=", "Date", ".", "now", "(", ")", ",", "last", "=", "!", "self", ".", "isAsync", "&&", "self", ".", "_lastTest", "?", "self", ".", "_lastTest", ":", "self", ".", "start", ",", "result", "=", "new", "AssertResult", "(", "name", ",", "self", ".", "nsPath", ",", "now", "-", "last", ",", "error", ",", "skip", ")", ";", "self", ".", "tests", "[", "name", "]", "=", "result", ";", "self", ".", "list", ".", "push", "(", "result", ")", ";", "self", ".", "_logs", ".", "push", "(", "result", ")", ";", "self", ".", "_lastTest", "=", "now", ";", "}" ]

[ "Returns", "a", "configured", "result", "object" ]

[ "function", "(", "actual", ",", "expected", ",", "prefix", ")", "{", "var", "self", "=", "this", ",", "keys", ",", "expectedKeys", ";", "prefix", "=", "prefix", "||", "''", ";", "if", "(", "munit", ".", "isArray", "(", "actual", ")", "&&", "munit", ".", "isArray", "(", "expected", ")", ")", "{", "if", "(", "actual", ".", "length", "!==", "expected", ".", "length", ")", "{", "throw", "\"\\nActual: actual\"", "+", "prefix", "+", "\".length = \"", "+", "actual", ".", "length", "+", "\"\\nExpected: expected\"", "+", "prefix", "+", "\".length = \"", "+", "expected", ".", "length", ";", "}", "munit", ".", "each", "(", "actual", ",", "function", "(", "item", ",", "i", ")", "{", "if", "(", "munit", ".", "isArray", "(", "item", ")", "||", "munit", ".", "isObject", "(", "item", ")", ")", "{", "self", ".", "_objectMatch", "(", "item", ",", "expected", "[", "i", "]", ",", "prefix", "+", "\"[\"", "+", "i", "+", "\"]\"", ")", ";", "}", "else", "if", "(", "item", "!==", "expected", "[", "i", "]", ")", "{", "throw", "\"\\nActual: actual\"", "+", "prefix", "+", "\"[\"", "+", "i", "+", "\"] = \"", "+", "item", "+", "\"\\nExpected: expected\"", "+", "prefix", "+", "\"[\"", "+", "i", "+", "\"] = \"", "+", "expected", "[", "i", "]", ";", "}", "}", ")", ";", "}", "else", "if", "(", "munit", ".", "isObject", "(", "actual", ")", "&&", "munit", ".", "isObject", "(", "expected", ")", ")", "{", "keys", "=", "Object", ".", "keys", "(", "actual", ")", ";", "expectedKeys", "=", "Object", ".", "keys", "(", "expected", ")", ";", "if", "(", "keys", ".", "length", "!==", "expectedKeys", ".", "length", ")", "{", "throw", "\"\\nActual: actual\"", "+", "prefix", "+", "\".length = \"", "+", "keys", ".", "length", "+", "\"\\nExpected: expected\"", "+", "prefix", "+", "\".length = \"", "+", "expectedKeys", ".", "length", ";", "}", "munit", ".", "each", "(", "keys", ",", "function", "(", "key", ")", "{", "var", "item", "=", "actual", "[", "key", "]", ";", "if", "(", "munit", ".", "isArray", "(", "item", ")", "||", "munit", ".", "isObject", "(", "item", ")", ")", "{", "self", ".", "_objectMatch", "(", "item", ",", "expected", "[", "key", "]", ",", "prefix", "+", "\"[\"", "+", "key", "+", "\"]\"", ")", ";", "}", "else", "if", "(", "item", "!==", "expected", "[", "key", "]", ")", "{", "throw", "\"\\nActual: actual\"", "+", "prefix", "+", "\"[\"", "+", "key", "+", "\"] = \"", "+", "item", "+", "\"\\nExpected: expected\"", "+", "prefix", "+", "\"[\"", "+", "key", "+", "\"] = \"", "+", "expected", "[", "key", "]", ";", "}", "}", ")", ";", "}", "else", "if", "(", "actual", "!==", "expected", ")", "{", "throw", "\"\\nActual: actual\"", "+", "prefix", "+", "\" = \"", "+", "actual", "+", "\"\\nExpected: expected\"", "+", "prefix", "+", "\" = \"", "+", "expected", ";", "}", "}" ]

[ "Key", "matching", "for", "object", "match" ]

[ "function", "(", "e", ",", "match", ")", "{", "var", "result", "=", "{", "passed", ":", "false", "}", ",", "message", "=", "''", ";", "// Get a string for matching on the error", "if", "(", "munit", ".", "isError", "(", "e", ")", ")", "{", "message", "=", "e", ".", "message", ";", "}", "else", "if", "(", "munit", ".", "isString", "(", "e", ")", ")", "{", "message", "=", "e", ";", "}", "// No match required", "if", "(", "match", "===", "undefined", ")", "{", "result", ".", "passed", "=", "true", ";", "}", "// Non Error/String error object, string matching required", "else", "if", "(", "!", "munit", ".", "isError", "(", "e", ")", "&&", "!", "munit", ".", "isString", "(", "e", ")", ")", "{", "if", "(", "e", "===", "match", ")", "{", "result", ".", "passed", "=", "true", ";", "}", "else", "{", "result", ".", "extra", "=", "\"Match object '\"", "+", "match", "+", "\"' does not match error '\"", "+", "e", "+", "\"'\"", ";", "}", "}", "// Function error class matching", "else", "if", "(", "munit", ".", "isFunction", "(", "match", ")", ")", "{", "if", "(", "e", "instanceof", "match", ")", "{", "result", ".", "passed", "=", "true", ";", "}", "else", "{", "result", ".", "extra", "=", "\"Error does not match class '\"", "+", "match", ".", "name", "+", "\"'\"", ";", "}", "}", "// Regex checking on the error message", "else", "if", "(", "munit", ".", "isRegExp", "(", "match", ")", ")", "{", "if", "(", "match", ".", "exec", "(", "message", ")", ")", "{", "result", ".", "passed", "=", "true", ";", "}", "else", "{", "result", ".", "extra", "=", "\"Regex (\"", "+", "match", "+", "\") could not find match on:\\n\"", "+", "message", ";", "}", "}", "// String matching on the error message", "else", "if", "(", "munit", ".", "isString", "(", "match", ")", ")", "{", "if", "(", "match", "===", "message", ")", "{", "result", ".", "passed", "=", "true", ";", "}", "else", "{", "result", ".", "extra", "=", "\"Error message doesn't match:\\nActual: \"", "+", "message", "+", "\"\\nExpected: \"", "+", "match", ";", "}", "}", "// Unkown error type passed", "else", "{", "result", ".", "extra", "=", "\"Unknown error match type '\"", "+", "match", "+", "\"'\"", ";", "}", "return", "result", ";", "}" ]

[ "Utility", "for", "error", "object", "matching" ]

[ "function", "(", "name", ",", "startFunc", ",", "error", ")", "{", "var", "self", "=", "this", ",", "result", ";", "// Assign proper error", "if", "(", "!", "error", ")", "{", "error", "=", "new", "munit", ".", "AssertionError", "(", "\"'\"", "+", "name", "+", "\"' test failed\"", ",", "startFunc", ")", ";", "}", "else", "if", "(", "!", "(", "error", "instanceof", "Error", ")", ")", "{", "error", "=", "new", "munit", ".", "AssertionError", "(", "error", ",", "startFunc", ")", ";", "}", "// Increment error count and jump", "self", ".", "_addResult", "(", "name", ",", "error", ")", ";", "self", ".", "failed", "++", ";", "self", ".", "count", "++", ";", "munit", ".", "failed", "++", ";", "// Kill on test failure", "if", "(", "self", ".", "options", ".", "stopOnFail", ")", "{", "self", ".", "_flush", "(", ")", ";", "munit", ".", "exit", "(", "1", ")", ";", "}", "}" ]

[ "Failed", "test", "storage" ]

[ "function", "(", "name", ")", "{", "var", "self", "=", "this", ";", "self", ".", "_addResult", "(", "name", ")", ";", "self", ".", "passed", "++", ";", "self", ".", "count", "++", ";", "munit", ".", "passed", "++", ";", "}" ]

[ "Passed", "test", "storage" ]

[ "function", "(", "required", ",", "startFunc", ")", "{", "var", "self", "=", "this", ";", "if", "(", "required", "!==", "self", ".", "state", ")", "{", "self", ".", "_stateError", "(", "startFunc", "||", "self", ".", "requireState", ")", ";", "}", "return", "self", ";", "}" ]

[ "Throws", "an", "error", "if", "module", "isn", "t", "in", "the", "required", "state" ]

[ "function", "(", "time", ",", "callback", ")", "{", "var", "self", "=", "this", ",", "timeid", ";", "// Can only delay an active module", "self", ".", "requireState", "(", "munit", ".", "ASSERT_STATE_ACTIVE", ",", "self", ".", "delay", ")", ";", "// Time parameter is required", "if", "(", "!", "munit", ".", "isNumber", "(", "time", ")", ")", "{", "throw", "new", "munit", ".", "AssertionError", "(", "\"Time parameter not passed to assert.delay\"", ",", "self", ".", "delay", ")", ";", "}", "// Module has yet to complete the callback cycle,", "// Start async extension now", "if", "(", "!", "self", ".", "isAsync", ")", "{", "self", ".", "isAsync", "=", "true", ";", "self", ".", "options", ".", "timeout", "=", "time", ";", "self", ".", "_timerStart", "=", "Date", ".", "now", "(", ")", ";", "self", ".", "_timeid", "=", "timeid", "=", "setTimeout", "(", "function", "(", ")", "{", "if", "(", "munit", ".", "isFunction", "(", "callback", ")", ")", "{", "callback", "(", "self", ")", ";", "}", "if", "(", "timeid", "===", "self", ".", "_timeid", "&&", "self", ".", "state", "<", "munit", ".", "ASSERT_STATE_TEARDOWN", ")", "{", "self", ".", "close", "(", ")", ";", "}", "}", ",", "time", ")", ";", "}", "// Only extend current timeout if it is less then requested delay", "else", "if", "(", "(", "self", ".", "_timerStart", "+", "self", ".", "options", ".", "timeout", ")", "<", "(", "Date", ".", "now", "(", ")", "+", "time", ")", ")", "{", "if", "(", "self", ".", "_timeid", ")", "{", "self", ".", "_timeid", "=", "clearTimeout", "(", "self", ".", "_timeid", ")", ";", "}", "self", ".", "isAsync", "=", "true", ";", "self", ".", "_timerStart", "=", "Date", ".", "now", "(", ")", ";", "self", ".", "_timeid", "=", "timeid", "=", "setTimeout", "(", "function", "(", ")", "{", "if", "(", "munit", ".", "isFunction", "(", "callback", ")", ")", "{", "callback", "(", "self", ")", ";", "}", "if", "(", "timeid", "===", "self", ".", "_timeid", "&&", "self", ".", "state", "<", "munit", ".", "ASSERT_STATE_TEARDOWN", ")", "{", "self", ".", "close", "(", ")", ";", "}", "}", ",", "time", ")", ";", "}", "// Force block any delay that does not extend longer than current timeout", "else", "{", "throw", "new", "munit", ".", "AssertionError", "(", "\"delay time doesn't extend further than the current timeout\"", ",", "self", ".", "delay", ")", ";", "}", "}" ]

[ "Makes", "module", "asynchronous" ]

[ "function", "(", "name", ",", "test", ",", "startFunc", ",", "extra", ")", "{", "var", "self", "=", "this", ";", "// Require an active state for tests", "self", ".", "requireState", "(", "munit", ".", "ASSERT_STATE_ACTIVE", ",", "startFunc", "||", "self", ".", "ok", ")", ";", "// Prevent non empty string names", "if", "(", "!", "munit", ".", "isString", "(", "name", ")", "||", "!", "name", ".", "length", ")", "{", "throw", "new", "munit", ".", "AssertionError", "(", "\"Name not found for test on '\"", "+", "self", ".", "nsPath", "+", "\"'\"", ",", "startFunc", "||", "self", ".", "ok", ")", ";", "}", "// Prevent duplicate tests", "else", "if", "(", "self", ".", "tests", "[", "name", "]", ")", "{", "throw", "new", "munit", ".", "AssertionError", "(", "\"Duplicate Test '\"", "+", "name", "+", "\"' on '\"", "+", "self", ".", "nsPath", "+", "\"'\"", ",", "startFunc", "||", "self", ".", "ok", ")", ";", "}", "// Increment test count and mark it", "self", "[", "!", "!", "(", "test", ")", "?", "'_pass'", ":", "'_fail'", "]", "(", "name", ",", "startFunc", "||", "self", ".", "ok", ",", "extra", ")", ";", "// Reached expected number of tests, close off", "if", "(", "self", ".", "options", ".", "expect", ">", "0", "&&", "self", ".", "count", ">=", "self", ".", "options", ".", "expect", ")", "{", "self", ".", "close", "(", ")", ";", "}", "return", "self", ";", "}" ]

[ "Basic", "boolean", "test" ]

[ "function", "(", "name", ",", "startFunc", ",", "extra", ")", "{", "if", "(", "extra", "===", "undefined", "&&", "!", "munit", ".", "isFunction", "(", "startFunc", ")", ")", "{", "extra", "=", "startFunc", ";", "startFunc", "=", "undefined", ";", "}", "if", "(", "munit", ".", "isError", "(", "extra", ")", ")", "{", "extra", "=", "extra", ".", "message", ";", "}", "return", "this", ".", "ok", "(", "name", ",", "false", ",", "startFunc", "||", "this", ".", "fail", ",", "extra", ")", ";", "}" ]

[ "Shortcut", "for", "explicit", "failures" ]

[ "function", "(", "name", ",", "value", ",", "match", ")", "{", "var", "self", "=", "this", ",", "result", "=", "munit", ".", "isError", "(", "value", ")", "?", "self", ".", "_errorMatch", "(", "value", ",", "match", ")", ":", "{", "passed", ":", "false", ",", "extra", ":", "\"Value is not an Error '\"", "+", "value", "+", "\"'\"", "}", ";", "return", "self", ".", "ok", "(", "name", ",", "result", ".", "passed", ",", "self", ".", "isError", ",", "result", ".", "extra", ")", ";", "}" ]

[ "Testing", "value", "for", "Error", "object" ]

[ "function", "(", "name", ",", "actual", ",", "expected", ")", "{", "return", "this", ".", "ok", "(", "name", ",", "actual", "!==", "expected", ",", "this", ".", "notEqual", ",", "\"\\nValues should not match\\nActual:\"", "+", "actual", "+", "\"\\nExpected:\"", "+", "expected", ")", ";", "}" ]

[ "Strict", "un", "-", "comparison" ]

[ "function", "(", "name", ",", "upper", ",", "lower", ")", "{", "return", "this", ".", "ok", "(", "name", ",", "upper", ">", "lower", ",", "this", ".", "greaterThan", ",", "\"\\nUpper Value '\"", "+", "upper", "+", "\"' is not greater than lower value '\"", "+", "lower", "+", "\"'\"", ")", ";", "}" ]

[ "Greater", "than", "comparison" ]

[ "function", "(", "name", ",", "lower", ",", "upper", ")", "{", "return", "this", ".", "ok", "(", "name", ",", "lower", "<", "upper", ",", "this", ".", "lessThan", ",", "\"\\nLower Value '\"", "+", "lower", "+", "\"' is not less than upper value '\"", "+", "upper", "+", "\"'\"", ")", ";", "}" ]

[ "Less", "than", "comparison" ]

[ "function", "(", "name", ",", "value", ",", "lower", ",", "upper", ")", "{", "return", "this", ".", "ok", "(", "name", ",", "value", ">", "lower", "&&", "value", "<", "upper", ",", "this", ".", "between", ",", "\"\\nValue '\"", "+", "value", "+", "\"' is not inbetween '\"", "+", "lower", "+", "\"' and '\"", "+", "upper", "+", "\"'\"", ")", ";", "}" ]

[ "Value", "between", "boundary" ]

[ "function", "(", "name", ",", "actual", ",", "expected", ")", "{", "var", "self", "=", "this", ",", "passed", "=", "true", ",", "extra", "=", "''", ";", "try", "{", "self", ".", "_objectMatch", "(", "actual", ",", "expected", ")", ";", "}", "catch", "(", "e", ")", "{", "passed", "=", "false", ";", "extra", "=", "e", ";", "if", "(", "!", "munit", ".", "isString", "(", "e", ")", ")", "{", "throw", "e", ";", "}", "}", "return", "self", ".", "ok", "(", "name", ",", "passed", ",", "self", ".", "deepEqual", ",", "extra", ")", ";", "}" ]

[ "Deep", "equal", "handle" ]

[ "function", "(", "name", ",", "actual", ",", "expected", ")", "{", "var", "self", "=", "this", ",", "passed", "=", "true", ";", "try", "{", "self", ".", "_objectMatch", "(", "actual", ",", "expected", ")", ";", "passed", "=", "false", ";", "}", "catch", "(", "e", ")", "{", "}", "return", "self", ".", "ok", "(", "name", ",", "passed", ",", "self", ".", "notDeepEqual", ",", "'Objects are not supposed to match'", ")", ";", "}" ]

[ "Not", "deep", "equal", "handle" ]

[ "function", "(", "name", ",", "match", ",", "block", ")", "{", "var", "self", "=", "this", ",", "result", "=", "{", "passed", ":", "false", ",", "extra", ":", "'Block did not throw error'", "}", ";", "// Variable arguments", "if", "(", "block", "===", "undefined", "&&", "munit", ".", "isFunction", "(", "match", ")", ")", "{", "block", "=", "match", ";", "match", "=", "undefined", ";", "}", "// Fail quick if block isn't a function", "if", "(", "!", "munit", ".", "isFunction", "(", "block", ")", ")", "{", "throw", "new", "Error", "(", "\"Block passed to assert.throws is not a function: '\"", "+", "block", "+", "\"'\"", ")", ";", "}", "// test for throwing", "try", "{", "block", "(", ")", ";", "}", "catch", "(", "e", ")", "{", "result", "=", "self", ".", "_errorMatch", "(", "e", ",", "match", ")", ";", "}", "return", "self", ".", "ok", "(", "name", ",", "result", ".", "passed", ",", "self", ".", "throws", ",", "result", ".", "extra", ")", ";", "}" ]

[ "Run", "internal", "throw", "handle" ]

[ "function", "(", "name", ",", "block", ")", "{", "var", "self", "=", "this", ",", "passed", "=", "true", ";", "try", "{", "block", "(", ")", ";", "}", "catch", "(", "e", ")", "{", "passed", "=", "false", ";", "}", "return", "self", ".", "ok", "(", "name", ",", "passed", ",", "self", ".", "doesNotThrow", ",", "'Block does throw error'", ")", ";", "}" ]

[ "Run", "internal", "notThrow", "handle" ]

[ "function", "(", "name", ",", "actual", ",", "expected", ")", "{", "var", "self", "=", "this", ",", "passed", "=", "false", ",", "message", "=", "''", ";", "if", "(", "munit", ".", "isDate", "(", "actual", ")", "&&", "munit", ".", "isDate", "(", "expected", ")", ")", "{", "passed", "=", "actual", ".", "getTime", "(", ")", "===", "expected", ".", "getTime", "(", ")", ";", "message", "=", "\"Date '\"", "+", "actual", "+", "\"' does not match '\"", "+", "expected", "+", "\"'\"", ";", "}", "else", "{", "message", "=", "munit", ".", "isDate", "(", "actual", ")", "?", "\"Expected value is not a Date object '\"", "+", "expected", "+", "\"'\"", ":", "\"Actual value is not a Date object '\"", "+", "actual", "+", "\"'\"", ";", "}", "return", "self", ".", "ok", "(", "name", ",", "passed", ",", "self", ".", "dateEquals", ",", "message", ")", ";", "}" ]

[ "Matching", "date", "objects" ]

[ "function", "(", "name", ",", "actual", ",", "lower", ")", "{", "var", "self", "=", "this", ",", "passed", "=", "false", ",", "message", "=", "''", ";", "if", "(", "munit", ".", "isDate", "(", "actual", ")", "&&", "munit", ".", "isDate", "(", "lower", ")", ")", "{", "passed", "=", "actual", ".", "getTime", "(", ")", ">", "lower", ".", "getTime", "(", ")", ";", "message", "=", "\"Date '\"", "+", "actual", "+", "\"' is not after '\"", "+", "lower", "+", "\"'\"", ";", "}", "else", "{", "message", "=", "munit", ".", "isDate", "(", "actual", ")", "?", "\"Lower value is not a Date object '\"", "+", "lower", "+", "\"'\"", ":", "\"Actual value is not a Date object '\"", "+", "actual", "+", "\"'\"", ";", "}", "return", "self", ".", "ok", "(", "name", ",", "passed", ",", "self", ".", "dateAfter", ",", "message", ")", ";", "}" ]

[ "Tests", "date", "is", "after", "another", "date" ]

[ "function", "(", "name", ",", "actual", ",", "upper", ")", "{", "var", "self", "=", "this", ",", "passed", "=", "false", ",", "message", "=", "''", ";", "if", "(", "munit", ".", "isDate", "(", "actual", ")", "&&", "munit", ".", "isDate", "(", "upper", ")", ")", "{", "passed", "=", "actual", ".", "getTime", "(", ")", "<", "upper", ".", "getTime", "(", ")", ";", "message", "=", "\"Date '\"", "+", "actual", "+", "\"' is not before '\"", "+", "upper", "+", "\"'\"", ";", "}", "else", "{", "message", "=", "munit", ".", "isDate", "(", "actual", ")", "?", "\"Upper value is not a Date object '\"", "+", "upper", "+", "\"'\"", ":", "\"Actual value is not a Date object '\"", "+", "actual", "+", "\"'\"", ";", "}", "return", "self", ".", "ok", "(", "name", ",", "passed", ",", "self", ".", "dateBefore", ",", "message", ")", ";", "}" ]

[ "Tests", "date", "is", "before", "another", "date" ]

[ "function", "(", "name", ",", "actual", ",", "lower", ",", "upper", ")", "{", "var", "self", "=", "this", ",", "passed", "=", "false", ",", "message", "=", "''", ";", "if", "(", "munit", ".", "isDate", "(", "actual", ")", "&&", "munit", ".", "isDate", "(", "lower", ")", "&&", "munit", ".", "isDate", "(", "upper", ")", ")", "{", "passed", "=", "actual", ".", "getTime", "(", ")", ">", "lower", ".", "getTime", "(", ")", "&&", "actual", ".", "getTime", "(", ")", "<", "upper", ".", "getTime", "(", ")", ";", "message", "=", "\"Date '\"", "+", "actual", "+", "\"' is not between '\"", "+", "lower", "+", "\"' and '\"", "+", "upper", "+", "\"'\"", ";", "}", "else", "{", "message", "=", "!", "munit", ".", "isDate", "(", "actual", ")", "?", "\"Actual value is not a Date object '\"", "+", "actual", "+", "\"'\"", ":", "!", "munit", ".", "isDate", "(", "lower", ")", "?", "\"Lower value is not a Date object '\"", "+", "lower", "+", "\"'\"", ":", "\"Upper value is not a Date object '\"", "+", "upper", "+", "\"'\"", ";", "}", "return", "self", ".", "ok", "(", "name", ",", "passed", ",", "self", ".", "dateBetween", ",", "message", ")", ";", "}" ]

[ "Tests", "date", "is", "between", "two", "other", "dates" ]

[ "function", "(", "name", ",", "handle", ")", "{", "var", "self", "=", "this", ";", "// Can only add custom assertions when module hasn't been triggered yet", "self", ".", "requireMaxState", "(", "munit", ".", "ASSERT_STATE_DEFAULT", ",", "self", ".", "custom", ")", ";", "// Block on reserved words", "if", "(", "munit", ".", "customReserved", ".", "indexOf", "(", "name", ")", ">", "-", "1", ")", "{", "throw", "new", "Error", "(", "\"'\"", "+", "name", "+", "\"' is a reserved name and cannot be added as a custom assertion test\"", ")", ";", "}", "// Attach handle to assertion module and all submodules", "self", "[", "name", "]", "=", "handle", ";", "munit", ".", "each", "(", "self", ".", "ns", ",", "function", "(", "mod", ")", "{", "mod", ".", "custom", "(", "name", ",", "handle", ")", ";", "}", ")", ";", "return", "self", ";", "}" ]

[ "Custom", "test", "additions" ]

[ "function", "(", ")", "{", "var", "self", "=", "this", ";", "// Can only start a module that hasn't been started yet", "self", ".", "requireState", "(", "munit", ".", "ASSERT_STATE_DEFAULT", ",", "self", ".", "trigger", ")", ";", "// Setup and trigger module", "self", ".", "start", "=", "self", ".", "end", "=", "Date", ".", "now", "(", ")", ";", "// Parent namespaces sometimes don't have tests", "// Also close out paths that aren't part of the focus", "if", "(", "!", "self", ".", "callback", "||", "!", "munit", ".", "render", ".", "focusPath", "(", "self", ".", "nsPath", ")", ")", "{", "self", ".", "state", "=", "munit", ".", "ASSERT_STATE_CLOSED", ";", "return", "self", ".", "_close", "(", ")", ";", "}", "// Trigger test setup first", "self", ".", "_setup", "(", "function", "(", "e", ",", "setupCallback", ")", "{", "if", "(", "e", ")", "{", "self", ".", "fail", "(", "\"[munit] Failed to setup '\"", "+", "self", ".", "nsPath", "+", "\"' module\"", ",", "setupCallback", ",", "e", ")", ";", "return", "self", ".", "close", "(", ")", ";", "}", "// Run test", "self", ".", "callback", "(", "self", ",", "self", ".", "queue", ")", ";", "// If module isn't finished, then prove that it's supposed to be asynchronous", "if", "(", "self", ".", "state", "<", "munit", ".", "ASSERT_STATE_TEARDOWN", ")", "{", "// Only tear it down if no timeout is specified", "if", "(", "self", ".", "options", ".", "timeout", "<", "1", ")", "{", "self", ".", "close", "(", ")", ";", "}", "// Delayed close", "else", "if", "(", "!", "self", ".", "isAsync", ")", "{", "self", ".", "isAsync", "=", "true", ";", "self", ".", "_timerStart", "=", "Date", ".", "now", "(", ")", ";", "self", ".", "_timeid", "=", "setTimeout", "(", "function", "(", ")", "{", "if", "(", "self", ".", "state", "<", "munit", ".", "ASSERT_STATE_TEARDOWN", ")", "{", "self", ".", "close", "(", ")", ";", "}", "}", ",", "self", ".", "options", ".", "timeout", ")", ";", "}", "}", "}", ")", ";", "return", "self", ";", "}" ]

[ "Trigger", "module", "s", "tests" ]

[ "function", "(", ")", "{", "var", "self", "=", "this", ",", "nodeVersion", "=", "process", ".", "version", ".", "replace", "(", "/", "\\.", "/", "g", ",", "'_'", ")", ",", "xml", "=", "\"<testsuite name='\"", "+", "munit", ".", "_xmlEncode", "(", "nodeVersion", "+", "self", ".", "nsPath", ")", "+", "\"' tests='\"", "+", "self", ".", "count", "+", "\"' failures='\"", "+", "self", ".", "failed", "+", "\"' skipped='\"", "+", "self", ".", "skipped", "+", "\"' time='\"", "+", "(", "(", "self", ".", "end", "-", "self", ".", "start", ")", "/", "1000", ")", "+", "\"'>\"", ";", "self", ".", "list", ".", "forEach", "(", "function", "(", "result", ")", "{", "xml", "+=", "result", ".", "junit", "(", ")", ";", "}", ")", ";", "xml", "+=", "\"</testsuite>\"", ";", "return", "xml", ";", "}" ]

[ "Returns", "XML", "result", "format" ]

[ "function", "(", ")", "{", "var", "self", "=", "this", ";", "return", "{", "name", ":", "self", ".", "nsPath", ".", "split", "(", "'.'", ")", ".", "pop", "(", ")", ",", "nsPath", ":", "self", ".", "nsPath", ",", "count", ":", "self", ".", "count", ",", "passed", ":", "self", ".", "passed", ",", "failed", ":", "self", ".", "failed", ",", "skipped", ":", "self", ".", "skipped", ",", "start", ":", "self", ".", "start", ",", "end", ":", "self", ".", "end", ",", "time", ":", "self", ".", "end", "-", "self", ".", "start", ",", "tests", ":", "self", ".", "list", ",", "ns", ":", "self", ".", "ns", ",", "}", ";", "}" ]

[ "JSON", "result", "format" ]

[ "function", "(", "startFunc", ",", "forced", ")", "{", "var", "self", "=", "this", ",", "i", ",", "mod", ";", "// Can only close an active module", "self", ".", "requireState", "(", "munit", ".", "ASSERT_STATE_ACTIVE", ",", "self", ".", "close", ")", ";", "// Add fail marker if no tests were ran", "if", "(", "self", ".", "count", "<", "1", ")", "{", "self", ".", "fail", "(", "\"[munit] No tests ran in this module\"", ")", ";", "}", "// Auto close out any spies", "self", ".", "_spies", ".", "reverse", "(", ")", ".", "forEach", "(", "function", "(", "spy", ")", "{", "spy", ".", "restore", "(", ")", ";", "}", ")", ";", "// Proxy teardown to pass start function and forced state", "self", ".", "_teardown", "(", "function", "(", "e", ",", "teardownCallback", ")", "{", "if", "(", "e", ")", "{", "self", ".", "_fail", "(", "\"[munit] failed to teardown '\"", "+", "self", ".", "nsPath", "+", "\"' module properly\"", ",", "teardownCallback", ")", ";", "}", "self", ".", "_close", "(", "startFunc", "||", "self", ".", "close", ",", "forced", ")", ";", "}", ")", ";", "return", "self", ";", "}" ]

[ "Forcing", "close", "of", "module" ]

[ "function", "(", "startFunc", ",", "forced", ")", "{", "var", "self", "=", "this", ",", "i", ",", "mod", ";", "// Handle invalid number of tests ran", "if", "(", "self", ".", "options", ".", "expect", ">", "0", "&&", "self", ".", "count", "<", "self", ".", "options", ".", "expect", "&&", "munit", ".", "render", ".", "focusPath", "(", "self", ".", "nsPath", ")", ")", "{", "self", ".", "_fail", "(", "'[munit] Unexpected End'", ",", "startFunc", "||", "self", ".", "_close", ",", "'Expecting '", "+", "self", ".", "options", ".", "expect", "+", "' tests, only '", "+", "self", ".", "count", "+", "' ran.'", ")", ";", "}", "else", "if", "(", "self", ".", "count", "<", "1", "&&", "self", ".", "callback", "&&", "munit", ".", "render", ".", "focusPath", "(", "self", ".", "nsPath", ")", ")", "{", "self", ".", "_fail", "(", "\"[munit] No Tests Found\"", ",", "startFunc", "||", "self", ".", "_close", ",", "\"Module closed without any tests being ran.\"", ")", ";", "}", "// Remove timer", "if", "(", "self", ".", "_timeid", ")", "{", "self", ".", "_timeid", "=", "clearTimeout", "(", "self", ".", "_timeid", ")", ";", "}", "// Meta", "self", ".", "end", "=", "Date", ".", "now", "(", ")", ";", "// Readd the queue back to the stack", "if", "(", "self", ".", "options", ".", "autoQueue", "&&", "self", ".", "queue", ")", "{", "munit", ".", "queue", ".", "add", "(", "self", ".", "queue", ")", ";", "self", ".", "queue", "=", "null", ";", "}", "// Check to see if submodules have closed off yet", "for", "(", "i", "in", "self", ".", "ns", ")", "{", "mod", "=", "self", ".", "ns", "[", "i", "]", ";", "if", "(", "mod", ".", "state", "<", "munit", ".", "ASSERT_STATE_CLOSED", ")", "{", "// Force close them if needed", "if", "(", "forced", ")", "{", "mod", ".", "close", "(", "startFunc", "||", "self", ".", "_close", ",", "forced", ")", ";", "}", "else", "{", "return", "self", ";", "}", "}", "}", "// All submodules have closed off, can mark this one as finished", "return", "self", ".", "finish", "(", "startFunc", ",", "forced", ")", ";", "}" ]

[ "Closing", "of", "module", "after", "teardown", "process" ]

[ "function", "(", "startFunc", ",", "forced", ")", "{", "var", "self", "=", "this", ",", "i", ",", "mod", ";", "// Can only finish an module that's in a closed state", "self", ".", "requireState", "(", "munit", ".", "ASSERT_STATE_CLOSED", ",", "startFunc", "||", "self", ".", "finish", ")", ";", "// Flip state to finished", "self", ".", "state", "=", "munit", ".", "ASSERT_STATE_FINISHED", ";", "// Force close each submodule if necessary", "for", "(", "i", "in", "self", ".", "ns", ")", "{", "mod", "=", "self", ".", "ns", "[", "i", "]", ";", "if", "(", "mod", ".", "state", "<", "munit", ".", "ASSERT_STATE_CLOSED", ")", "{", "mod", ".", "close", "(", "startFunc", "||", "self", ".", "finish", ",", "true", ")", ";", "}", "}", "// Only print out results if on the focus path", "if", "(", "munit", ".", "render", ".", "focusPath", "(", "self", ".", "nsPath", ")", ")", "{", "self", ".", "_flush", "(", ")", ";", "}", "// Finish parent if not forced by it", "if", "(", "!", "forced", ")", "{", "if", "(", "self", ".", "parAssert", ")", "{", "if", "(", "self", ".", "parAssert", ".", "state", "<", "munit", ".", "ASSERT_STATE_CLOSED", ")", "{", "munit", ".", "render", ".", "check", "(", ")", ";", "return", "self", ";", "}", "for", "(", "i", "in", "self", ".", "parAssert", ".", "ns", ")", "{", "mod", "=", "self", ".", "parAssert", ".", "ns", "[", "i", "]", ";", "if", "(", "mod", ".", "state", "<", "munit", ".", "ASSERT_STATE_FINISHED", ")", "{", "munit", ".", "render", ".", "check", "(", ")", ";", "return", "self", ";", "}", "}", "self", ".", "parAssert", ".", "finish", "(", ")", ";", "}", "else", "{", "munit", ".", "render", ".", "check", "(", ")", ";", "}", "}", "return", "self", ";", "}" ]

[ "Finish", "this", "module", "and", "all", "sub", "modules" ]

[ "function", "(", "n", ")", "{", "return", "function", "chunk", "(", "arg", ")", "{", "if", "(", "Array", ".", "isArray", "(", "arg", ")", ")", "{", "return", "arg", ".", "reduce", "(", "(", "acc", ",", "_", ",", "i", ",", "a", ")", "=>", "{", "return", "i", "%", "n", "===", "0", "?", "acc", ".", "concat", "(", "[", "a", ".", "slice", "(", "i", ",", "i", "+", "n", ")", "]", ")", ":", "acc", ";", "}", ",", "[", "]", ")", ";", "}", "else", "if", "(", "typeof", "arg", "===", "'string'", ")", "{", "return", "arg", ".", "match", "(", "new", "RegExp", "(", "'.{1,'", "+", "n", "+", "'}'", ",", "'g'", ")", ")", "||", "[", "]", ";", "}", "else", "throw", "new", "TypeError", "(", "'Incorrect type. Passed in value should be an array or string.'", ")", ";", "}", "}" ]

[ "Returns", "an", "array", "of", "arrays", "or", "strings", "in", "chunks", "of", "n", "." ]

[ "function", "(", "fn1", ",", "fn2", ")", "{", "return", "function", "composed", "(", ")", "{", "return", "fn1", ".", "call", "(", "null", ",", "fn2", ".", "apply", "(", "null", ",", "arguments", ")", ")", ";", "}", "}" ]

[ "Creates", "a", "function", "from", "two", "functions", "that", "runs", "fn1", "on", "the", "results", "of", "fn2", "." ]

[ "function", "(", "fn", ")", "{", "return", "function", "curried", "(", ")", "{", "var", "gatheredArgs", "=", "[", "]", ".", "slice", ".", "call", "(", "arguments", ")", ";", "if", "(", "gatheredArgs", ".", "length", ">=", "fn", ".", "length", ")", "{", "return", "fn", ".", "apply", "(", "null", ",", "gatheredArgs", ")", ";", "}", "return", "function", "(", "innerArg", ")", "{", "var", "newArgs", "=", "[", "]", ".", "concat", "(", "gatheredArgs", ",", "innerArg", ")", ";", "return", "curried", ".", "apply", "(", "null", ",", "newArgs", ")", ";", "}", "}", "}" ]

[ "Takes", "a", "variadic", "function", "and", "returns", "unary", "functions", "until", "all", "parameters", "are", "used", "." ]

[ "function", "(", "value", ",", "times", ")", "{", "if", "(", "Array", ".", "fill", ")", "{", "return", "new", "Array", "(", "times", ")", ".", "fill", "(", "value", ")", ";", "}", "return", "Array", ".", "apply", "(", "null", ",", "Array", "(", "+", "times", ")", ")", ".", "map", "(", "function", "(", ")", "{", "return", "value", ";", "}", ")", ";", "}" ]

[ "Returns", "an", "array", "filled", "with", "a", "value", "repeated", "a", "number", "of", "times", "." ]

[ "function", "(", "x", ",", "fn", ")", "{", "if", "(", "Array", ".", "isArray", "(", "x", ")", ")", "{", "return", "x", ".", "reduce", "(", "function", "(", "acc", ",", "curr", ")", "{", "return", "acc", ".", "concat", "(", "funcifyr", ".", "flatMap", "(", "curr", ",", "fn", ")", ")", ";", "}", ",", "[", "]", ")", ";", "}", "return", "fn", "(", "x", ")", ";", "}" ]

[ "Takes", "a", "multidimensional", "array", "and", "a", "callback", "function", "and", "returns", "a", "new", "flattened", "array", "with", "the", "results", "of", "calling", "the", "callback", "function", "on", "each", "value", "." ]

[ "function", "(", "key", ")", "{", "return", "function", "group", "(", "arr", ")", "{", "return", "arr", ".", "reduce", "(", "function", "(", "obj", ",", "item", ")", "{", "(", "obj", "[", "item", "[", "key", "]", "]", "=", "obj", "[", "item", "[", "key", "]", "]", "||", "[", "]", ")", ".", "push", "(", "item", ")", ";", "return", "obj", ";", "}", ",", "{", "}", ")", ";", "}", "}" ]

[ "Groups", "together", "related", "prop", "values", "from", "an", "array", "of", "objects", "." ]

[ "function", "(", "collection", ",", "fn", ")", "{", "if", "(", "Array", ".", "isArray", "(", "collection", ")", ")", "{", "var", "result", "=", "[", "]", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "collection", ".", "length", ";", "i", "++", ")", "{", "result", "[", "i", "]", "=", "fn", "(", "collection", "[", "i", "]", ",", "i", ",", "collection", ")", ";", "}", "return", "result", ";", "}", "else", "if", "(", "Object", ".", "prototype", ".", "toString", ".", "call", "(", "collection", ")", "===", "'[object Object]'", ")", "{", "var", "result", "=", "{", "}", ";", "for", "(", "var", "key", "in", "collection", ")", "{", "if", "(", "collection", ".", "hasOwnProperty", "(", "key", ")", ")", "{", "result", "[", "key", "]", "=", "fn", "(", "collection", "[", "key", "]", ")", ";", "}", "}", "return", "result", ";", "}", "else", "throw", "new", "TypeError", "(", "'Invalid type. First argument must be an array or an object.'", ")", ";", "}" ]

[ "Maps", "over", "a", "collection", "and", "runs", "a", "callback", "on", "each", "item", "." ]

[ "function", "(", "fn1", ",", "fn2", ")", "{", "return", "function", "orified", "(", "arg", ")", "{", "return", "fn1", ".", "call", "(", "null", ",", "arg", ")", "||", "fn2", ".", "call", "(", "null", ",", "arg", ")", ";", "}", "}" ]

[ "Runs", "two", "predicate", "functions", "on", "an", "argument", "and", "returns", "true", "if", "either", "are", "true", "." ]

[ "function", "(", "/*fns*/", ")", "{", "var", "fns", "=", "[", "]", ".", "slice", ".", "call", "(", "arguments", ")", ";", "return", "function", "piped", "(", "/*args*/", ")", "{", "var", "args", "=", "[", "]", ".", "slice", ".", "call", "(", "arguments", ")", ";", "fns", ".", "forEach", "(", "function", "(", "fn", ")", "{", "args", "=", "[", "fn", ".", "apply", "(", "null", ",", "args", ")", "]", ";", "}", ")", ";", "return", "args", "[", "0", "]", ";", "}", ";", "}" ]

[ "Runs", "several", "functions", "using", "the", "result", "of", "one", "function", "as", "the", "argument", "for", "the", "next", "." ]

[ "function", "(", "start", ",", "stop", ",", "step", ")", "{", "if", "(", "arguments", ".", "length", "===", "1", ")", "return", "funcifyr", ".", "range", "(", "1", ",", "start", ",", "1", ")", ";", "if", "(", "arguments", ".", "length", "===", "2", ")", "return", "funcifyr", ".", "range", "(", "start", ",", "stop", ",", "1", ")", ";", "var", "result", "=", "[", "]", ";", "for", "(", "var", "i", "=", "start", ";", "i", "<=", "stop", ";", "i", "+=", "step", ")", "{", "result", ".", "push", "(", "i", ")", ";", "}", "return", "result", ";", "}" ]

[ "Returns", "an", "array", "of", "numbers", "ranging", "from", "start", "to", "stop", "incremented", "by", "step", "." ]

[ "function", "(", "str", ",", "times", ")", "{", "if", "(", "String", ".", "prototype", ".", "repeat", ")", "return", "str", ".", "repeat", "(", "times", ")", ";", "return", "Array", ".", "apply", "(", "null", ",", "new", "Array", "(", "times", ")", ")", ".", "map", "(", "function", "(", ")", "{", "return", "str", ";", "}", ")", ".", "join", "(", "''", ")", ";", "}" ]

[ "Repeats", "a", "string", "a", "number", "of", "times", "." ]

[ "function", "(", "arr", ")", "{", "for", "(", "var", "i", "=", "0", ";", "i", "<", "arr", ".", "length", ";", "i", "++", ")", "{", "var", "randIndex", "=", "Math", ".", "floor", "(", "Math", ".", "random", "(", ")", "*", "arr", ".", "length", ")", ";", "var", "temp", "=", "arr", "[", "randIndex", "]", ";", "arr", "[", "randIndex", "]", "=", "arr", "[", "i", "]", ";", "arr", "[", "i", "]", "=", "temp", ";", "}", "return", "arr", ";", "}" ]

[ "Randomly", "shuffles", "items", "in", "an", "array", "." ]

[ "function", "(", "prop", ")", "{", "return", "function", "tallied", "(", "arrayOfObjects", ")", "{", "return", "arrayOfObjects", ".", "reduce", "(", "function", "(", "acc", ",", "curr", ")", "{", "acc", "[", "curr", "[", "prop", "]", "]", "=", "(", "acc", "[", "curr", "[", "prop", "]", "]", "||", "0", ")", "+", "1", ";", "return", "acc", ";", "}", ",", "{", "}", ")", ";", "}", "}" ]

[ "Returns", "an", "object", "with", "the", "number", "of", "occurrences", "of", "a", "property", "value", "found", "in", "an", "array", "of", "objects", "." ]

[ "function", "(", "value", ")", "{", "return", "{", "value", ":", "value", ",", "then", ":", "function", "(", "fn", ")", "{", "this", ".", "value", "=", "fn", "(", "this", ".", "value", ")", ";", "return", "this", ";", "}", ",", "end", ":", "function", "(", ")", "{", "return", "this", ".", "value", ";", "}", "}", ";", "}" ]

[ "Creates", "sequence", "of", "chainable", "actions", "." ]

[ "function", "(", "arr", ")", "{", "if", "(", "Array", ".", "prototype", ".", "from", ")", "return", "Array", ".", "from", "(", "new", "Set", "(", "arr", ")", ")", ";", "return", "arr", ".", "filter", "(", "function", "(", "v", ",", "i", ",", "a", ")", "{", "return", "i", "===", "a", ".", "indexOf", "(", "v", ")", ";", "}", ")", ";", "}" ]

[ "Takes", "an", "array", "with", "duplicates", "and", "returns", "a", "new", "one", "with", "all", "dupes", "removed", "." ]

[ "function", "typePaths", "(", "config", ")", "{", "var", "out", "=", "[", "\"node_modules/@types\"", ",", "]", ";", "var", "paths", "=", "(", "config", ".", "compilerOptions", "&&", "config", ".", "compilerOptions", ".", "paths", ")", "||", "{", "}", ";", "Object", ".", "keys", "(", "paths", ")", ".", "forEach", "(", "function", "eachEntry", "(", "k", ")", "{", "// paths may contain a /*, eliminate it", "paths", "[", "k", "]", ".", "forEach", "(", "function", "eachPath", "(", "a", ")", "{", "var", "p", "=", "a", ".", "split", "(", "\"/\\*\"", ")", "[", "0", "]", ";", "if", "(", "out", ".", "indexOf", "(", "p", ")", "<", "0", ")", "{", "out", ".", "push", "(", "p", ")", ";", "}", "}", ")", ";", "}", ")", ";", "debug", "(", "\"type paths\"", ",", "out", ")", ";", "return", "out", ";", "}" ]

[ "Return", "the", "paths", "which", "contain", "type", "information", "." ]

[ "function", "(", "config", ",", "callback", ")", "{", "var", "self", "=", "this", ";", "var", "db", "=", "Array", "(", ")", ",", "diff", "=", "Array", "(", ")", ",", "first", "=", "true", ";", "for", "(", "var", "c", "=", "0", ";", "c", "<", "2", ";", "++", "c", ")", "{", "db", "[", "c", "]", "=", "Array", "(", ")", ";", "for", "(", "var", "d", "=", "0", ";", "d", "<", "2", ";", "++", "d", ")", "{", "db", "[", "c", "]", "[", "d", "]", "=", "Array", "(", ")", ";", "}", "}", "var", "query", "=", "util", ".", "format", "(", "'USE %s; SHOW FULL TABLES'", ",", "config", ".", "database", ")", ";", "this", ".", "runSql", "(", "query", ",", "null", ",", "{", "useArray", ":", "true", "}", ")", ".", "on", "(", "'result'", ",", "function", "(", "res", ")", "{", "res", ".", "on", "(", "'data'", ",", "function", "(", "row", ")", "{", "if", "(", "row", "[", "0", "]", "&&", "row", "[", "1", "]", "===", "'VIEW'", ")", "db", "[", "0", "]", "[", "1", "]", ".", "push", "(", "row", "[", "0", "]", ")", ";", "else", "if", "(", "row", "[", "0", "]", "&&", "row", "[", "0", "]", "!==", "'migrations'", ")", "db", "[", "0", "]", "[", "0", "]", ".", "push", "(", "row", "[", "0", "]", ")", ";", "}", ")", ";", "}", ")", ".", "on", "(", "'end'", ",", "function", "(", ")", "{", "if", "(", "config", ".", "diffDump", ")", "first", "=", "false", ";", "else", "callback", "(", "db", ")", ";", "}", ")", ";", "if", "(", "config", ".", "diffDump", ")", "{", "query", "=", "util", ".", "format", "(", "'USE %s; SHOW FULL TABLES'", ",", "config", ".", "database_diff", ")", ";", "this", ".", "runSql", "(", "query", ",", "null", ",", "{", "useArray", ":", "true", "}", ")", ".", "on", "(", "'result'", ",", "function", "(", "res", ")", "{", "res", ".", "on", "(", "'data'", ",", "function", "(", "row", ")", "{", "if", "(", "row", "[", "0", "]", "&&", "row", "[", "1", "]", "===", "'VIEW'", ")", "db", "[", "1", "]", "[", "1", "]", ".", "push", "(", "row", "[", "0", "]", ")", ";", "else", "if", "(", "row", "[", "0", "]", "&&", "row", "[", "0", "]", "!==", "'migrations'", ")", "db", "[", "1", "]", "[", "0", "]", ".", "push", "(", "row", "[", "0", "]", ")", ";", "}", ")", ";", "}", ")", ".", "on", "(", "'end'", ",", "function", "(", ")", "{", "while", "(", "first", ")", "{", "deasync", ".", "sleep", "(", "100", ")", ";", "}", "callback", "(", "db", ")", ";", "}", ")", ";", "}", "}" ]

[ "Returns", "an", "array", "containing", "the", "Tables", "." ]

[ "function", "(", "config", ",", "callback", ")", "{", "var", "self", "=", "this", ";", "var", "db", "=", "Array", "(", ")", ",", "diff", "=", "Array", "(", ")", ",", "first", "=", "true", ";", "db", "[", "0", "]", "=", "Array", "(", ")", ";", "db", "[", "1", "]", "=", "Array", "(", ")", ";", "diff", "[", "0", "]", "=", "Array", "(", ")", ";", "diff", "[", "1", "]", "=", "Array", "(", ")", ";", "var", "query", "=", "'SELECT name, modified, type FROM mysql.proc WHERE db = ?'", ";", "this", ".", "runSql", "(", "query", ",", "[", "config", ".", "database", "]", ")", ".", "on", "(", "'result'", ",", "function", "(", "res", ")", "{", "res", ".", "on", "(", "'data'", ",", "function", "(", "row", ")", "{", "if", "(", "row", ".", "type", "===", "'FUNCTION'", ")", "db", "[", "0", "]", ".", "push", "(", "[", "row", ".", "name", ",", "row", ".", "modified", "]", ")", ";", "else", "if", "(", "row", ".", "type", "===", "'PROCEDURE'", ")", "db", "[", "1", "]", ".", "push", "(", "[", "row", ".", "name", ",", "row", ".", "modified", "]", ")", ";", "}", ")", ";", "}", ")", ".", "on", "(", "'end'", ",", "function", "(", ")", "{", "if", "(", "config", ".", "diffDump", ")", "first", "=", "false", ";", "else", "callback", "(", "db", ")", ";", "}", ")", ";", "if", "(", "config", ".", "diffDump", ")", "{", "var", "query", "=", "'SELECT name, modified, type FROM mysql.proc WHERE db = ?'", ";", "this", ".", "runSql", "(", "query", ",", "[", "config", ".", "database_diff", "]", ",", "false", ")", ".", "on", "(", "'result'", ",", "function", "(", "res", ")", "{", "res", ".", "on", "(", "'data'", ",", "function", "(", "row", ")", "{", "if", "(", "row", ".", "type", "===", "'FUNCTION'", ")", "diff", "[", "0", "]", ".", "push", "(", "[", "row", ".", "name", ",", "row", ".", "modified", "]", ")", ";", "else", "if", "(", "row", ".", "type", "===", "'PROCEDURE'", ")", "diff", "[", "1", "]", ".", "push", "(", "[", "row", ".", "name", ",", "row", ".", "modified", "]", ")", ";", "}", ")", ";", "}", ")", ".", "on", "(", "'end'", ",", "function", "(", ")", "{", "while", "(", "first", ")", "{", "deasync", ".", "sleep", "(", "100", ")", ";", "}", "callback", "(", "db", ",", "diff", ")", ";", "}", ")", ";", "}", "}" ]

[ "No", "specification", "yet", "." ]

[ "function", "(", "config", ",", "tables", ",", "context", ",", "callback", ")", "{", "var", "self", "=", "this", ";", "var", "db", "=", "Array", "(", ")", ",", "counter", "=", "0", ",", "query", "=", "'SHOW INDEX FROM %s.%s;'", ";", "db", "[", "0", "]", "=", "Array", "(", ")", ";", "db", "[", "1", "]", "=", "Array", "(", ")", ";", "var", "len", "=", "(", "tables", ".", "tables", "[", "0", "]", ".", "length", ">", "tables", ".", "tables", "[", "1", "]", ".", "length", ")", "?", "tables", ".", "tables", "[", "0", "]", ".", "length", ":", "tables", ".", "tables", "[", "1", "]", ".", "length", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "len", ";", "++", "i", ")", "{", "var", "q", "=", "''", ",", "stmt", "=", "0", ";", "if", "(", "tables", ".", "tables", "[", "0", "]", "[", "i", "]", ")", "q", "=", "util", ".", "format", "(", "query", ",", "config", ".", "database", ",", "tables", ".", "tables", "[", "0", "]", "[", "i", "]", ")", ";", "else", "++", "stmt", ";", "if", "(", "tables", ".", "tables", "[", "1", "]", "[", "i", "]", ")", "q", "+=", "util", ".", "format", "(", "query", ",", "config", ".", "database_diff", ",", "tables", ".", "tables", "[", "1", "]", "[", "i", "]", ")", ";", "//scoping stmt and interator to event", "(", "function", "(", "stmt", ",", "i", ")", "{", "self", ".", "runSql", "(", "q", ",", "null", ",", "{", "useArray", ":", "true", "}", ")", ".", "on", "(", "'result'", ",", "function", "(", "res", ")", "{", "var", "local", "=", "stmt", "++", ";", "res", ".", "on", "(", "'data'", ",", "function", "(", "row", ")", "{", "row", "[", "0", "]", "=", "row", "[", "2", "]", ";", "//replace table by key name", "row", "[", "1", "]", "=", "row", "[", "1", "]", "===", "'0'", ";", "row", ".", "splice", "(", "2", ",", "1", ")", ";", "//delete moved key name", "//<-- Seq_in_index has now moved one index lower", "row", ".", "splice", "(", "4", ",", "4", ")", ";", "//delete until null info", "row", "[", "4", "]", "=", "(", "row", "[", "4", "]", "===", "'YES'", ")", "?", "true", ":", "false", ";", "//Comment and Index_comment will be simply ignored", "//Maybe I'm going to implement them later, but not for now.", "if", "(", "!", "db", "[", "local", "]", "[", "tables", ".", "tables", "[", "local", "]", "[", "i", "]", "]", ")", "db", "[", "local", "]", "[", "tables", ".", "tables", "[", "local", "]", "[", "i", "]", "]", "=", "Array", "(", ")", ";", "db", "[", "local", "]", "[", "tables", ".", "tables", "[", "local", "]", "[", "i", "]", "]", ".", "push", "(", "row", ")", ";", "}", ")", ";", "}", ")", ".", "on", "(", "'end'", ",", "function", "(", ")", "{", "if", "(", "++", "counter", ">=", "len", ")", "callback", "(", "context", ",", "db", ")", ";", "}", ")", ";", "}", ")", "(", "stmt", ",", "i", ")", ";", "}", "}" ]

[ "Returns", "an", "array", "containing", "the", "indizies", "." ]

[ "function", "(", "config", ",", "tables", ",", "context", ",", "callback", ")", "{", "var", "self", "=", "this", ",", "db", "=", "Array", "(", ")", ",", "counter", "=", "0", ";", "db", "[", "0", "]", "=", "Array", "(", ")", ";", "db", "[", "1", "]", "=", "Array", "(", ")", ";", "var", "len", "=", "(", "tables", ".", "tables", "[", "0", "]", ".", "length", ">", "tables", ".", "tables", "[", "1", "]", ".", "length", ")", "?", "tables", ".", "tables", "[", "0", "]", ".", "length", ":", "tables", ".", "tables", "[", "1", "]", ".", "length", ";", "var", "query", "=", "[", "'SELECT const.CONSTRAINT_NAME, const.CONSTRAINT_SCHEMA,const.TABLE_NAME,'", ",", "'const.REFERENCED_TABLE_NAME,const.UPDATE_RULE,const.DELETE_RULE,'", ",", "'const_keys.COLUMN_NAME,const_keys.POSITION_IN_UNIQUE_CONSTRAINT,'", ",", "'const_keys.REFERENCED_COLUMN_NAME,const_keys.REFERENCED_TABLE_SCHEMA'", ",", "'FROM information_schema.REFERENTIAL_CONSTRAINTS const'", ",", "'INNER JOIN information_schema.KEY_COLUMN_USAGE const_keys ON ( '", ",", "'const_keys.CONSTRAINT_SCHEMA = const.CONSTRAINT_SCHEMA'", ",", "'AND const_keys.CONSTRAINT_NAME = const.CONSTRAINT_NAME )'", ",", "'WHERE const.CONSTRAINT_SCHEMA = ?'", ",", "'AND const.TABLE_NAME = ?;'", "]", ".", "join", "(", "' '", ")", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "len", ";", "++", "i", ")", "{", "var", "q", "=", "''", ",", "params", "=", "Array", "(", ")", ",", "stmt", "=", "0", ";", "if", "(", "tables", ".", "tables", "[", "0", "]", "[", "i", "]", ")", "{", "q", "=", "query", ";", "params", ".", "push", "(", "config", ".", "database", ")", ";", "params", ".", "push", "(", "tables", ".", "tables", "[", "0", "]", "[", "i", "]", ")", ";", "}", "else", "++", "stmt", ";", "if", "(", "tables", ".", "tables", "[", "1", "]", "[", "i", "]", ")", "{", "q", "+=", "query", ";", "params", ".", "push", "(", "config", ".", "database_diff", ")", ";", "params", ".", "push", "(", "tables", ".", "tables", "[", "1", "]", "[", "i", "]", ")", ";", "}", "//scoping stmt and interator to event", "(", "function", "(", "stmt", ",", "i", ")", "{", "self", ".", "runSql", "(", "q", ",", "params", ",", "{", "useArray", ":", "true", "}", ")", ".", "on", "(", "'result'", ",", "function", "(", "res", ")", "{", "var", "local", "=", "stmt", "++", ";", "res", ".", "on", "(", "'data'", ",", "function", "(", "row", ")", "{", "constraint", "=", "Array", "(", ")", ";", "if", "(", "!", "db", "[", "local", "]", "[", "tables", ".", "tables", "[", "local", "]", "[", "i", "]", "]", ")", "db", "[", "local", "]", "[", "tables", ".", "tables", "[", "local", "]", "[", "i", "]", "]", "=", "Array", "(", ")", ";", "constraint", "[", "0", "]", "=", "row", "[", "0", "]", ";", "//constraint_name", "constraint", "[", "1", "]", "=", "row", "[", "6", "]", ";", "//column_name", "constraint", "[", "2", "]", "=", "row", "[", "9", "]", ";", "//referenced_table_schema", "constraint", "[", "3", "]", "=", "row", "[", "3", "]", ";", "//referenced_table_name", "constraint", "[", "4", "]", "=", "row", "[", "8", "]", ";", "//referenced_column_name", "constraint", "[", "5", "]", "=", "row", "[", "7", "]", ";", "//position_in_unique_constraint", "constraint", "[", "6", "]", "=", "row", "[", "4", "]", ";", "//on_update", "constraint", "[", "7", "]", "=", "row", "[", "5", "]", ";", "//on_delete", "db", "[", "local", "]", "[", "tables", ".", "tables", "[", "local", "]", "[", "i", "]", "]", ".", "push", "(", "constraint", ")", ";", "}", ")", ";", "}", ")", ".", "on", "(", "'end'", ",", "function", "(", ")", "{", "if", "(", "++", "counter", ">=", "len", ")", "callback", "(", "context", ",", "db", ")", ";", "}", ")", ";", "}", ")", "(", "stmt", ",", "i", ")", ";", "}", "}" ]

[ "Returns", "an", "array", "containing", "the", "foreign", "keys", "." ]

[ "function", "(", "wholeMatch", ",", "match", ",", "left", ",", "right", ")", "{", "// unescape match to prevent double escaping", "match", "=", "htmlunencode", "(", "match", ")", ";", "return", "left", "+", "hljs", ".", "highlightAuto", "(", "match", ")", ".", "value", "+", "right", ";", "}" ]

[ "use", "new", "shodown", "s", "regexp", "engine", "to", "conditionally", "parse", "codeblocks" ]

[ "function", "HashThrough", "(", "createHash", ")", "{", "const", "hashThrough", "=", "new", "Transform", "(", ")", "const", "hash", "=", "createHash", "(", ")", "hashThrough", ".", "_transform", "=", "function", "(", "chunk", ",", "encoding", ",", "cb", ")", "{", "setImmediate", "(", "_", "=>", "{", "try", "{", "hash", ".", "update", "(", "chunk", ")", "cb", "(", "null", ",", "chunk", ")", "}", "catch", "(", "err", ")", "{", "cb", "(", "err", ")", "}", "}", ")", "}", "// bind the digest function to hash object", "hashThrough", ".", "digest", "=", "format", "=>", "hash", ".", "digest", "(", "format", ")", "return", "hashThrough", "}" ]

[ "Effectively", "a", "PassThrough", "stream", "that", "taps", "to", "chunks", "flow", "and", "accumulating", "the", "hash" ]

[ "function", "Logger", "(", "level", ")", "{", "if", "(", "_", ".", "isString", "(", "level", ")", "&&", "_", ".", "has", "(", "LogLevel", ",", "level", ")", ")", "{", "this", ".", "level", "=", "LogLevel", "[", "level", "]", ";", "}", "else", "if", "(", "_", ".", "isNumber", "(", "level", ")", "&&", "level", ">=", "0", "&&", "level", "<=", "4", ")", "{", "this", ".", "level", "=", "level", ";", "}", "else", "{", "this", ".", "level", "=", "LogLevel", ".", "info", ";", "}", "}" ]

[ "Logger", "that", "logs", "exclusively", "to", "stderr", "so", "that", "logging", "doesn", "t", "pollute", "the", "scraper", "result", "which", "is", "written", "to", "stdout", "." ]

[ "function", "localSearchFactory", "(", "$http", ",", "$timeout", ",", "NG_PAGES", ")", "{", "console", ".", "log", "(", "'Using Local Search Index'", ")", ";", "// Create the lunr index", "var", "index", "=", "lunr", "(", "function", "(", ")", "{", "this", ".", "ref", "(", "'path'", ")", ";", "this", ".", "field", "(", "'titleWords'", ",", "{", "boost", ":", "50", "}", ")", ";", "this", ".", "field", "(", "'members'", ",", "{", "boost", ":", "40", "}", ")", ";", "this", ".", "field", "(", "'keywords'", ",", "{", "boost", ":", "20", "}", ")", ";", "}", ")", ";", "// Delay building the index by loading the data asynchronously", "var", "indexReadyPromise", "=", "$http", ".", "get", "(", "'js/search-data.json'", ")", ".", "then", "(", "function", "(", "response", ")", "{", "var", "searchData", "=", "response", ".", "data", ";", "// Delay building the index for 500ms to allow the page to render", "return", "$timeout", "(", "function", "(", ")", "{", "// load the page data into the index", "angular", ".", "forEach", "(", "searchData", ",", "function", "(", "page", ")", "{", "index", ".", "add", "(", "page", ")", ";", "}", ")", ";", "}", ",", "500", ")", ";", "}", ")", ";", "// The actual service is a function that takes a query string and", "// returns a promise to the search results", "// (In this case we just resolve the promise immediately as it is not", "// inherently an async process)", "return", "function", "(", "q", ")", "{", "return", "indexReadyPromise", ".", "then", "(", "function", "(", ")", "{", "var", "hits", "=", "index", ".", "search", "(", "q", ")", ";", "var", "results", "=", "[", "]", ";", "angular", ".", "forEach", "(", "hits", ",", "function", "(", "hit", ")", "{", "results", ".", "push", "(", "NG_PAGES", "[", "hit", ".", "ref", "]", ")", ";", "}", ")", ";", "return", "results", ";", "}", ")", ";", "}", ";", "}" ]

[ "This", "version", "of", "the", "service", "builds", "the", "index", "in", "the", "current", "thread", "which", "blocks", "rendering", "and", "other", "browser", "activities", ".", "It", "should", "only", "be", "used", "where", "the", "browser", "does", "not", "support", "WebWorkers" ]

[ "function", "webWorkerSearchFactory", "(", "$q", ",", "$rootScope", ",", "NG_PAGES", ")", "{", "console", ".", "log", "(", "'Using WebWorker Search Index'", ")", "var", "searchIndex", "=", "$q", ".", "defer", "(", ")", ";", "var", "results", ";", "var", "worker", "=", "new", "Worker", "(", "'js/search-worker.js'", ")", ";", "// The worker will send us a message in two situations:", "// - when the index has been built, ready to run a query", "// - when it has completed a search query and the results are available", "worker", ".", "onmessage", "=", "function", "(", "oEvent", ")", "{", "$rootScope", ".", "$apply", "(", "function", "(", ")", "{", "switch", "(", "oEvent", ".", "data", ".", "e", ")", "{", "case", "'index-ready'", ":", "searchIndex", ".", "resolve", "(", ")", ";", "break", ";", "case", "'query-ready'", ":", "var", "pages", "=", "oEvent", ".", "data", ".", "d", ".", "map", "(", "function", "(", "path", ")", "{", "return", "NG_PAGES", "[", "path", "]", ";", "}", ")", ";", "results", ".", "resolve", "(", "pages", ")", ";", "break", ";", "}", "}", ")", ";", "}", ";", "// The actual service is a function that takes a query string and", "// returns a promise to the search results", "return", "function", "(", "q", ")", "{", "// We only run the query once the index is ready", "return", "searchIndex", ".", "promise", ".", "then", "(", "function", "(", ")", "{", "results", "=", "$q", ".", "defer", "(", ")", ";", "worker", ".", "postMessage", "(", "{", "q", ":", "q", "}", ")", ";", "return", "results", ".", "promise", ";", "}", ")", ";", "}", ";", "}" ]

[ "This", "version", "of", "the", "service", "builds", "the", "index", "in", "a", "WebWorker", "which", "does", "not", "block", "rendering", "and", "other", "browser", "activities", ".", "It", "should", "only", "be", "used", "where", "the", "browser", "does", "support", "WebWorkers" ]

[ "function", "queue", "(", "job", ",", "value", ",", "put", ")", "{", "var", "ts", "=", "timestamp", "(", ")", "var", "key", "=", "toKey", "(", "job", ",", "ts", ")", "var", "id", "=", "hash", "(", "job", "+", "':'", "+", "value", ")", "if", "(", "pending", "[", "id", "]", ")", "return", "null", "//this job is already queued.", "pending", "[", "id", "]", "=", "Date", ".", "now", "(", ")", "if", "(", "put", "===", "false", ")", "{", "//return the job to be queued, to include it in a batch insert.", "return", "{", "type", ":", "'put'", ",", "key", ":", "Buffer", ".", "isBuffer", "(", "key", ")", "?", "key", ":", "new", "Buffer", "(", "key", ")", ",", "value", ":", "Buffer", ".", "isBuffer", "(", "key", ")", "?", "value", ":", "new", "Buffer", "(", "value", ")", "}", "}", "else", "{", "db", ".", "put", "(", "key", ",", "value", ")", "}", "}" ]

[ "put", "=", "false", "means", "return", "a", "job", "to", "be", "queued" ]

[ "function", "skew", "(", "ax", ",", "ay", ")", "{", "return", "{", "a", ":", "1", ",", "c", ":", "tan", "(", "ax", ")", ",", "e", ":", "0", ",", "b", ":", "tan", "(", "ay", ")", ",", "d", ":", "1", ",", "f", ":", "0", "}", ";", "}" ]

[ "Calculate", "a", "skew", "matrix" ]

[ "function", "skewDEG", "(", "ax", ",", "ay", ")", "{", "return", "skew", "(", "ax", "*", "Math", ".", "PI", "/", "180", ",", "ay", "*", "Math", ".", "PI", "/", "180", ")", ";", "}" ]

[ "Calculate", "a", "skew", "matrix", "using", "DEG", "angles" ]

[ "function", "ObjectID", "(", "id", ")", "{", "// Duck-typing to support ObjectId from different npm packages", "if", "(", "id", "instanceof", "ObjectID", ")", "return", "id", ";", "if", "(", "!", "(", "this", "instanceof", "ObjectID", ")", ")", "return", "new", "ObjectID", "(", "id", ")", ";", "this", ".", "_bsontype", "=", "'ObjectID'", ";", "// The most common usecase (blank id, new objectId instance)", "if", "(", "id", "==", "null", "||", "typeof", "id", "===", "'number'", ")", "{", "// Generate a new id", "this", ".", "id", "=", "this", ".", "generate", "(", "id", ")", ";", "// If we are caching the hex string", "if", "(", "ObjectID", ".", "cacheHexString", ")", "this", ".", "__id", "=", "this", ".", "toString", "(", "'hex'", ")", ";", "// Return the object", "return", ";", "}", "// Check if the passed in id is valid", "var", "valid", "=", "ObjectID", ".", "isValid", "(", "id", ")", ";", "// Throw an error if it's not a valid setup", "if", "(", "!", "valid", "&&", "id", "!=", "null", ")", "{", "throw", "new", "Error", "(", "'Argument passed in must be a single String of 12 bytes or a string of 24 hex characters'", ")", ";", "}", "else", "if", "(", "valid", "&&", "typeof", "id", "===", "'string'", "&&", "id", ".", "length", "===", "24", "&&", "hasBufferType", ")", "{", "return", "new", "ObjectID", "(", "new", "Buffer", "(", "id", ",", "'hex'", ")", ")", ";", "}", "else", "if", "(", "valid", "&&", "typeof", "id", "===", "'string'", "&&", "id", ".", "length", "===", "24", ")", "{", "return", "ObjectID", ".", "createFromHexString", "(", "id", ")", ";", "}", "else", "if", "(", "id", "!=", "null", "&&", "id", ".", "length", "===", "12", ")", "{", "// assume 12 byte string", "this", ".", "id", "=", "id", ";", "}", "else", "if", "(", "id", "!=", "null", "&&", "id", ".", "toHexString", ")", "{", "// Duck-typing to support ObjectId from different npm packages", "return", "id", ";", "}", "else", "{", "throw", "new", "Error", "(", "'Argument passed in must be a single String of 12 bytes or a string of 24 hex characters'", ")", ";", "}", "if", "(", "ObjectID", ".", "cacheHexString", ")", "this", ".", "__id", "=", "this", ".", "toString", "(", "'hex'", ")", ";", "}" ]

[ "Create", "a", "new", "ObjectID", "instance" ]

[ "function", "init", "(", "masterPassword", ",", "map", ")", "{", "var", "fileContents", "=", "JSON", ".", "stringify", "(", "map", ")", ";", "var", "encryptedFileContents", "=", "encryption", ".", "encrypt", "(", "fileContents", ",", "masterPassword", ")", ";", "file", ".", "writeToFile", "(", "encryptedFileContents", ")", ";", "}" ]

[ "Make", "a", "new", "safetext", "file", "with", "encrypted", "contents", "." ]

[ "function", "getContents", "(", "masterPassword", ")", "{", "var", "encryptedContents", "=", "file", ".", "readFile", "(", ")", ";", "try", "{", "var", "contents", "=", "encryption", ".", "decrypt", "(", "encryptedContents", ",", "masterPassword", ")", ";", "return", "JSON", ".", "parse", "(", "contents", ")", ";", "}", "catch", "(", "err", ")", "{", "console", ".", "log", "(", "err", ")", ";", "throw", "new", "Error", "(", "\"Error reading file contents. This most likely means the provided password is wrong.\"", ")", ";", "}", "}" ]

[ "Read", "object", "out", "of", "safetext", "must", "include", "master", "password", "." ]

[ "function", "getKey", "(", "key", ",", "masterPassword", ")", "{", "var", "contents", "=", "getContents", "(", "masterPassword", ")", ";", "if", "(", "contents", "[", "key", "]", "!=", "undefined", ")", "return", "contents", "[", "key", "]", ";", "else", "throw", "new", "Error", "(", "`", "${", "key", "}", "`", ")", ";", "}" ]

[ "Get", "a", "specific", "key", "value", "from", "safetext", "file", "." ]

[ "function", "writeKey", "(", "key", ",", "value", ",", "masterPassword", ")", "{", "var", "contents", "=", "getContents", "(", "masterPassword", ")", ";", "contents", "[", "key", "]", "=", "value", ";", "var", "fileContents", "=", "JSON", ".", "stringify", "(", "contents", ")", ";", "var", "encryptedFileContents", "=", "encryption", ".", "encrypt", "(", "fileContents", ",", "masterPassword", ")", ";", "file", ".", "writeToFile", "(", "encryptedFileContents", ")", ";", "}" ]

[ "Writes", "a", "key", "to", "the", "safetext", "file", "." ]

[ "function", "removeKey", "(", "key", ",", "masterPassword", ")", "{", "var", "contents", "=", "getContents", "(", "masterPassword", ")", ";", "if", "(", "contents", "[", "key", "]", "!=", "undefined", ")", "delete", "contents", "[", "key", "]", ";", "var", "fileContents", "=", "JSON", ".", "stringify", "(", "contents", ")", ";", "var", "encryptedFileContents", "=", "encryption", ".", "encrypt", "(", "fileContents", ",", "masterPassword", ")", ";", "file", ".", "writeToFile", "(", "encryptedFileContents", ")", ";", "}" ]

[ "Removes", "a", "key", "from", "the", "safetext", "password", "file", "." ]

[ "function", "changePassword", "(", "masterPassword", ",", "newPassword1", ",", "newPassword2", ")", "{", "if", "(", "newPassword1", "!==", "newPassword2", ")", "throw", "new", "Error", "(", "\"New passwords must match.\"", ")", ";", "else", "{", "var", "contents", "=", "getContents", "(", "masterPassword", ")", ";", "init", "(", "newPassword1", ",", "contents", ")", ";", "}", "}" ]

[ "Changes", "the", "password", "of", "the", "safetext", "file", "." ]

[ "function", "(", "total", ",", "timeout", ")", "{", "events", ".", "EventEmitter", ".", "call", "(", "this", ")", ";", "if", "(", "!", "isPositiveInteger", "(", "total", ")", ")", "{", "throw", "new", "Error", "(", "'`total` must be a positive integer'", ")", ";", "}", "if", "(", "timeout", "&&", "!", "isPositiveInteger", "(", "timeout", ")", ")", "{", "throw", "new", "Error", "(", "'`timeout` must be a positive integer'", ")", ";", "}", "this", ".", "destroyed", "=", "false", ";", "this", ".", "total", "=", "total", ";", "this", ".", "fired", "=", "0", ";", "if", "(", "timeout", ")", "{", "this", ".", "timer", "=", "setTimeout", "(", "function", "(", ")", "{", "this", ".", "onTimeout", "(", ")", ";", "}", ".", "bind", "(", "this", ")", ",", "timeout", ")", ";", "}", "}" ]

[ "EventCollector", "class", "." ]

[ "function", "_join", "(", "arr1", ",", "arr2", ")", "{", "var", "len", "=", "arr1", ".", "length", ">", "arr2", "?", "arr1", ".", "length", ":", "arr2", ".", "length", "var", "joinedArr", "=", "[", "]", "while", "(", "len", "--", ")", "{", "joinedArr", ".", "push", "(", "arr1", ".", "shift", "(", ")", ")", "joinedArr", ".", "push", "(", "arr2", ".", "shift", "(", ")", ")", "}", "// merge remains", "return", "joinedArr", ".", "concat", "(", "arr1", ")", ".", "concat", "(", "arr2", ")", "}" ]

[ "join", "arr2", "s", "items", "to", "arr" ]

[ "function", "callCompat", "(", "obj", ")", "{", "if", "(", "obj", ")", "{", "obj", "=", "obj", ".", "prototype", "||", "obj", ";", "PIXI", ".", "EventTarget", ".", "mixin", "(", "obj", ")", ";", "}", "}" ]

[ "Backward", "compat", "from", "when", "this", "used", "to", "be", "a", "function" ]

[ "function", "(", ")", "{", "var", "ikConstraints", "=", "this", ".", "ikConstraints", ";", "var", "ikConstraintsCount", "=", "ikConstraints", ".", "length", ";", "var", "arrayCount", "=", "ikConstraintsCount", "+", "1", ";", "var", "boneCache", "=", "this", ".", "boneCache", ";", "if", "(", "boneCache", ".", "length", ">", "arrayCount", ")", "boneCache", ".", "length", "=", "arrayCount", ";", "for", "(", "var", "i", "=", "0", ",", "n", "=", "boneCache", ".", "length", ";", "i", "<", "n", ";", "i", "++", ")", "boneCache", "[", "i", "]", ".", "length", "=", "0", ";", "while", "(", "boneCache", ".", "length", "<", "arrayCount", ")", "boneCache", "[", "boneCache", ".", "length", "]", "=", "[", "]", ";", "var", "nonIkBones", "=", "boneCache", "[", "0", "]", ";", "var", "bones", "=", "this", ".", "bones", ";", "outer", ":", "for", "(", "var", "i", "=", "0", ",", "n", "=", "bones", ".", "length", ";", "i", "<", "n", ";", "i", "++", ")", "{", "var", "bone", "=", "bones", "[", "i", "]", ";", "var", "current", "=", "bone", ";", "do", "{", "for", "(", "var", "ii", "=", "0", ";", "ii", "<", "ikConstraintsCount", ";", "ii", "++", ")", "{", "var", "ikConstraint", "=", "ikConstraints", "[", "ii", "]", ";", "var", "parent", "=", "ikConstraint", ".", "bones", "[", "0", "]", ";", "var", "child", "=", "ikConstraint", ".", "bones", "[", "ikConstraint", ".", "bones", ".", "length", "-", "1", "]", ";", "while", "(", "true", ")", "{", "if", "(", "current", "==", "child", ")", "{", "boneCache", "[", "ii", "]", ".", "push", "(", "bone", ")", ";", "boneCache", "[", "ii", "+", "1", "]", ".", "push", "(", "bone", ")", ";", "continue", "outer", ";", "}", "if", "(", "child", "==", "parent", ")", "break", ";", "child", "=", "child", ".", "parent", ";", "}", "}", "current", "=", "current", ".", "parent", ";", "}", "while", "(", "current", ")", ";", "nonIkBones", "[", "nonIkBones", ".", "length", "]", "=", "bone", ";", "}", "}" ]

[ "Caches", "information", "about", "bones", "and", "IK", "constraints", ".", "Must", "be", "called", "if", "bones", "or", "IK", "constraints", "are", "added", "or", "removed", "." ]

[ "function", "asyncifyFunctions", "(", "forms", ")", "{", "// for each subexpression form...", "forms", ".", "forEach", "(", "function", "(", "form", ")", "{", "if", "(", "sl", ".", "isList", "(", "form", ")", ")", "{", "if", "(", "sl", ".", "typeOf", "(", "form", "[", "0", "]", ")", "===", "'symbol'", "&&", "sl", ".", "valueOf", "(", "form", "[", "0", "]", ")", "===", "'function'", "&&", "asyncNeeded", "(", "form", ")", ")", "{", "form", ".", "unshift", "(", "sl", ".", "atom", "(", "\"async\"", ")", ")", ";", "asyncifyFunctions", "(", "form", ")", ";", "}", "else", "{", "asyncifyFunctions", "(", "form", ")", ";", "}", "}", "}", ")", ";", "}" ]

[ "Had", "to", "timebox", "this", "-", "double", "check", "it", "later", "-", "I", "ve", "yet", "to", "handle", "functions", "nested", "down", "under", "other", "functions", "-", "in", "that", "case", "isn", "t", "co", ".", "wrap", "needed", "to", "be", "added", "both", "at", "the", "lowest", "level", "and", "at", "the", "higher", "levels?", "Right", "now", "I", "stop", "at", "the", "higher", "levels", "." ]

[ "function", "on", "(", "event", ",", "fn", ")", "{", "if", "(", "typeof", "event", "!==", "'string'", ")", "{", "throw", "new", "Error", "(", "'\"event\" not a string'", ")", ";", "}", "if", "(", "!", "(", "fn", "instanceof", "Function", ")", ")", "{", "throw", "new", "Error", "(", "'\"fn\" not a Function'", ")", ";", "}", "if", "(", "hasListener", "(", "event", ",", "fn", ")", ")", "{", "return", "false", ";", "}", "if", "(", "!", "hasListeners", "(", "event", ")", ")", "{", "listeners", "[", "event", "]", "=", "[", "]", ";", "}", "listeners", "[", "event", "]", ".", "push", "(", "fn", ")", ";", "return", "true", ";", "}" ]

[ "Registers", "a", "listener", "for", "a", "type", "of", "event", "." ]

[ "function", "off", "(", "event", ",", "fn", ")", "{", "if", "(", "typeof", "event", "!==", "'string'", ")", "{", "throw", "new", "Error", "(", "'\"event\" not a string'", ")", ";", "}", "if", "(", "fn", "!==", "undefined", "&&", "!", "(", "fn", "instanceof", "Function", ")", ")", "{", "throw", "new", "Error", "(", "'\"fn\" not a Function'", ")", ";", "}", "if", "(", "fn", ")", "{", "// do we event have this listener", "if", "(", "!", "hasListener", "(", "event", ",", "fn", ")", ")", "{", "return", "false", ";", "}", "// unregistering a specific listener for the event", "listeners", "[", "event", "]", "=", "listeners", "[", "event", "]", ".", "filter", "(", "function", "(", "l", ")", "{", "return", "l", "!==", "fn", ";", "}", ")", ";", "if", "(", "listeners", "[", "event", "]", ".", "length", "===", "0", ")", "{", "delete", "listeners", "[", "event", "]", ";", "}", "}", "else", "{", "// do we have any listeners for this event?", "if", "(", "!", "hasListeners", "(", "event", ")", ")", "{", "return", "false", ";", "}", "// unregistering all listeners for the event", "delete", "listeners", "[", "event", "]", ";", "}", "return", "true", ";", "}" ]

[ "Unregisters", "one", "or", "all", "listeners", "for", "an", "event", "." ]

[ "function", "fire", "(", "event", ")", "{", "if", "(", "typeof", "event", "!==", "'string'", ")", "{", "throw", "new", "Error", "(", "'\"event\" not a string'", ")", ";", "}", "// any listeners registered?", "if", "(", "!", "hasListeners", "(", "event", ")", ")", "{", "return", "triggerObject", ";", "}", "// get optional arguments", "var", "args", "=", "Array", ".", "prototype", ".", "slice", ".", "call", "(", "arguments", ",", "1", ")", ";", "// invoke listener functions", "listeners", "[", "event", "]", ".", "slice", "(", "0", ")", ".", "forEach", "(", "function", "(", "fn", ")", "{", "fn", ".", "apply", "(", "global", ",", "args", ")", ";", "}", ")", ";", "return", "triggerObject", ";", "}" ]

[ "Fires", "an", "event", "." ]

[ "function", "fireAsync", "(", "event", ")", "{", "var", "args", "=", "Array", ".", "prototype", ".", "slice", ".", "call", "(", "arguments", ")", ";", "setTimeout", "(", "function", "(", ")", "{", "fire", ".", "apply", "(", "triggerObject", ",", "args", ")", ";", "}", ",", "0", ")", ";", "return", "triggerObject", ";", "}" ]

[ "Fires", "an", "event", "asynchronously", ".", "Event", "listeners", "are", "invoked", "on", "the", "next", "tick", "rather", "than", "immediately", "." ]

[ "function", "hasListener", "(", "event", ",", "fn", ")", "{", "return", "listeners", "[", "event", "]", "?", "listeners", "[", "event", "]", ".", "some", "(", "function", "(", "l", ")", "{", "return", "l", "===", "fn", ";", "}", ")", ":", "false", ";", "}" ]

[ "Returns", "whether", "the", "specified", "event", "has", "the", "specified", "listener", "." ]

[ "function", "validCorsPreflight", "(", "request", ")", "{", "if", "(", "request", ".", "method", "===", "'OPTIONS'", "&&", "request", ".", "headers", ".", "has", "(", "'access-control-request-headers'", ")", ")", "{", "return", "request", ".", "headers", ".", "get", "(", "'access-control-request-headers'", ")", ".", "split", "(", "','", ")", ".", "map", "(", "function", "(", "header", ")", "{", "return", "header", ".", "trim", "(", ")", ";", "}", ")", ".", "includes", "(", "'authorization'", ")", ";", "}", "else", "{", "return", "false", ";", "}", "}" ]

[ "Checks", "if", "an", "OPTIONS", "request", "with", "the", "access", "-", "control", "-", "request", "-", "headers", "containing", "authorization", "is", "being", "made" ]

[ "function", "getTokenFromHeader", "(", "request", ")", "{", "if", "(", "!", "request", ".", "headers", "||", "!", "request", ".", "headers", ".", "has", "(", "'authorization'", ")", ")", "{", "throw", "new", "UnauthorizedError", "(", "'No authorization header present'", ")", ";", "}", "const", "parts", "=", "request", ".", "headers", ".", "get", "(", "'authorization'", ")", ".", "split", "(", "\" \"", ")", ";", "if", "(", "parts", ".", "length", "===", "2", ")", "{", "const", "scheme", "=", "parts", "[", "0", "]", ";", "const", "credentials", "=", "parts", "[", "1", "]", ";", "if", "(", "/", "^Bearer$", "/", "i", ".", "test", "(", "scheme", ")", ")", "{", "return", "credentials", ";", "}", "else", "{", "throw", "new", "UnauthorizedError", "(", "'Bad Authorization header format. Format is \"Authorization: Bearer token\"'", ")", ";", "}", "}", "else", "{", "throw", "new", "UnauthorizedError", "(", "'Bad Authorization header format. Format is \"Authorization: Bearer token\"'", ")", ";", "}", "}" ]

[ "Retrieves", "the", "JWT", "from", "the", "authorization", "header" ]

[ "function", "myParser", "(", "size", ")", "{", "if", "(", "typeof", "size", "!==", "'number'", ")", "throw", "new", "Error", "(", "'Invalid block size: '", "+", "size", ")", "function", "isEnd", "(", ")", "{", "return", "atok", ".", "ending", "?", "atok", ".", "length", "-", "atok", ".", "offset", ":", "-", "1", "}", "atok", ".", "trim", "(", ")", ".", "addRule", "(", "size", ",", "function", "(", "data", ")", "{", "self", ".", "emit", "(", "'data'", ",", "data", ")", "}", ")", ".", "addRule", "(", "''", ",", "isEnd", ",", "function", "(", "data", ")", "{", "var", "len", "=", "data", ".", "length", "if", "(", "typeof", "data", "===", "'string'", ")", "{", "var", "lastBlock", "=", "data", "+", "new", "Array", "(", "size", "-", "len", "+", "1", ")", ".", "join", "(", "'0'", ")", "}", "else", "{", "var", "lastBlock", "=", "new", "Buffer", "(", "size", ")", "lastBlock", ".", "fill", "(", "0", ",", "len", ")", "data", ".", "copy", "(", "lastBlock", ",", "0", ")", "}", "self", ".", "emit", "(", "'data'", ",", "lastBlock", ")", "}", ")", ".", "on", "(", "'end'", ",", "function", "(", ")", "{", "self", ".", "emit", "(", "'end'", ")", "}", ")", "}" ]

[ "Stream", "data", "in", "blocks" ]

[ "function", "getArrayFromRange", "(", "l", ",", "h", ",", "s", ")", "{", "var", "a", "=", "[", "]", ";", "s", "=", "s", "||", "1", ";", "for", "(", "var", "i", "=", "l", ";", "i", "<", "h", ";", "i", "+=", "s", ")", "{", "a", ".", "push", "(", "i", ")", ";", "}", "return", "a", ";", "}" ]

[ "Returns", "an", "array", "of", "integers", "from", "a", "starting", "number", "to", "another", "number", "with", "steps", "." ]

[ "function", "handleMasterPayload", "(", "payload", ")", "{", "// Parse and validate received payload.", "if", "(", "(", "payload", "=", "utils", ".", "parsePayload", "(", "payload", ")", ")", "===", "null", ")", "return", "// Notify all workers except the worker who emitted the event.", "sendPayload", ".", "call", "(", "this", ",", "payload", ")", "}" ]

[ "handleMasterPayload", "handles", "the", "payload", "recieved", "by", "the", "master", "process", ".", "If", "payload", "is", "valid", "it", "is", "echoed", "back", "to", "all", "workers", ".", "Note", "that", "unlike", "the", "handleWorkerPayload", "the", "listeners", "of", "the", "instance", "won", "t", "be", "notified", "." ]

[ "function", "handleWorkerPayload", "(", "payload", ")", "{", "// Parse and validate received payload.", "if", "(", "(", "payload", "=", "utils", ".", "parsePayload", "(", "payload", ")", ")", "===", "null", ")", "return", "// If the master is configured to echo events to its own master, the event", "// emitted by the worker should be echoed to the master.", "if", "(", "this", ".", "__echoEvents", "===", "true", ")", "{", "const", "echoPayload", "=", "JSON", ".", "parse", "(", "JSON", ".", "stringify", "(", "payload", ")", ")", "// Update PID as if the payload is originating from this process, the master", "// is in. If this is not done, the master of this process, will resend the", "// payload since the PID is different.", "echoPayload", "[", "fields", ".", "pid", "]", "=", "process", ".", "pid", "process", ".", "send", "(", "echoPayload", ")", "}", "// Unmarshal args.", "payload", "[", "fields", ".", "args", "]", "=", "marshaller", ".", "unmarshal", "(", "payload", "[", "fields", ".", "args", "]", ")", "// Notify instance listeners.", "events", ".", "prototype", ".", "emit", ".", "call", "(", "this", ",", "payload", "[", "fields", ".", "event", "]", ",", "...", "payload", "[", "fields", ".", "args", "]", ")", "// Notify all workers except the worker who emitted the event.", "sendPayload", ".", "call", "(", "this", ",", "payload", ")", "}" ]

[ "handleWorkerPayload", "handles", "the", "payload", "received", "by", "a", "worker", ".", "If", "payload", "is", "valid", "it", "is", "echoed", "back", "to", "all", "workers", "except", "the", "worker", "that", "it", "was", "received", "from", "." ]

[ "function", "getModels", "(", "done", ")", "{", "if", "(", "models", ")", "{", "return", "done", "(", "models", ")", ";", "}", "return", "orm", ".", "initialize", "(", "ormConfig", ",", "function", "(", "err", ",", "m", ")", "{", "if", "(", "err", ")", "{", "throw", "err", ";", "}", "// make the models available as soon as possible for other functions", "models", "=", "m", ";", "// ignore error if groups already created", "let", "catcher", "=", "(", "createErr", ")", "=>", "{", "if", "(", "createErr", "&&", "createErr", ".", "code", "!==", "\"E_VALIDATION\"", ")", "{", "throw", "createErr", ";", "}", "}", ";", "// create the administrators group", "createGroup", "(", "\"admin\"", ",", "catcher", ")", ";", "// create the public group", "createGroup", "(", "\"public\"", ",", "catcher", ")", ";", "return", "done", "(", "models", ")", ";", "}", ")", ";", "}" ]

[ "return", "models", ".", "It", "initializes", "Waterfall", "if", "not", "yet", "initialized", "in", "this", "process", "." ]

[ "function", "createGroup", "(", "name", ",", "done", ")", "{", "return", "getModels", "(", "function", "(", "m", ")", "{", "return", "m", ".", "collections", ".", "group", ".", "create", "(", "{", "name", "}", ",", "done", ")", ";", "}", ")", ";", "}" ]

[ "Create", "a", "new", "group" ]

[ "function", "getGroup", "(", "name", ",", "done", ")", "{", "return", "getModels", "(", "function", "(", "m", ")", "{", "return", "m", ".", "collections", ".", "group", ".", "findOne", "(", "{", "name", "}", ")", ".", "populate", "(", "\"members\"", ")", ".", "populate", "(", "\"leaders\"", ")", ".", "exec", "(", "done", ")", ";", "}", ")", ";", "}" ]

[ "Get", "a", "group", ".", "It", "populates", "the", "members", "and", "leaders", "automatically", "." ]

[ "function", "getGroups", "(", "done", ")", "{", "return", "getModels", "(", "function", "(", "m", ")", "{", "return", "m", ".", "collections", ".", "group", ".", "find", "(", ")", ".", "exec", "(", "done", ")", ";", "}", ")", ";", "}" ]

[ "Get", "all", "groups", ".", "Members", "and", "leaders", "are", "not", "loaded", "automatically", ".", "This", "is", "by", "design", ";", "avoid", "too", "much", "data", "fetching", "." ]

[ "function", "deleteGroup", "(", "name", ",", "done", ")", "{", "return", "getGroup", "(", "name", ",", "function", "(", "getGroupErr", ",", "group", ")", "{", "if", "(", "getGroupErr", ")", "{", "return", "done", "(", "getGroupErr", ")", ";", "}", "if", "(", "!", "group", ")", "{", "return", "done", "(", "new", "Error", "(", "`", "${", "name", "}", "`", ")", ")", ";", "}", "return", "group", ".", "destroy", "(", "done", ")", ";", "}", ")", ";", "}" ]

[ "Delete", "a", "group" ]