Datasets:

---

CM

/

codexglue_code2text_javascript

like 12

[ "function", "processNode", "(", "{", "rawNode", ",", "parsedNode", ",", "parentId", "=", "resourceId", ",", "cursor", ",", "refChain", ",", "prop", "}", ")", "{", "logger", ".", "info", "(", "`", "${", "cursor", "}", "${", "prop", "?", "'('", "+", "prop", "+", "')'", ":", "''", "}", "${", "refChain", "}", "`", ")", "const", "currentId", "=", "options", ".", "urlBaseKey", "&&", "rawNode", "[", "options", ".", "urlBaseKey", "]", "?", "parseRef", "(", "rawNode", "[", "options", ".", "urlBaseKey", "]", ",", "parentId", ")", ".", "fullUrl", ":", "parentId", "const", "props", "=", "!", "!", "prop", "?", "[", "prop", "]", ":", "Object", ".", "getOwnPropertyNames", "(", "rawNode", ")", "let", "propIndex", "=", "-", "1", ",", "nodeChanged", "=", "0", "return", "new", "Promise", "(", "(", "accept", ",", "reject", ")", "=>", "{", "nextProp", "(", ")", "function", "nextProp", "(", ")", "{", "propIndex", "++", "if", "(", "propIndex", ">=", "props", ".", "length", ")", "{", "if", "(", "!", "!", "prop", ")", "{", "accept", "(", "parsedNode", "[", "prop", "]", ")", "}", "else", "{", "accept", "(", "nodeChanged", "?", "parsedNode", ":", "rawNode", ")", "}", "}", "else", "{", "const", "prop", "=", "props", "[", "propIndex", "]", "const", "sourceValue", "=", "rawNode", "[", "prop", "]", "const", "propCursor", "=", "`", "${", "cursor", "}", "${", "prop", "}", "`", "// If prop is already defined in parsedNode assume complete and skip it", "if", "(", "parsedNode", ".", "hasOwnProperty", "(", "prop", ")", ")", "{", "nodeChanged", "|=", "parsedNode", "[", "prop", "]", "!==", "sourceValue", "nextProp", "(", ")", "}", "// Is scalar, just set same and continue", "else", "if", "(", "typeof", "sourceValue", "!==", "'object'", "||", "sourceValue", "===", "null", ")", "{", "parsedNode", "[", "prop", "]", "=", "sourceValue", "nextProp", "(", ")", "}", "// prop is a reference", "else", "if", "(", "!", "!", "sourceValue", ".", "$ref", ")", "{", "const", "{", "$ref", ",", "...", "params", "}", "=", "sourceValue", "const", "branchRefChain", "=", "[", "...", "refChain", ",", "propCursor", "]", "const", "{", "url", ",", "pointer", ",", "isLocalRef", ",", "isCircular", "}", "=", "parseRef", "(", "$ref", ",", "currentId", ",", "branchRefChain", ")", "//, options.vars)", "if", "(", "!", "url", ")", "throw", "new", "Error", "(", "`", "${", "$ref", "}", "`", ")", "if", "(", "isCircular", "&&", "options", ".", "skipCircular", "||", "isLocalRef", "&&", "externalOnly", ")", "{", "// if(isLocalRef && externalOnly) {", "parsedNode", "[", "prop", "]", "=", "sourceValue", "nextProp", "(", ")", "}", "else", "{", "Promise", ".", "resolve", "(", "isLocalRef", "?", "solvePointer", "(", "pointer", ",", "branchRefChain", ",", "currentId", ")", ":", "externalOnly", "&&", "pointer", "?", "processResource", "(", "url", ",", "pointer", ",", "branchRefChain", ",", "false", ")", ":", "processResource", "(", "url", ",", "pointer", ",", "branchRefChain", ")", ")", ".", "then", "(", "newValue", "=>", "{", "nodeChanged", "=", "1", "parsedNode", "[", "prop", "]", "=", "newValue", "nextProp", "(", ")", "}", ")", ".", "catch", "(", "err", "=>", "{", "const", "log", "=", "`", "${", "cursor", "}", "${", "prop", "}", "`", "if", "(", "options", ".", "failOnMissing", ")", "{", "reject", "(", "log", ")", "}", "else", "{", "logger", ".", "info", "(", "log", ")", "parsedNode", "[", "prop", "]", "=", "sourceValue", "nextProp", "(", ")", "}", "}", ")", "}", "}", "else", "{", "const", "placeholder", "=", "parsedNode", "[", "prop", "]", "=", "Array", ".", "isArray", "(", "sourceValue", ")", "?", "[", "]", ":", "{", "}", "processNode", "(", "{", "rawNode", ":", "sourceValue", ",", "parsedNode", ":", "placeholder", ",", "parentId", ":", "currentId", ",", "cursor", ":", "propCursor", ",", "refChain", "}", ")", ".", "then", "(", "newValue", "=>", "{", "nodeChanged", "|=", "newValue", "!==", "sourceValue", "nextProp", "(", ")", "}", ")", ".", "catch", "(", "reject", ")", "}", "}", "}", "}", ")", "}" ]

[ "Main", "recursive", "traverse", "function" ]

[ "function", "getAll", "(", "name", ",", "deploy", ",", "fn", ",", "single", ")", "{", "getTree", "(", "name", ",", "deploy", ",", "function", "(", "err", ",", "tree", ")", "{", "if", "(", "err", ")", "return", "fn", "(", "err", ")", ";", "var", "acc", "=", "[", "]", ";", "flatten", "(", "tree", ",", "acc", ")", ";", "if", "(", "acc", ".", "length", "===", "0", ")", "return", "fn", "(", "null", ")", ";", "if", "(", "single", "&&", "acc", ".", "length", "===", "1", ")", "return", "fn", "(", "null", ",", "acc", "[", "0", "]", ")", ";", "fn", "(", "err", ",", "acc", ")", ";", "}", ")", ";", "}" ]

[ "concats", "have", "to", "go", "all", "the", "way", "down", "the", "chain", "overrides", "work", "backwards", "and", "stop", "at", "first", "definition" ]

[ "function", "(", "portKey", ")", "{", "var", "result", "=", "this", ".", "isValidPort", "(", "portKey", ")", "?", "tessel", ".", "port", "[", "this", ".", "validLEDNames", ".", "indexOf", "(", "portKey", ")", "]", ":", "null", ";", "return", "result", ";", "}" ]

[ "Return", "the", "Tessel", "port", "if", "the", "given", "portKey", "is", "valid", ";", "otherwise", "return", "null", "." ]

[ "function", "(", "ledName", ")", "{", "var", "result", "=", "this", ".", "isValidLEDName", "(", "ledName", ")", "?", "tessel", ".", "port", "[", "this", ".", "validLEDNames", ".", "indexOf", "(", "ledName", ")", "]", ":", "null", ";", "return", "result", ";", "}" ]

[ "Return", "the", "Tessel", "LED", "if", "the", "given", "LED", "name", "is", "valid", ";", "otherwise", "return", "null", "." ]

[ "function", "(", "startState", ")", "{", "let", "dfa", "=", "new", "DFA", "(", ")", ";", "let", "stateMap", "=", "{", "}", ";", "let", "epsilonNFASetCache", "=", "{", "}", ";", "// NFA-set -> NFA-set", "let", "startOrigin", "=", "{", "[", "startState", "]", ":", "1", "}", ";", "let", "start", "=", "this", ".", "epsilonClosure", "(", "startOrigin", ")", ";", "epsilonNFASetCache", "[", "hashNFAStates", "(", "startOrigin", ")", "]", "=", "start", ";", "let", "dfaStates", "=", "{", "}", ",", "newAdded", "=", "[", "]", ";", "let", "last", "=", "0", ",", "offset", "=", "0", ";", "// distance between last state and current state", "dfaStates", "[", "hashNFAStates", "(", "start", ")", "]", "=", "0", ";", "// default, the start state for DFA is 0", "stateMap", "[", "0", "]", "=", "start", ";", "newAdded", ".", "push", "(", "start", ")", ";", "while", "(", "newAdded", ".", "length", ")", "{", "let", "newAddedTmp", "=", "[", "]", ";", "for", "(", "let", "i", "=", "0", ",", "n", "=", "newAdded", ".", "length", ";", "i", "<", "n", ";", "i", "++", ")", "{", "let", "stateSet", "=", "newAdded", "[", "i", "]", ";", "let", "newMap", "=", "this", ".", "_getNFASetTransitionMap", "(", "stateSet", ")", ";", "let", "currentDFAState", "=", "i", "+", "offset", ";", "for", "(", "let", "letter", "in", "newMap", ")", "{", "let", "toSet", "=", "newMap", "[", "letter", "]", ";", "let", "hashKey", "=", "hashNFAStates", "(", "toSet", ")", ";", "// find new state", "let", "newItem", "=", "null", ";", "if", "(", "epsilonNFASetCache", "[", "hashKey", "]", ")", "{", "newItem", "=", "epsilonNFASetCache", "[", "hashKey", "]", ";", "}", "else", "{", "newItem", "=", "this", ".", "epsilonClosure", "(", "newMap", "[", "letter", "]", ")", ";", "}", "let", "newItemHashKey", "=", "hashNFAStates", "(", "newItem", ")", ";", "//", "if", "(", "dfaStates", "[", "newItemHashKey", "]", "!==", "undefined", ")", "{", "dfa", ".", "addTransition", "(", "currentDFAState", ",", "letter", ",", "dfaStates", "[", "newItemHashKey", "]", ")", ";", "}", "else", "{", "// find new item", "last", "++", ";", "// last + 1 as new DFA state", "dfaStates", "[", "newItemHashKey", "]", "=", "last", ";", "stateMap", "[", "last", "]", "=", "newItem", ";", "newAddedTmp", ".", "push", "(", "newItem", ")", ";", "// build the connection from (index + offset) -> last", "dfa", ".", "addTransition", "(", "currentDFAState", ",", "letter", ",", "last", ")", ";", "}", "}", "}", "offset", "+=", "newAdded", ".", "length", ";", "newAdded", "=", "newAddedTmp", ";", "}", "return", "{", "dfa", ",", "stateMap", "}", ";", "}" ]

[ "generate", "a", "new", "DFA", "and", "record", "which", "nfa", "states", "composed", "to", "a", "new", "DFA", "state" ]

[ "function", "virtualForm", "(", "h", ",", "opts", ",", "arr", ")", "{", "if", "(", "!", "arr", ")", "{", "arr", "=", "opts", "opts", "=", "{", "}", "}", "assert", ".", "equal", "(", "typeof", "h", ",", "'function'", ")", "assert", ".", "equal", "(", "typeof", "opts", ",", "'object'", ")", "assert", ".", "ok", "(", "Array", ".", "isArray", "(", "arr", ")", ",", "'is array'", ")", "return", "arr", ".", "map", "(", "function", "createInput", "(", "val", ")", "{", "if", "(", "typeof", "val", "===", "'string'", ")", "{", "val", "=", "{", "type", ":", "'text'", ",", "name", ":", "val", "}", "}", "if", "(", "!", "val", ".", "value", ")", "val", ".", "value", "=", "''", "assert", ".", "equal", "(", "typeof", "val", ",", "'object'", ")", "if", "(", "opts", ".", "label", ")", "{", "if", "(", "val", ".", "type", "===", "'submit'", ")", "return", "h", "(", "'input'", ",", "val", ")", "return", "h", "(", "'fieldset'", ",", "[", "h", "(", "'label'", ",", "[", "val", ".", "name", "]", ")", ",", "h", "(", "'input'", ",", "val", ")", "]", ")", "}", "if", "(", "val", ".", "type", "!==", "'submit'", "&&", "!", "val", ".", "placeholder", ")", "{", "val", ".", "placeholder", "=", "val", ".", "name", "}", "return", "h", "(", "'input'", ",", "val", ")", "}", ")", "}" ]

[ "Create", "a", "virtual", "-", "dom", "form", "null", "-", ">", "null" ]

[ "function", "cleanRedundantCode", "(", "str", ",", "opts", ")", "{", "opts", "=", "opts", "||", "{", "}", ";", "var", "minimize", "=", "def", "(", "opts", ".", "minimize", ",", "true", ")", ";", "var", "comments", "=", "opts", ".", "comments", "||", "{", "}", ";", "var", "htmlComments", "=", "comments", ".", "html", ",", "rglComments", "=", "comments", ".", "rgl", ";", "if", "(", "minimize", "&&", "typeof", "str", "===", "'string'", ")", "{", "var", "SINGLE_SPACE", "=", "' '", ";", "var", "EMPTY", "=", "''", ";", "// remove html-comments <!-- xxx -->", "str", "=", "!", "htmlComments", "?", "str", ".", "replace", "(", "/", "<!-[\\s\\S]*?-->", "/", "g", ",", "EMPTY", ")", ":", "str", ";", "// remove regular-comments {! xxx !}", "str", "=", "!", "rglComments", "?", "str", ".", "replace", "(", "/", "{![\\s\\S]*?!}", "/", "g", ",", "EMPTY", ")", ":", "str", ";", "// 暴力全局替换\\s，副作用：内容里面有带空格或回车的字符串会被替换截掉", "// str = str.replace(/[\\s]{2,}/g, SINGLE_SPACE);", "str", "=", "str", ".", "replace", "(", "/", "[\\f\\t\\v]{2,}", "/", "g", ",", "SINGLE_SPACE", ")", ";", "// // <abc>,<abc/> 左边", "// str = str.replace(/[\\s]{2,}(?=<\\w+(\\s[\\s\\S]*?)*?\\/?>)/g, SINGLE_SPACE);", "// // </abc> 左边", "// str = str.replace(/[\\s]{2,}(?=<\\/\\w+>)/g, SINGLE_SPACE);", "//", "// // js并不支持'后行断言'(?<=condition)这种写法，这里只能采用callback函数来弥补", "//", "// // <abc>,</abc>,<abc/>,/> 右边", "// str = str.replace(/((?:<\\/?\\w+>)|(?:<\\w+\\/>)|(?:\\/>))[\\s]{2,}/g, function($0, $1){", "// return ($1 ? ($ + SINGLE_SPACE) : $0);", "// });", "// // 花括号左右", "// str = str.replace(/[\\s]+(?=(}|\\{))/g, SINGLE_SPACE); // 左空格", "// str = str.replace(/(}|\\{)(\\s+)/g, function($0, $1){ // 右空格", "// return $1 + SINGLE_SPACE;", "// });", "// // 大小于等号左右", "// str = str.replace(/[\\s]+(?=(>|<))/g, SINGLE_SPACE); // 左空格", "// str = str.replace(/(>|<)(\\s+)/g, function($0, $1){ // 右空格", "// return $1 + SINGLE_SPACE;", "// });", "// Last, trim", "str", "=", "str", ".", "trim", "(", ")", ";", "}", "return", "str", ";", "}" ]

[ "pure", "regEx", "to", "resolve", "it", "not", "via", "a", "parser", ";" ]

[ "function", "getCache", "(", "pkg", ",", "config", ")", "{", "pkg", "=", "toPkg", "(", "pkg", ")", "if", "(", "config", "&&", "config", ".", "cacheHash", ")", "return", "path", ".", "join", "(", "config", ".", "cache", ",", "pkg", ".", "shasum", ",", "'package.tgz'", ")", "return", "path", ".", "join", "(", "config", ".", "cache", "||", "path", ".", "join", "(", "process", ".", "env", ".", "HOME", ",", "'.npm'", ")", ",", "pkg", ".", "name", ",", "pkg", ".", "version", ",", "'package.tgz'", ")", "}" ]

[ "Would", "be", "better", "to", "store", "the", "tarball", "as", "it", "s", "hash", "not", "it", "s", "version", ".", "that", "would", "allow", "exact", "shrinkwraps", ".", "Probably", "want", "to", "fallback", "to", "getting", "the", "other", "cache", "for", "speed", ".", "But", "to", "pull", "down", "new", "deps", "...", "Also", "...", "hashes", "would", "allow", "peer", "to", "peer", "module", "hosting", "and", "multiple", "repos", "..." ]

[ "function", "get", "(", "url", ",", "cb", ")", "{", "var", "urls", "=", "[", "]", ",", "end", "_get", "(", "url", ",", "cb", ")", "function", "_get", "(", "url", ")", "{", "urls", ".", "push", "(", "url", ")", "if", "(", "end", ")", "return", "if", "(", "urls", ".", "length", ">", "5", ")", "cb", "(", "end", "=", "new", "Error", "(", "'too many redirects\\n'", "+", "JSON", ".", "stringify", "(", "urls", ")", ")", ")", "console", ".", "error", "(", "'GET'", ",", "url", ")", ";", "(", "/", "^https", "/", ".", "test", "(", "url", ")", "?", "https", ":", "http", ")", ".", "get", "(", "url", ",", "function", "next", "(", "res", ")", "{", "if", "(", "res", ".", "statusCode", ">=", "300", "&&", "res", ".", "statusCode", "<", "400", ")", "_get", "(", "res", ".", "headers", ".", "location", ")", "else", "{", "end", "=", "true", ",", "cb", "(", "null", ",", "res", ")", "}", "}", ")", ".", "on", "(", "'error'", ",", "function", "(", "err", ")", "{", "if", "(", "!", "end", ")", "cb", "(", "end", "=", "err", ")", "}", ")", "}", "}" ]

[ "pull", "a", "package", "from", "the", "registry" ]

[ "function", "getTarballStream", "(", "pkg", ",", "config", ",", "cb", ")", "{", "if", "(", "config", ".", "casDb", "&&", "pkg", ".", "shasum", ")", "{", "var", "db", "=", "config", ".", "casDb", "db", ".", "has", "(", "pkg", ".", "shasum", ",", "function", "(", "err", ",", "stat", ")", "{", "if", "(", "!", "err", ")", "cb", "(", "null", ",", "db", ".", "getStream", "(", "pkg", ".", "shasum", ")", ")", "else", "//fallback to the old way...", "tryCache", "(", ")", "}", ")", "}", "else", "tryCache", "(", ")", "function", "tryCache", "(", ")", "{", "var", "cache", "=", "getCache", "(", "pkg", ",", "config", ")", "fs", ".", "stat", "(", "cache", ",", "function", "(", "err", ")", "{", "if", "(", "!", "err", ")", "cb", "(", "null", ",", "fs", ".", "createReadStream", "(", "cache", ")", ")", "else", "getDownload", "(", "pkg", ",", "config", ",", "cb", ")", "}", ")", "}", "}" ]

[ "stream", "a", "tarball", "-", "either", "from", "cache", "or", "registry" ]

[ "function", "getTmp", "(", "config", ")", "{", "return", "path", ".", "join", "(", "config", ".", "tmpdir", "||", "'/tmp'", ",", "''", "+", "Date", ".", "now", "(", ")", "+", "Math", ".", "random", "(", ")", ")", "}" ]

[ "unpack", "a", "tarball", "to", "some", "target", "directory", ".", "recommend", "unpacking", "to", "tmpdir", "and", "then", "moving", "a", "following", "step", ".", "ALSO", "should", "hash", "the", "file", "as", "we", "unpack", "it", "and", "validate", "that", "we", "get", "the", "correct", "hash", "." ]

[ "function", "mixin", "(", "source", ")", "{", "var", "keys", "=", "[", "]", ";", "if", "(", "arguments", ".", "length", ">", "1", ")", "{", "for", "(", "var", "i", "=", "1", ",", "len", "=", "arguments", ".", "length", ";", "i", "<", "len", ";", "i", "++", ")", "{", "var", "key", "=", "arguments", "[", "i", "]", ";", "if", "(", "!", "source", ".", "hasOwnProperty", "(", "key", ")", ")", "{", "throw", "new", "Error", "(", "util", ".", "format", "(", "'Property not found: %s'", ",", "key", ")", ")", ";", "}", "keys", ".", "push", "(", "key", ")", ";", "}", "}", "else", "{", "keys", "=", "Object", ".", "keys", "(", "source", ")", ";", "}", "// Copy.", "for", "(", "var", "i", "=", "0", ",", "len", "=", "keys", ".", "length", ";", "i", "<", "len", ";", "i", "++", ")", "{", "key", "=", "keys", "[", "i", "]", ";", "defineProp", "(", "this", ",", "key", ",", "descriptor", "(", "source", ",", "key", ")", ")", ";", "}", "return", "this", ";", "}" ]

[ "The", "common", "mixin", "simply", "copies", "properties", "by", "redefining", "the", "same", "properties", "from", "the", "source", "." ]

[ "function", "subst", "(", "str", ",", "file", ",", "dst", ")", "{", "if", "(", "dst", "!==", "undefined", ")", "{", "str", "=", "str", ".", "replace", "(", "/", "\\{\\{DST\\}\\}", "/", "g", ",", "dst", ")", ";", "}", "var", "dir", "=", "path", ".", "dirname", "(", "file", ")", ";", "str", "=", "str", ".", "replace", "(", "/", "\\{\\{SRC\\}\\}", "/", "g", ",", "file", ")", ";", "var", "name", "=", "path", ".", "basename", "(", "file", ")", ";", "str", "=", "str", ".", "replace", "(", "/", "\\{\\{NAME\\}\\}", "/", "g", ",", "name", ")", ";", "name", "=", "name", ".", "replace", "(", "/", "\\.\\w+$", "/", ",", "''", ")", ";", "str", "=", "str", ".", "replace", "(", "/", "\\{\\{BASENAME\\}\\}", "/", "g", ",", "name", ")", ";", "str", "=", "str", ".", "replace", "(", "/", "\\{\\{DIR\\}\\}", "/", "g", ",", "dir", ")", ";", "var", "parts", "=", "dir", ".", "split", "(", "path", ".", "sep", ")", ";", "parts", ".", "splice", "(", "0", ",", "1", ")", ";", "str", "=", "str", ".", "replace", "(", "/", "\\{\\{SUBDIR\\}\\}", "/", "g", ",", "path", ".", "join", ".", "apply", "(", "null", ",", "parts", ")", ")", ";", "parts", ".", "splice", "(", "0", ",", "1", ")", ";", "str", "=", "str", ".", "replace", "(", "/", "\\{\\{SUBSUBDIR\\}\\}", "/", "g", ",", "path", ".", "join", ".", "apply", "(", "null", ",", "parts", ")", ")", ";", "return", "str", ";", "}" ]

[ "Support", "function", "to", "substitute", "path", "variables", "." ]

[ "function", "(", "request", ",", "response", ",", "next", ")", "{", "if", "(", "utils", ".", "Misc", ".", "isEmptyObject", "(", "request", ".", "query", ")", ")", "{", "var", "errApp", "=", "new", "Error", "(", "errors", "[", "'130'", "]", ")", ";", "response", ".", "end", "(", "utils", ".", "Misc", ".", "createResponse", "(", "null", ",", "errApp", ",", "130", ")", ")", ";", "}", "else", "{", "next", "(", ")", ";", "}", "}" ]

[ "checks", "to", "be", "sure", "a", "criterion", "was", "specified", "for", "a", "bulk", "update", "operation" ]

[ "function", "(", "request", ",", "response", ",", "next", ")", "{", "if", "(", "!", "utils", ".", "Misc", ".", "isNullOrUndefined", "(", "request", ".", "user", ")", ")", "{", "next", "(", ")", ";", "}", "else", "{", "var", "error", "=", "new", "Error", "(", "errors", "[", "'213'", "]", ")", ";", "response", ".", "end", "(", "utils", ".", "Misc", ".", "createResponse", "(", "null", ",", "error", ",", "213", ")", ")", ";", "}", "}" ]

[ "checks", "for", "logged", "-", "in", "user" ]

[ "function", "(", "request", ",", "response", ",", "next", ")", "{", "if", "(", "!", "utils", ".", "Misc", ".", "isNullOrUndefined", "(", "request", ".", "user", ")", "||", "request", ".", "originalUrl", "==", "'/error'", "||", "request", ".", "originalUrl", ".", "indexOf", "(", "'/error?'", ")", "==", "0", ")", "{", "next", "(", ")", ";", "}", "else", "{", "var", "success", "=", "encodeURIComponent", "(", "request", ".", "protocol", "+", "'://'", "+", "request", ".", "get", "(", "'host'", ")", "+", "request", ".", "originalUrl", ")", ";", "response", ".", "redirect", "(", "'/login?success='", "+", "success", "+", "'&no_query=true'", ")", ";", "//we don't want it to add any query string", "}", "}" ]

[ "checks", "for", "logged", "-", "in", "UI", "user" ]

[ "function", "(", "request", ",", "response", ",", "next", ")", "{", "var", "apptkn", ";", "if", "(", "!", "utils", ".", "Misc", ".", "isNullOrUndefined", "(", "request", ".", "get", "(", "X_BOLT_APP_TOKEN", ")", ")", ")", "{", "apptkn", "=", "request", ".", "get", "(", "X_BOLT_APP_TOKEN", ")", ";", "}", "else", "{", "var", "error", "=", "new", "Error", "(", "errors", "[", "'110'", "]", ")", ";", "response", ".", "end", "(", "utils", ".", "Misc", ".", "createResponse", "(", "null", ",", "error", ",", "110", ")", ")", ";", "return", ";", "}", "var", "name", "=", "__getAppFromAppToken", "(", "apptkn", ",", "request", ")", ";", "if", "(", "utils", ".", "Misc", ".", "isNullOrUndefined", "(", "name", ")", ")", "{", "var", "error", "=", "new", "Error", "(", "errors", "[", "'113'", "]", ")", ";", "response", ".", "end", "(", "utils", ".", "Misc", ".", "createResponse", "(", "null", ",", "error", ",", "113", ")", ")", ";", "return", ";", "}", "var", "appnm", "=", "utils", ".", "String", ".", "trim", "(", "name", ".", "toLowerCase", "(", ")", ")", ";", "if", "(", "appnm", "==", "'bolt'", ")", "{", "//native views", "next", "(", ")", ";", "}", "else", "{", "models", ".", "app", ".", "findOne", "(", "{", "name", ":", "appnm", ",", "system", ":", "true", "}", ",", "function", "(", "appError", ",", "app", ")", "{", "if", "(", "!", "utils", ".", "Misc", ".", "isNullOrUndefined", "(", "appError", ")", ")", "{", "response", ".", "end", "(", "utils", ".", "Misc", ".", "createResponse", "(", "null", ",", "appError", ")", ")", ";", "}", "else", "if", "(", "utils", ".", "Misc", ".", "isNullOrUndefined", "(", "app", ")", ")", "{", "var", "error", "=", "new", "Error", "(", "errors", "[", "'504'", "]", ")", ";", "response", ".", "end", "(", "utils", ".", "Misc", ".", "createResponse", "(", "null", ",", "error", ",", "504", ")", ")", ";", "}", "else", "{", "next", "(", ")", ";", "}", "}", ")", ";", "}", "}" ]

[ "checks", "to", "be", "sure", "the", "app", "making", "this", "request", "is", "a", "system", "app" ]

[ "function", "(", "request", ",", "response", ",", "next", ")", "{", "var", "apptkn", ";", "if", "(", "!", "utils", ".", "Misc", ".", "isNullOrUndefined", "(", "request", ".", "get", "(", "X_BOLT_APP_TOKEN", ")", ")", ")", "{", "apptkn", "=", "request", ".", "get", "(", "X_BOLT_APP_TOKEN", ")", ";", "}", "else", "{", "var", "error", "=", "new", "Error", "(", "errors", "[", "'110'", "]", ")", ";", "response", ".", "end", "(", "utils", ".", "Misc", ".", "createResponse", "(", "null", ",", "error", ",", "110", ")", ")", ";", "return", ";", "}", "var", "name", "=", "__getAppFromAppToken", "(", "apptkn", ",", "request", ")", ";", "if", "(", "utils", ".", "Misc", ".", "isNullOrUndefined", "(", "name", ")", ")", "{", "var", "error", "=", "new", "Error", "(", "errors", "[", "'113'", "]", ")", ";", "response", ".", "end", "(", "utils", ".", "Misc", ".", "createResponse", "(", "null", ",", "error", ",", "113", ")", ")", ";", "return", ";", "}", "var", "appnm", "=", "utils", ".", "String", ".", "trim", "(", "name", ".", "toLowerCase", "(", ")", ")", ";", "request", ".", "appName", "=", "appnm", ";", "next", "(", ")", ";", "}" ]

[ "gets", "the", "app", "name", "from", "the", "request" ]

[ "function", "(", "request", ",", "response", ",", "next", ")", "{", "if", "(", "!", "utils", ".", "Misc", ".", "isNullOrUndefined", "(", "request", ".", "body", ".", "db", ")", ")", "{", "request", ".", "db", "=", "request", ".", "body", ".", "db", ";", "}", "else", "if", "(", "!", "utils", ".", "Misc", ".", "isNullOrUndefined", "(", "request", ".", "body", ".", "app", ")", ")", "{", "request", ".", "db", "=", "request", ".", "body", ".", "app", ";", "}", "else", "{", "var", "apptkn", ";", "if", "(", "!", "utils", ".", "Misc", ".", "isNullOrUndefined", "(", "request", ".", "get", "(", "X_BOLT_APP_TOKEN", ")", ")", ")", "{", "apptkn", "=", "request", ".", "get", "(", "X_BOLT_APP_TOKEN", ")", ";", "}", "else", "{", "var", "error", "=", "new", "Error", "(", "errors", "[", "'110'", "]", ")", ";", "response", ".", "end", "(", "utils", ".", "Misc", ".", "createResponse", "(", "null", ",", "error", ",", "110", ")", ")", ";", "return", ";", "}", "var", "name", "=", "__getAppFromAppToken", "(", "apptkn", ",", "request", ")", ";", "if", "(", "utils", ".", "Misc", ".", "isNullOrUndefined", "(", "name", ")", ")", "{", "var", "error", "=", "new", "Error", "(", "errors", "[", "'113'", "]", ")", ";", "response", ".", "end", "(", "utils", ".", "Misc", ".", "createResponse", "(", "null", ",", "error", ",", "113", ")", ")", ";", "return", ";", "}", "var", "appnm", "=", "utils", ".", "String", ".", "trim", "(", "name", ".", "toLowerCase", "(", ")", ")", ";", "request", ".", "db", "=", "appnm", ";", "}", "if", "(", "request", ".", "db", ".", "indexOf", "(", "'/'", ")", ">", "-", "1", "||", "request", ".", "db", ".", "indexOf", "(", "'\\\\'", ")", ">", "-", "1", "||", "request", ".", "db", ".", "indexOf", "(", "'?'", ")", ">", "-", "1", "||", "request", ".", "db", ".", "indexOf", "(", "'&'", ")", ">", "-", "1", ")", "{", "//invalid characters in app name", "var", "error", "=", "new", "Error", "(", "errors", "[", "'405'", "]", ")", ";", "response", ".", "end", "(", "utils", ".", "Misc", ".", "createResponse", "(", "null", ",", "error", ",", "405", ")", ")", ";", "return", ";", "}", "next", "(", ")", ";", "}" ]

[ "gets", "the", "DB", "name", "from", "the", "request", "and", "creates", "the", "request", ".", "db", "field", "to", "hold", "the", "value" ]

[ "function", "(", "request", ",", "response", ",", "next", ")", "{", "var", "apptkn", ";", "if", "(", "!", "utils", ".", "Misc", ".", "isNullOrUndefined", "(", "request", ".", "get", "(", "X_BOLT_APP_TOKEN", ")", ")", ")", "{", "apptkn", "=", "request", ".", "get", "(", "X_BOLT_APP_TOKEN", ")", ";", "}", "else", "{", "var", "error", "=", "new", "Error", "(", "errors", "[", "'110'", "]", ")", ";", "response", ".", "end", "(", "utils", ".", "Misc", ".", "createResponse", "(", "null", ",", "error", ",", "110", ")", ")", ";", "return", ";", "}", "var", "name", "=", "__getAppFromAppToken", "(", "apptkn", ",", "request", ")", ";", "if", "(", "utils", ".", "Misc", ".", "isNullOrUndefined", "(", "name", ")", ")", "{", "var", "error", "=", "new", "Error", "(", "errors", "[", "'113'", "]", ")", ";", "response", ".", "end", "(", "utils", ".", "Misc", ".", "createResponse", "(", "null", ",", "error", ",", "113", ")", ")", ";", "return", ";", "}", "var", "appnm", "=", "utils", ".", "String", ".", "trim", "(", "name", ".", "toLowerCase", "(", ")", ")", ";", "var", "dbOwner", "=", "request", ".", "body", ".", "db", "||", "request", ".", "body", ".", "app", "||", "appnm", ";", "models", ".", "collection", ".", "findOne", "(", "{", "name", ":", "request", ".", "params", ".", "collection", ",", "app", ":", "dbOwner", "}", ",", "function", "(", "collError", ",", "collection", ")", "{", "if", "(", "!", "utils", ".", "Misc", ".", "isNullOrUndefined", "(", "collError", ")", ")", "{", "response", ".", "end", "(", "utils", ".", "Misc", ".", "createResponse", "(", "null", ",", "collError", ")", ")", ";", "}", "else", "if", "(", "utils", ".", "Misc", ".", "isNullOrUndefined", "(", "collection", ")", ")", "{", "var", "errColl", "=", "new", "Error", "(", "errors", "[", "'703'", "]", ")", ";", "response", ".", "end", "(", "utils", ".", "Misc", ".", "createResponse", "(", "null", ",", "errColl", ",", "703", ")", ")", ";", "}", "else", "{", "//allow the owner to pass", "if", "(", "appnm", "==", "collection", ".", "app", ".", "toLowerCase", "(", ")", ")", "{", "next", "(", ")", ";", "return", ";", "}", "if", "(", "!", "utils", ".", "Misc", ".", "isNullOrUndefined", "(", "collection", ".", "tenants", ")", ")", "{", "//tenants allowed", "if", "(", "\"*\"", "==", "collection", ".", "tenants", ")", "{", "//every body is allowed", "next", "(", ")", ";", "return", ";", "}", "//there is a tenant list; are u listed?", "else", "if", "(", "collection", ".", "tenants", ".", "map", "(", "function", "(", "value", ")", "{", "return", "value", ".", "toLowerCase", "(", ")", ";", "}", ")", ".", "indexOf", "(", "appnm", ")", ">", "-", "1", ")", "{", "next", "(", ")", ";", "return", ";", "}", "}", "//no guests allowed", "var", "error", "=", "new", "Error", "(", "errors", "[", "'704'", "]", ")", ";", "response", ".", "end", "(", "utils", ".", "Misc", ".", "createResponse", "(", "null", ",", "error", ",", "704", ")", ")", ";", "}", "}", ")", ";", "}" ]

[ "checks", "if", "this", "app", "has", "the", "right", "to", "write", "to", "the", "collection", "in", "the", "database" ]

[ "function", "toBitMask", "(", "event", ")", "{", "if", "(", "!", "_", ".", "has", "(", "eventMap", ",", "event", ")", ")", "{", "throw", "new", "Error", "(", "'Unkown event: '", "+", "event", ")", ";", "}", "return", "eventMap", "[", "event", "]", ";", "}" ]

[ "Convert", "a", "string", "to", "the", "corresponding", "bit", "mask", ".", "event", "-", "String", "Returns", "a", "binary", "number", "." ]

[ "function", "addFlags", "(", "mask", ",", "flags", ")", "{", "if", "(", "flags", ".", "onlydir", ")", "mask", "=", "mask", "|", "Inotify", ".", "IN_ONLYDIR", ";", "if", "(", "flags", ".", "dont_follow", ")", "mask", "=", "mask", "|", "Inotify", ".", "IN_DONT_FOLLOW", ";", "if", "(", "flags", ".", "oneshot", ")", "mask", "=", "mask", "|", "Inotify", ".", "IN_ONESHOT", ";", "return", "mask", ";", "}" ]

[ "Add", "additional", "flags", "to", "a", "given", "mask", ".", "mask", "-", "Number", "flags", "-", "Object", "Returns", "a", "number", "." ]

[ "function", "FABridge__bridgeInitialized", "(", "bridgeName", ")", "{", "var", "objects", "=", "document", ".", "getElementsByTagName", "(", "\"object\"", ")", ";", "var", "ol", "=", "objects", ".", "length", ";", "var", "activeObjects", "=", "[", "]", ";", "if", "(", "ol", ">", "0", ")", "{", "for", "(", "var", "i", "=", "0", ";", "i", "<", "ol", ";", "i", "++", ")", "{", "if", "(", "typeof", "objects", "[", "i", "]", ".", "SetVariable", "!=", "\"undefined\"", ")", "{", "activeObjects", "[", "activeObjects", ".", "length", "]", "=", "objects", "[", "i", "]", ";", "}", "}", "}", "var", "embeds", "=", "document", ".", "getElementsByTagName", "(", "\"embed\"", ")", ";", "var", "el", "=", "embeds", ".", "length", ";", "var", "activeEmbeds", "=", "[", "]", ";", "if", "(", "el", ">", "0", ")", "{", "for", "(", "var", "j", "=", "0", ";", "j", "<", "el", ";", "j", "++", ")", "{", "if", "(", "typeof", "embeds", "[", "j", "]", ".", "SetVariable", "!=", "\"undefined\"", ")", "{", "activeEmbeds", "[", "activeEmbeds", ".", "length", "]", "=", "embeds", "[", "j", "]", ";", "}", "}", "}", "var", "aol", "=", "activeObjects", ".", "length", ";", "var", "ael", "=", "activeEmbeds", ".", "length", ";", "var", "searchStr", "=", "\"bridgeName=\"", "+", "bridgeName", ";", "if", "(", "(", "aol", "==", "1", "&&", "!", "ael", ")", "||", "(", "aol", "==", "1", "&&", "ael", "==", "1", ")", ")", "{", "FABridge", ".", "attachBridge", "(", "activeObjects", "[", "0", "]", ",", "bridgeName", ")", ";", "}", "else", "if", "(", "ael", "==", "1", "&&", "!", "aol", ")", "{", "FABridge", ".", "attachBridge", "(", "activeEmbeds", "[", "0", "]", ",", "bridgeName", ")", ";", "}", "else", "{", "var", "flash_found", "=", "false", ";", "if", "(", "aol", ">", "1", ")", "{", "for", "(", "var", "k", "=", "0", ";", "k", "<", "aol", ";", "k", "++", ")", "{", "var", "params", "=", "activeObjects", "[", "k", "]", ".", "childNodes", ";", "for", "(", "var", "l", "=", "0", ";", "l", "<", "params", ".", "length", ";", "l", "++", ")", "{", "var", "param", "=", "params", "[", "l", "]", ";", "if", "(", "param", ".", "nodeType", "==", "1", "&&", "param", ".", "tagName", ".", "toLowerCase", "(", ")", "==", "\"param\"", "&&", "param", "[", "\"name\"", "]", ".", "toLowerCase", "(", ")", "==", "\"flashvars\"", "&&", "param", "[", "\"value\"", "]", ".", "indexOf", "(", "searchStr", ")", ">=", "0", ")", "{", "FABridge", ".", "attachBridge", "(", "activeObjects", "[", "k", "]", ",", "bridgeName", ")", ";", "flash_found", "=", "true", ";", "break", ";", "}", "}", "if", "(", "flash_found", ")", "{", "break", ";", "}", "}", "}", "if", "(", "!", "flash_found", "&&", "ael", ">", "1", ")", "{", "for", "(", "var", "m", "=", "0", ";", "m", "<", "ael", ";", "m", "++", ")", "{", "var", "flashVars", "=", "activeEmbeds", "[", "m", "]", ".", "attributes", ".", "getNamedItem", "(", "\"flashVars\"", ")", ".", "nodeValue", ";", "if", "(", "flashVars", ".", "indexOf", "(", "searchStr", ")", ">=", "0", ")", "{", "FABridge", ".", "attachBridge", "(", "activeEmbeds", "[", "m", "]", ",", "bridgeName", ")", ";", "break", ";", "}", "}", "}", "}", "return", "true", ";", "}" ]

[ "updated", "for", "changes", "to", "SWFObject2" ]

[ "function", "(", "objRef", ",", "propName", ")", "{", "if", "(", "FABridge", ".", "refCount", ">", "0", ")", "{", "throw", "new", "Error", "(", "\"You are trying to call recursively into the Flash Player which is not allowed. In most cases the JavaScript setTimeout function, can be used as a workaround.\"", ")", ";", "}", "else", "{", "FABridge", ".", "refCount", "++", ";", "retVal", "=", "this", ".", "target", ".", "getPropFromAS", "(", "objRef", ",", "propName", ")", ";", "retVal", "=", "this", ".", "handleError", "(", "retVal", ")", ";", "FABridge", ".", "refCount", "--", ";", "return", "retVal", ";", "}", "}" ]

[ "low", "level", "access", "to", "the", "flash", "object", "get", "a", "named", "property", "from", "an", "AS", "object" ]

[ "function", "(", "objRef", ",", "propName", ",", "value", ")", "{", "if", "(", "FABridge", ".", "refCount", ">", "0", ")", "{", "throw", "new", "Error", "(", "\"You are trying to call recursively into the Flash Player which is not allowed. In most cases the JavaScript setTimeout function, can be used as a workaround.\"", ")", ";", "}", "else", "{", "FABridge", ".", "refCount", "++", ";", "retVal", "=", "this", ".", "target", ".", "setPropInAS", "(", "objRef", ",", "propName", ",", "this", ".", "serialize", "(", "value", ")", ")", ";", "retVal", "=", "this", ".", "handleError", "(", "retVal", ")", ";", "FABridge", ".", "refCount", "--", ";", "return", "retVal", ";", "}", "}" ]

[ "set", "a", "named", "property", "on", "an", "AS", "object" ]

[ "function", "(", "funcID", ",", "args", ")", "{", "if", "(", "FABridge", ".", "refCount", ">", "0", ")", "{", "throw", "new", "Error", "(", "\"You are trying to call recursively into the Flash Player which is not allowed. In most cases the JavaScript setTimeout function, can be used as a workaround.\"", ")", ";", "}", "else", "{", "FABridge", ".", "refCount", "++", ";", "retVal", "=", "this", ".", "target", ".", "invokeASFunction", "(", "funcID", ",", "this", ".", "serialize", "(", "args", ")", ")", ";", "retVal", "=", "this", ".", "handleError", "(", "retVal", ")", ";", "FABridge", ".", "refCount", "--", ";", "return", "retVal", ";", "}", "}" ]

[ "call", "an", "AS", "function" ]

[ "function", "(", "objID", ",", "funcName", ",", "args", ")", "{", "if", "(", "FABridge", ".", "refCount", ">", "0", ")", "{", "throw", "new", "Error", "(", "\"You are trying to call recursively into the Flash Player which is not allowed. In most cases the JavaScript setTimeout function, can be used as a workaround.\"", ")", ";", "}", "else", "{", "FABridge", ".", "refCount", "++", ";", "args", "=", "this", ".", "serialize", "(", "args", ")", ";", "retVal", "=", "this", ".", "target", ".", "invokeASMethod", "(", "objID", ",", "funcName", ",", "args", ")", ";", "retVal", "=", "this", ".", "handleError", "(", "retVal", ")", ";", "FABridge", ".", "refCount", "--", ";", "return", "retVal", ";", "}", "}" ]

[ "call", "a", "method", "on", "an", "AS", "object" ]

[ "function", "(", "funcID", ",", "args", ")", "{", "var", "result", ";", "var", "func", "=", "this", ".", "localFunctionCache", "[", "funcID", "]", ";", "if", "(", "func", "!=", "undefined", ")", "{", "result", "=", "this", ".", "serialize", "(", "func", ".", "apply", "(", "null", ",", "this", ".", "deserialize", "(", "args", ")", ")", ")", ";", "}", "return", "result", ";", "}" ]

[ "callback", "from", "flash", "that", "executes", "a", "local", "JS", "function", "used", "mostly", "when", "setting", "js", "functions", "as", "callbacks", "on", "events" ]

[ "function", "(", "objID", ",", "typeName", ")", "{", "var", "objType", "=", "this", ".", "getTypeFromName", "(", "typeName", ")", ";", "instanceFactory", ".", "prototype", "=", "objType", ";", "var", "instance", "=", "new", "instanceFactory", "(", "objID", ")", ";", "this", ".", "remoteInstanceCache", "[", "objID", "]", "=", "instance", ";", "return", "instance", ";", "}" ]

[ "create", "an", "AS", "proxy", "for", "the", "given", "object", "ID", "and", "type" ]

[ "function", "(", "typeData", ")", "{", "var", "newType", "=", "new", "ASProxy", "(", "this", ",", "typeData", ".", "name", ")", ";", "var", "accessors", "=", "typeData", ".", "accessors", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "accessors", ".", "length", ";", "i", "++", ")", "{", "this", ".", "addPropertyToType", "(", "newType", ",", "accessors", "[", "i", "]", ")", ";", "}", "var", "methods", "=", "typeData", ".", "methods", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "methods", ".", "length", ";", "i", "++", ")", "{", "if", "(", "FABridge", ".", "blockedMethods", "[", "methods", "[", "i", "]", "]", "==", "undefined", ")", "{", "this", ".", "addMethodToType", "(", "newType", ",", "methods", "[", "i", "]", ")", ";", "}", "}", "this", ".", "remoteTypeCache", "[", "newType", ".", "typeName", "]", "=", "newType", ";", "return", "newType", ";", "}" ]

[ "accepts", "a", "type", "structure", "returns", "a", "constructed", "type" ]

[ "function", "(", "ty", ",", "propName", ")", "{", "var", "c", "=", "propName", ".", "charAt", "(", "0", ")", ";", "var", "setterName", ";", "var", "getterName", ";", "if", "(", "c", ">=", "\"a\"", "&&", "c", "<=", "\"z\"", ")", "{", "getterName", "=", "\"get\"", "+", "c", ".", "toUpperCase", "(", ")", "+", "propName", ".", "substr", "(", "1", ")", ";", "setterName", "=", "\"set\"", "+", "c", ".", "toUpperCase", "(", ")", "+", "propName", ".", "substr", "(", "1", ")", ";", "}", "else", "{", "getterName", "=", "\"get\"", "+", "propName", ";", "setterName", "=", "\"set\"", "+", "propName", ";", "}", "ty", "[", "setterName", "]", "=", "function", "(", "val", ")", "{", "this", ".", "bridge", ".", "setPropertyInAS", "(", "this", ".", "fb_instance_id", ",", "propName", ",", "val", ")", ";", "}", "ty", "[", "getterName", "]", "=", "function", "(", ")", "{", "return", "this", ".", "bridge", ".", "deserialize", "(", "this", ".", "bridge", ".", "getPropertyFromAS", "(", "this", ".", "fb_instance_id", ",", "propName", ")", ")", ";", "}", "}" ]

[ "add", "a", "property", "to", "a", "typename", ";", "used", "to", "define", "the", "properties", "that", "can", "be", "called", "on", "an", "AS", "proxied", "object" ]

[ "function", "(", "ty", ",", "methodName", ")", "{", "ty", "[", "methodName", "]", "=", "function", "(", ")", "{", "return", "this", ".", "bridge", ".", "deserialize", "(", "this", ".", "bridge", ".", "callASMethod", "(", "this", ".", "fb_instance_id", ",", "methodName", ",", "FABridge", ".", "argsToArray", "(", "arguments", ")", ")", ")", ";", "}", "}" ]

[ "add", "a", "method", "to", "a", "typename", ";", "used", "to", "define", "the", "methods", "that", "can", "be", "callefd", "on", "an", "AS", "proxied", "object" ]

[ "function", "(", "funcID", ")", "{", "var", "bridge", "=", "this", ";", "if", "(", "this", ".", "remoteFunctionCache", "[", "funcID", "]", "==", "null", ")", "{", "this", ".", "remoteFunctionCache", "[", "funcID", "]", "=", "function", "(", ")", "{", "bridge", ".", "callASFunction", "(", "funcID", ",", "FABridge", ".", "argsToArray", "(", "arguments", ")", ")", ";", "}", "}", "return", "this", ".", "remoteFunctionCache", "[", "funcID", "]", ";", "}" ]

[ "Function", "Proxies", "returns", "the", "AS", "proxy", "for", "the", "specified", "function", "ID" ]

[ "function", "(", "func", ")", "{", "if", "(", "func", ".", "__bridge_id__", "==", "undefined", ")", "{", "func", ".", "__bridge_id__", "=", "this", ".", "makeID", "(", "this", ".", "nextLocalFuncID", "++", ")", ";", "this", ".", "localFunctionCache", "[", "func", ".", "__bridge_id__", "]", "=", "func", ";", "}", "return", "func", ".", "__bridge_id__", ";", "}" ]

[ "reutrns", "the", "ID", "of", "the", "given", "function", ";", "if", "it", "doesnt", "exist", "it", "is", "created", "and", "added", "to", "the", "local", "cache" ]

[ "function", "shadowClose", "(", "connection", ")", "{", "debug", "(", "'shadowClose'", ",", "'start'", ")", ";", "let", "close", "=", "connection", ".", "close", ";", "connection", ".", "close", "=", "function", "(", ")", "{", "debug", "(", "'connection.close'", ",", "'start'", ")", ";", "//remove references", "delete", "promises", "[", "connection", ".", "_mssqlngKey", "]", ";", "delete", "connections", "[", "connection", ".", "_mssqlngKey", "]", ";", "//close original connection", "setImmediate", "(", "(", ")", "=>", "{", "try", "{", "debug", "(", "'connection.close'", ",", "'apply'", ")", ";", "close", ".", "apply", "(", "connection", ")", ";", "debug", "(", "'connection.close'", ",", "'applied'", ")", ";", "//clear local references - allow GC", "close", "=", "null", ";", "connection", "-", "null", ";", "}", "catch", "(", "err", ")", "{", "}", "}", ")", ";", "debug", "(", "'connection.close'", ",", "'end'", ")", ";", "}", "}" ]

[ "shadow", "the", "close", "method", "so", "that", "it", "will", "clear", "itself", "from", "the", "pool" ]

[ "function", "(", "infos", ",", "name", ")", "{", "name", "=", "name", "||", "'jsdoc.json'", ";", "var", "firstFile", "=", "null", ";", "var", "readme", "=", "null", ";", "var", "wp", "=", "new", "Parser", "(", "infos", ")", ";", "var", "bufferFiles", "=", "function", "(", "file", ",", "enc", ",", "next", ")", "{", "if", "(", "file", ".", "isNull", "(", ")", ")", "return", ";", "// ignore\r", "if", "(", "file", ".", "isStream", "(", ")", ")", "return", "this", ".", "emit", "(", "'error'", ",", "new", "PluginError", "(", "'gulp-jsdoc'", ",", "'Streaming not supported'", ")", ")", ";", "// Store firstFile to get a base and cwd later on\r", "if", "(", "!", "firstFile", ")", "firstFile", "=", "file", ";", "if", "(", "/", "[.]js$", "/", "i", ".", "test", "(", "file", ".", "path", ")", ")", "wp", ".", "parse", "(", "file", ")", ";", "else", "if", "(", "/", "readme(?:[.]md)?$", "/", "i", ".", "test", "(", "file", ".", "path", ")", ")", "readme", "=", "marked", "(", "file", ".", "contents", ".", "toString", "(", "'utf8'", ")", ")", ";", "next", "(", ")", ";", "}", ";", "var", "endStream", "=", "function", "(", "conclude", ")", "{", "// Nothing? Exit right away\r", "if", "(", "!", "firstFile", ")", "{", "conclude", "(", ")", ";", "return", ";", "}", "var", "data", ";", "try", "{", "data", "=", "JSON", ".", "stringify", "(", "wp", ".", "complete", "(", ")", ",", "null", ",", "2", ")", ";", "// data = parser(options, filemap));\r", "}", "catch", "(", "e", ")", "{", "return", "this", ".", "emit", "(", "'error'", ",", "new", "PluginError", "(", "'gulp-jsdoc'", ",", "'Oooooh! Failed parsing with jsdoc. What did you do?! '", "+", "e", ")", ")", ";", "}", "// Pump-up the generated output\r", "var", "vinyl", "=", "new", "File", "(", "{", "cwd", ":", "firstFile", ".", "cwd", ",", "base", ":", "firstFile", ".", "base", ",", "path", ":", "path", ".", "join", "(", "firstFile", ".", "base", ",", "name", ")", ",", "contents", ":", "new", "Buffer", "(", "data", ")", "}", ")", ";", "// Possibly stack-up the readme, if there was any in the first place\r", "vinyl", ".", "readme", "=", "readme", ";", "// Add that to the stream...\r", "this", ".", "push", "(", "vinyl", ")", ";", "conclude", "(", ")", ";", "}", ";", "// That's it for the parser\r", "return", "through2", ".", "obj", "(", "bufferFiles", ",", "endStream", ")", ";", "}" ]

[ "That", "s", "the", "plugin", "parser" ]

[ "function", "(", "model", ",", "options", ")", "{", "if", "(", "!", "(", "model", "instanceof", "Parse", ".", "Object", ")", ")", "{", "var", "attrs", "=", "model", ";", "options", ".", "collection", "=", "this", ";", "model", "=", "new", "this", ".", "model", "(", "attrs", ",", "options", ")", ";", "if", "(", "!", "model", ".", "_validate", "(", "model", ".", "attributes", ",", "options", ")", ")", "{", "model", "=", "false", ";", "}", "}", "else", "if", "(", "!", "model", ".", "collection", ")", "{", "model", ".", "collection", "=", "this", ";", "}", "return", "model", ";", "}" ]

[ "Prepare", "a", "model", "or", "hash", "of", "attributes", "to", "be", "added", "to", "this", "collection", "." ]

[ "function", "_configGetExtLang", "(", "filext", ")", "{", "var", "fileext1", "=", "filext", ".", "indexOf", "(", "'.'", ")", "==", "0", "?", "fileext", ".", "substring", "(", "1", ",", "filext", ".", "length", ")", ":", "fileext", ";", "if", "(", "!", "config", ".", "extlangs", ".", "hasOwnProperty", "(", "fileext1", ")", ")", "return", "null", ";", "return", "config", ".", "extlangs", "[", "fileext1", "]", ";", "}" ]

[ "CHECK", "EXTLANG", "[" ]

[ "function", "extractCommentTagFromLine", "(", "fileext", ",", "line", ")", "{", "line", "=", "line", ".", "trim", "(", ")", ";", "// CHECK FORMAT [", "var", "b", ";", "function", "chkfmt", "(", "b", ")", "{", "if", "(", "line", ".", "indexOf", "(", "b", ")", "==", "0", "&&", "line", ".", "indexOf", "(", "'['", ")", "==", "line", ".", "length", "-", "1", ")", "// begin", "return", "[", "line", ".", "substr", "(", "b", ".", "length", ",", "line", ".", "length", "-", "b", ".", "length", "-", "1", ")", ".", "trim", "(", ")", ",", "0", "]", ";", "if", "(", "line", ".", "indexOf", "(", "b", ")", "==", "0", "&&", "line", ".", "indexOf", "(", "']'", ")", "==", "line", ".", "length", "-", "1", "&&", "line", ".", "indexOf", "(", "'['", ")", "==", "-", "1", ")", "// end", "return", "[", "line", ".", "substr", "(", "b", ".", "length", ",", "line", ".", "length", "-", "b", ".", "length", "-", "1", ")", ".", "trim", "(", ")", ",", "1", "]", ";", "return", "null", ";", "}", ";", "// CHECK FORMAT ]", "// SUPPORT FORMATS [", "switch", "(", "fileext", ")", "{", "case", "'.js'", ":", "case", "'.java'", ":", "case", "'.c'", ":", "case", "'.h'", ":", "case", "'.cpp'", ":", "case", "'.hpp'", ":", "case", "'.less'", ":", "case", "'.m'", ":", "case", "'.mm'", ":", "return", "chkfmt", "(", "'//'", ")", "||", "false", ";", "case", "'.css'", ":", "return", "chkfmt", "(", "'/*'", ")", "||", "false", ";", "case", "'.acpul'", ":", "case", "'.sh'", ":", "case", "'.py'", ":", "case", "'.pro'", ":", "return", "chkfmt", "(", "'#'", ")", "||", "false", ";", "case", "'.ejs'", ":", "case", "'.jade'", ":", "case", "'.sass'", ":", "case", "'.styl'", ":", "case", "'.coffee'", ":", "break", ";", "default", ":", "return", "null", ";", "}", "// SUPPORT FORMATS ]", "return", "false", ";", "}" ]

[ "custom", "comment", "format", "use", "config", ".", "extractCommentTagFromLine", "[" ]

[ "function", "(", "name", ",", "dimensions", ")", "{", "name", "=", "name", "||", "''", ";", "name", "=", "name", ".", "replace", "(", "/", "^\\s*", "/", ",", "''", ")", ";", "name", "=", "name", ".", "replace", "(", "/", "\\s*$", "/", ",", "''", ")", ";", "if", "(", "name", ".", "length", "===", "0", ")", "{", "throw", "'A name for the custom event must be provided'", ";", "}", "_", ".", "each", "(", "dimensions", ",", "function", "(", "val", ",", "key", ")", "{", "if", "(", "!", "_", ".", "isString", "(", "key", ")", "||", "!", "_", ".", "isString", "(", "val", ")", ")", "{", "throw", "'track() dimensions expects keys and values of type \"string\".'", ";", "}", "}", ")", ";", "return", "Parse", ".", "_request", "(", "{", "route", ":", "'events'", ",", "className", ":", "name", ",", "method", ":", "'POST'", ",", "data", ":", "{", "dimensions", ":", "dimensions", "}", "}", ")", ";", "}" ]

[ "Tracks", "the", "occurrence", "of", "a", "custom", "event", "with", "additional", "dimensions", ".", "Parse", "will", "store", "a", "data", "point", "at", "the", "time", "of", "invocation", "with", "the", "given", "event", "name", "." ]

[ "function", "retryPromiseTimeout", "(", "PromiseFunc", ",", "Obj", ",", "Options", ")", "{", "let", "timeoutOpts", "=", "Options", ".", "Timeout", ";", "limitpromises", "=", "limitpromises", "||", "require", "(", "'../limitpromises'", ")", ";", "setTimeout", "(", "(", ")", "=>", "{", "if", "(", "Obj", ".", "isRunning", "&&", "Obj", ".", "attempt", "<=", "timeoutOpts", ".", "retryAttempts", ")", "{", "// Put a new promise on the same stack as the current one is, so you dont call more promises of one", "// group as specified. Input Value is just true as we dont need it and only make one promise", "let", "newPromise", "=", "limitpromises", "(", "(", ")", "=>", "{", "return", "new", "Promise", "(", "(", "resolve", ",", "reject", ")", "=>", "{", "PromiseFunc", "(", "Obj", ".", "inputValue", ")", ".", "then", "(", "data", "=>", "{", "resolve", "(", "data", ")", ";", "}", ",", "err", "=>", "{", "reject", "(", "err", ")", ";", "}", ")", ";", "}", ")", ";", "}", ",", "[", "true", "]", ",", "Obj", ".", "maxAtOnce", ",", "Obj", ".", "TypeKey", ")", ";", "// Wait for the PromiseArray and either resolve the current promise or handle the rejects", "Promise", ".", "all", "(", "newPromise", ".", "map", "(", "r", "=>", "{", "return", "r", ".", "result", "}", ")", ")", ".", "then", "(", "data", "=>", "{", "if", "(", "Obj", ".", "isRunning", ")", "{", "Obj", ".", "resolveResult", "(", "data", ")", ";", "}", "}", ",", "err", "=>", "{", "if", "(", "Obj", ".", "isRunning", ")", "{", "handleRejects", "(", "PromiseFunc", ",", "Obj", ",", "err", ",", "Options", ")", ";", "}", "}", ")", ";", "// Call the function again to check again after a given time", "retryPromiseTimeout", "(", "PromiseFunc", ",", "Obj", ",", "Options", ")", ";", "// Count that an attempt has been made for that object", "Obj", ".", "attempt", "++", ";", "// If more retry attempts have been made than specified by the user, reject the result", "}", "else", "if", "(", "Obj", ".", "isRunning", "&&", "Obj", ".", "attempt", ">", "timeoutOpts", ".", "retryAttempts", ")", "{", "Obj", ".", "rejectResult", "(", "new", "Error", ".", "TimeoutError", "(", "Obj", ")", ")", ";", "}", "}", ",", "timeoutOpts", ".", "timeoutMillis", ")", ";", "}" ]

[ "Handles", "Timeout", "of", "promises" ]

[ "function", "queue", "(", "task", ",", "done", ")", "{", "var", "storage", "=", "this", ",", "key", "=", "this", ".", "keygen", "(", "task", ")", ";", "// store task as JSON serialized string", "task", "=", "JSON", ".", "stringify", "(", "task", ")", ";", "// first add the key to the queue", "this", ".", "redis", "(", ")", ".", "rpush", "(", "this", ".", "queueKey", "(", ")", ",", "key", ",", "function", "(", "err", ")", "{", "if", "(", "err", ")", "done", "(", "err", ")", ";", "// now store task data", "else", "storage", ".", "redis", "(", ")", ".", "set", "(", "key", ",", "task", ",", "function", "(", "err", ")", "{", "if", "(", "err", ")", "done", "(", "err", ")", ";", "else", "done", "(", "null", ",", "key", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Queue", "a", "serialized", "request", "and", "pass", "the", "storage", "key", "to", "the", "callback", "." ]

[ "function", "unqueue", "(", "done", ")", "{", "var", "storage", "=", "this", ";", "this", ".", "redis", "(", ")", ".", "lpop", "(", "this", ".", "queueKey", "(", ")", ",", "function", "(", "err", ",", "key", ")", "{", "if", "(", "err", ")", "return", "done", "(", "err", ")", ";", "storage", ".", "redis", "(", ")", ".", "get", "(", "key", ",", "function", "(", "err", ",", "task", ")", "{", "if", "(", "err", ")", "return", "done", "(", "err", ")", ";", "if", "(", "!", "task", ")", "return", "done", "(", ")", ";", "storage", ".", "redis", "(", ")", ".", "del", "(", "key", ")", ";", "done", "(", "null", ",", "JSON", ".", "parse", "(", "task", ")", ",", "key", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Remove", "a", "task", "from", "the", "queue", "and", "pass", "it", "to", "the", "callback", "." ]

[ "function", "log", "(", "key", ",", "result", ",", "done", ")", "{", "var", "storage", "=", "this", ";", "// store result as JSON serialized string", "result", "=", "JSON", ".", "stringify", "(", "result", ")", ";", "// generate result key from task key", "key", "=", "key", "+", "\"-result\"", ";", "// first add the key to the log", "this", ".", "redis", "(", ")", ".", "rpush", "(", "this", ".", "logKey", "(", ")", ",", "key", ",", "function", "(", "err", ")", "{", "if", "(", "err", ")", "done", "(", "err", ")", ";", "// now store result data", "else", "storage", ".", "redis", "(", ")", ".", "set", "(", "key", ",", "result", ",", "done", ")", ";", "}", ")", ";", "}" ]

[ "Log", "task", "result", "." ]

[ "function", "Logger", "(", ")", "{", "this", ".", "_level", "=", "LEVELS", ".", "NOTICE", ";", "this", ".", "_out", "=", "process", ".", "stdout", ";", "this", ".", "_err", "=", "process", ".", "stderr", ";", "/* istanbul ignore next: allow server to suppress logs */", "if", "(", "process", ".", "env", ".", "NODE_ENV", "===", "Constants", ".", "TEST", "&&", "!", "process", ".", "env", ".", "TEST_DEBUG", ")", "{", "this", ".", "log", "=", "function", "noop", "(", ")", "{", "}", ";", "}", "}" ]

[ "Create", "a", "logger", "." ]

[ "function", "level", "(", "lvl", ")", "{", "if", "(", "!", "lvl", ")", "return", "this", ".", "_level", ";", "if", "(", "!", "~", "LEVELS", ".", "indexOf", "(", "lvl", ")", ")", "{", "throw", "new", "Error", "(", "'invalid log level: '", "+", "lvl", ")", ";", "}", "this", ".", "_level", "=", "lvl", ";", "return", "this", ".", "_level", ";", "}" ]

[ "Get", "or", "set", "the", "log", "level", "." ]

[ "function", "warning", "(", ")", "{", "var", "args", "=", "[", "LEVELS", ".", "WARNING", "]", ".", "concat", "(", "slice", ".", "apply", "(", "arguments", ")", ")", ";", "return", "this", ".", "log", ".", "apply", "(", "this", ",", "args", ")", ";", "}" ]

[ "Log", "a", "warning", "message", "." ]

[ "function", "notice", "(", ")", "{", "var", "args", "=", "[", "LEVELS", ".", "NOTICE", "]", ".", "concat", "(", "slice", ".", "apply", "(", "arguments", ")", ")", ";", "return", "this", ".", "log", ".", "apply", "(", "this", ",", "args", ")", ";", "}" ]

[ "Log", "a", "notice", "message", "." ]

[ "function", "verbose", "(", ")", "{", "var", "args", "=", "[", "LEVELS", ".", "VERBOSE", "]", ".", "concat", "(", "slice", ".", "apply", "(", "arguments", ")", ")", ";", "return", "this", ".", "log", ".", "apply", "(", "this", ",", "args", ")", ";", "}" ]

[ "Log", "a", "verbose", "message", "." ]

[ "function", "createConfiguration", "(", "options", ")", "{", "const", "cfg", "=", "Object", ".", "assign", "(", "{", "followSymbolicLinks", ":", "false", ",", "cacheTimeInSeconds", ":", "0", ",", "documentRoot", ":", "process", ".", "cwd", "(", ")", ",", "parsedURLName", ":", "'urlParsed'", ",", "getFilePath", ":", "getFilePath", ",", "getFileStats", ":", "getFileStats", ",", "getResponseData", ":", "getResponseData", ",", "standardResponses", ":", "null", "}", ",", "options", ")", ";", "try", "{", "let", "root", "=", "fs", ".", "realpathSync", "(", "cfg", ".", "documentRoot", ")", ";", "cfg", ".", "documentRootReal", "=", "root", ";", "}", "catch", "(", "e", ")", "{", "return", "e", ";", "}", "return", "cfg", ";", "}" ]

[ "Configuration", "object", "." ]

[ "function", "getFileStats", "(", "cfg", ",", "filePath", ",", "callback", ")", "{", "fs", ".", "realpath", "(", "filePath", ",", "function", "(", "err", ",", "realpath", ")", "{", "// On Windows we can get different cases for the same disk letter :/.", "let", "checkPath", "=", "realpath", ";", "if", "(", "os", ".", "platform", "(", ")", "===", "'win32'", "&&", "realpath", ")", "{", "checkPath", "=", "realpath", ".", "toLowerCase", "(", ")", ";", "}", "if", "(", "err", "||", "checkPath", ".", "indexOf", "(", "cfg", ".", "documentRootReal", ")", "!==", "0", ")", "{", "return", "callback", "(", "err", "||", "new", "Error", "(", "'Access denied'", ")", ")", ";", "}", "fs", "[", "cfg", ".", "followSymbolicLinks", "?", "'stat'", ":", "'lstat'", "]", "(", "filePath", ",", "function", "(", "err", ",", "stats", ")", "{", "if", "(", "err", "||", "!", "stats", ".", "isFile", "(", ")", ")", "{", "return", "callback", "(", "err", "||", "new", "Error", "(", "'Access denied'", ")", ")", ";", "}", "stats", ".", "path", "=", "realpath", ";", "callback", "(", "null", ",", "stats", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Calls", "back", "with", "error", "or", "null", "and", "fs", ".", "Stats", "object", "as", "second", "parameter", ".", "fs", ".", "Stats", "object", "is", "extended", "with", "path", "property", "." ]

[ "function", "getResponseDataWhole", "(", "fileStats", "/* , headers*/", ")", "{", "return", "{", "body", ":", "fs", ".", "createReadStream", "(", "fileStats", ".", "path", ")", ",", "statusCode", ":", "HTTP_CODES", ".", "OK", ",", "headers", ":", "{", "'Content-Type'", ":", "mime", "(", "fileStats", ".", "path", ")", ",", "'Content-Length'", ":", "fileStats", ".", "size", ",", "'Last-Modified'", ":", "fileStats", ".", "mtime", ".", "toUTCString", "(", ")", "}", "}", ";", "}" ]

[ "Creates", "responseData", "object", "with", "body", "set", "to", "readable", "stream", "of", "requested", "file", "." ]

[ "function", "createFileResponseHandler", "(", "options", ")", "{", "const", "cfg", "=", "createConfiguration", "(", "options", ")", ";", "if", "(", "cfg", "instanceof", "Error", ")", "{", "return", "cfg", ";", "}", "/**\n\t * @private\n\t * @param {!external:\"http.IncomingMessage\"} req\n\t * @param {!external:\"http.ServerResponse\"} res\n\t * @param {Function} [callback] called AFTER response is finished\n\t */", "function", "serve", "(", "req", ",", "res", ",", "callback", ")", "{", "if", "(", "callback", "&&", "callback", "instanceof", "Function", ")", "{", "res", ".", "once", "(", "'finish'", ",", "callback", ")", ";", "}", "const", "filePath", "=", "cfg", ".", "getFilePath", "(", "cfg", ",", "req", ")", ";", "prepareFileResponse", "(", "cfg", ",", "filePath", ",", "req", ".", "headers", ",", "(", "err", ",", "data", ")", "=>", "{", "if", "(", "err", ")", "{", "data", "=", "{", "statusCode", ":", "HTTP_CODES", ".", "NOT_FOUND", "}", ";", "}", "serveFileResponse", "(", "cfg", ",", "data", ",", "res", ")", ";", "}", ")", ";", "}", "return", "serve", ";", "}" ]

[ "Create", "function", "that", "will", "handle", "serving", "files", "." ]

[ "function", "(", "inputIndex", ")", "{", "_", ".", "each", "(", "tokens", ",", "function", "(", "token", ",", "index", ")", "{", "// determain whether or not this is a file reference or a string", "if", "(", "token", ".", "file", ")", "{", "// read the file and reset replacement to what was loaded", "fs", ".", "readFile", "(", "token", ".", "file", ",", "'utf8'", ",", "function", "(", "e", ",", "data", ")", "{", "if", "(", "e", ")", "{", "grunt", ".", "fail", ".", "warn", "(", "\"There was an error processing the replacement '\"", "+", "token", ".", "file", "+", "\"' file.\"", ")", ";", "}", "tokens", "[", "index", "]", ".", "contents", "=", "data", ";", "processTokenCompleteCallback", "(", ")", ";", "}", ")", ";", "}", "else", "if", "(", "token", ".", "string", ")", "{", "// we didn't need to load a file", "tokens", "[", "index", "]", ".", "contents", "=", "token", ".", "string", ";", "processTokenCompleteCallback", "(", ")", ";", "}", "else", "{", "processTokenCompleteCallback", "(", ")", ";", "}", "}", ",", "this", ")", ";", "}" ]

[ "Processes", "all", "of", "the", "passed", "replacements" ]

[ "function", "(", "inputIndex", ")", "{", "var", "inputPath", "=", "input", "[", "inputIndex", "]", ".", "split", "(", "\"/\"", ")", ";", "inputPath", "=", "inputPath", "[", "inputPath", ".", "length", "-", "1", "]", ";", "var", "path", "=", "outputIsPath", "?", "output", "+", "inputPath", ":", "output", ";", "// write the input string to the output file name", "grunt", ".", "log", ".", "writeln", "(", "'Writing Output: '", "+", "(", "path", ")", ".", "cyan", ")", ";", "fs", ".", "writeFile", "(", "path", ",", "fileContents", "[", "inputIndex", "]", ",", "'utf8'", ",", "function", "(", "err", ")", "{", "//console.log(fileContents[inputIndex]);", "if", "(", "err", ")", "{", "clearTimeout", "(", "timer", ")", ";", "grunt", ".", "fail", ".", "warn", "(", "\"Could not write output '\"", "+", "output", "+", "\"' file.\"", ")", ";", "}", "processedFiles", "++", ";", "if", "(", "processedFiles", "===", "fileContents", ".", "length", ")", "{", "processedFiles", "=", "0", ";", "fileContents", "=", "[", "]", ";", "var", "endtime", "=", "(", "new", "Date", "(", ")", ")", ".", "getTime", "(", ")", ";", "grunt", ".", "log", ".", "writeln", "(", "'Combine task completed in '", "+", "(", "(", "endtime", "-", "starttime", ")", "/", "1000", ")", "+", "' seconds'", ")", ";", "clearTimeout", "(", "timer", ")", ";", "done", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Writes", "the", "processed", "input", "file", "to", "the", "specified", "output", "name", "." ]

[ "function", "string_component", "(", "self", ",", "message", ",", "component", ")", "{", "eventify", "(", "self", ")", ";", "valuable", "(", "self", ",", "update", ",", "''", ")", ";", "var", "$c", "=", "$$", "(", ")", ".", "addClass", "(", "'control'", ")", ";", "var", "$l", "=", "$", "(", "\"<label>\"", "+", "message", "+", "\"</label>\"", ")", ";", "var", "$i", "=", "$", "(", "component", ")", ";", "$c", ".", "append", "(", "$l", ",", "$i", ")", ";", "self", ".", "$el", "=", "$c", ";", "function", "update", "(", ")", "{", "$i", ".", "val", "(", "self", ".", "_data", ")", ";", "}", "$i", ".", "on", "(", "'change'", ",", "function", "(", ")", "{", "self", ".", "_data", "=", "$i", ".", "val", "(", ")", ";", "self", ".", "emit", "(", "'change'", ")", ";", "}", ")", "}" ]

[ "simple", "component", "!" ]

[ "function", "attributable", "(", "form", ",", "c", ",", "name", ")", "{", "if", "(", "form", ".", "_vals", "==", "null", ")", "form", ".", "_vals", "=", "{", "}", ";", "if", "(", "form", ".", "_update", "==", "null", ")", "form", ".", "_update", "=", "function", "(", ")", "{", "for", "(", "var", "p", "in", "form", ".", "_vals", ")", "form", ".", "_vals", "[", "p", "]", ".", "data", "==", "form", ".", "_data", "[", "p", "]", ";", "}", "form", ".", "_vals", "[", "name", "]", "=", "c", ";", "c", ".", "on", "(", "'change'", ",", "function", "(", ")", "{", "form", ".", "_data", "[", "name", "]", "=", "c", ".", "data", ";", "form", ".", "emit", "(", "'change'", ")", ";", "}", ")", ";", "}" ]

[ "form", "field", "utility" ]

[ "function", "UserVoiceSSO", "(", "subdomain", ",", "ssoKey", ")", "{", "// For UserVoice, the subdomain is used as password", "// and the ssoKey is used as salt", "this", ".", "subdomain", "=", "subdomain", ";", "this", ".", "ssoKey", "=", "ssoKey", ";", "if", "(", "!", "this", ".", "subdomain", ")", "{", "throw", "new", "Error", "(", "'No UserVoice subdomain given'", ")", ";", "}", "if", "(", "!", "this", ".", "ssoKey", ")", "{", "throw", "new", "Error", "(", "'No SSO key given. Find it '", ")", ";", "}", "this", ".", "defaults", "=", "{", "}", ";", "}" ]

[ "UserVoice", "SSO", "Contstructor" ]

[ "function", "getDomain", "(", "data", ",", "accessor", ")", "{", "return", "data", ".", "map", "(", "function", "(", "item", ")", "{", "return", "accessor", ".", "call", "(", "this", ",", "item", ")", ";", "}", ")", ".", "filter", "(", "function", "(", "item", ",", "index", ",", "array", ")", "{", "return", "array", ".", "indexOf", "(", "item", ")", "===", "index", ";", "}", ")", ";", "}" ]

[ "Creates", "a", "unique", "array", "of", "items" ]

[ "function", "validateRule", "(", "rule", ",", "value", ")", "{", "// For a given rule, get the first letter of the string name of its", "// constructor function. \"R\" -> RegExp, \"F\" -> Function (these shouldn't", "// conflict with any other types one might specify). Note: instead of", "// getting .toString from a new object {} or Object.prototype, I'm assuming", "// that exports will always be an object, and using its .toString method.", "// Bad idea? Let me know by filing an issue", "var", "type", "=", "exports", ".", "toString", ".", "call", "(", "rule", ")", ".", "charAt", "(", "8", ")", ";", "// If regexp, match. If function, invoke. Otherwise, compare. Note that ==", "// is used because type coercion is needed, as `value` will always be a", "// string, but `rule` might not.", "return", "type", "===", "\"R\"", "?", "rule", ".", "test", "(", "value", ")", ":", "type", "===", "\"F\"", "?", "rule", "(", "value", ")", ":", "rule", "==", "value", ";", "}" ]

[ "Test", "to", "see", "if", "a", "value", "matches", "the", "corresponding", "rule", "." ]

[ "function", "Dotfile", "(", "basename", ",", "options", ")", "{", "this", ".", "basename", "=", "basename", ";", "this", ".", "extname", "=", "'.json'", ";", "this", ".", "dirname", "=", "(", "options", "&&", "typeof", "options", ".", "dirname", "===", "'string'", ")", "?", "options", ".", "dirname", ":", "Dotfile", ".", "_tilde", ";", "this", ".", "filepath", "=", "path", ".", "join", "(", "this", ".", "dirname", ",", "'.'", "+", "this", ".", "basename", "+", "this", ".", "extname", ")", ";", "}" ]

[ "Class", "to", "easily", "manage", "dot", "files" ]

[ "function", "transform", "(", "value", ")", "{", "if", "(", "typeof", "value", "===", "'function'", ")", "value", "=", "value", "(", ")", "if", "(", "value", "instanceof", "Array", ")", "{", "var", "el", "=", "document", ".", "createDocumentFragment", "(", ")", "value", ".", "map", "(", "item", "=>", "el", ".", "appendChild", "(", "transform", "(", "item", ")", ")", ")", "value", "=", "el", "}", "else", "if", "(", "typeof", "value", "===", "'object'", ")", "{", "if", "(", "typeof", "value", ".", "then", "===", "'function'", ")", "{", "var", "tmp", "=", "document", ".", "createTextNode", "(", "''", ")", "value", ".", "then", "(", "function", "(", "data", ")", "{", "tmp", ".", "parentElement", ".", "replaceChild", "(", "transform", "(", "data", ")", ",", "tmp", ")", "}", ")", "value", "=", "tmp", "}", "else", "if", "(", "typeof", "value", ".", "on", "===", "'function'", ")", "{", "var", "tmp", "=", "document", ".", "createTextNode", "(", "''", ")", "value", ".", "on", "(", "'data'", ",", "function", "(", "data", ")", "{", "// need to transform? Streams are only text?", "tmp", ".", "parentElement", ".", "insertBefore", "(", "document", ".", "createTextNode", "(", "data", ")", ",", "tmp", ")", "}", ")", "value", "=", "tmp", "}", "}", "else", "value", "=", "document", ".", "createTextNode", "(", "value", ")", "return", "value", "}" ]

[ "Transform", "value", "." ]

[ "function", "Requests", "(", "apiUrl", ",", "version", ",", "publicKey", ")", "{", "this", ".", "apiUrl", "=", "stripSlashes", "(", "apiUrl", ")", ";", "this", ".", "version", "=", "version", ".", "toString", "(", ")", ";", "this", ".", "publicKey", "=", "publicKey", ";", "}" ]

[ "Dinvio", "API", "Requests", "module" ]

[ "function", "(", "id", ")", "{", "var", "file", ";", "if", "(", "typeof", "id", "===", "'number'", ")", "{", "file", "=", "this", ".", "uploader", ".", "files", "[", "id", "]", ";", "}", "else", "{", "file", "=", "this", ".", "uploader", ".", "getFile", "(", "id", ")", ";", "}", "return", "file", ";", "}" ]

[ "Retrieve", "file", "by", "it", "s", "unique", "id", "." ]

[ "function", "(", "file", ")", "{", "if", "(", "plupload", ".", "typeOf", "(", "file", ")", "===", "'string'", ")", "{", "file", "=", "this", ".", "getFile", "(", "file", ")", ";", "}", "this", ".", "uploader", ".", "removeFile", "(", "file", ")", ";", "}" ]

[ "Remove", "the", "file", "from", "the", "queue", "." ]

[ "function", "(", "type", ",", "message", ")", "{", "var", "popup", "=", "$", "(", "'<div class=\"plupload_message\">'", "+", "'<span class=\"plupload_message_close ui-icon ui-icon-circle-close\" title=\"'", "+", "_", "(", "'Close'", ")", "+", "'\"></span>'", "+", "'<p><span class=\"ui-icon\"></span>'", "+", "message", "+", "'</p>'", "+", "'</div>'", ")", ";", "popup", ".", "addClass", "(", "'ui-state-'", "+", "(", "type", "===", "'error'", "?", "'error'", ":", "'highlight'", ")", ")", ".", "find", "(", "'p .ui-icon'", ")", ".", "addClass", "(", "'ui-icon-'", "+", "(", "type", "===", "'error'", "?", "'alert'", ":", "'info'", ")", ")", ".", "end", "(", ")", ".", "find", "(", "'.plupload_message_close'", ")", ".", "click", "(", "function", "(", ")", "{", "popup", ".", "remove", "(", ")", ";", "}", ")", ".", "end", "(", ")", ";", "$", "(", "'.plupload_header'", ",", "this", ".", "container", ")", ".", "append", "(", "popup", ")", ";", "}" ]

[ "Display", "a", "message", "in", "notification", "area", "." ]

[ "function", "(", ")", "{", "// destroy uploader instance", "this", ".", "uploader", ".", "destroy", "(", ")", ";", "// unbind all button events", "$", "(", "'.plupload_button'", ",", "this", ".", "element", ")", ".", "unbind", "(", ")", ";", "// destroy buttons", "if", "(", "$", ".", "ui", ".", "button", ")", "{", "$", "(", "'.plupload_add, .plupload_start, .plupload_stop'", ",", "this", ".", "container", ")", ".", "button", "(", "'destroy'", ")", ";", "}", "// destroy progressbar", "if", "(", "$", ".", "ui", ".", "progressbar", ")", "{", "this", ".", "progressbar", ".", "progressbar", "(", "'destroy'", ")", ";", "}", "// destroy sortable behavior", "if", "(", "$", ".", "ui", ".", "sortable", "&&", "this", ".", "options", ".", "sortable", ")", "{", "$", "(", "'tbody'", ",", "this", ".", "filelist", ")", ".", "sortable", "(", "'destroy'", ")", ";", "}", "// restore the elements initial state", "this", ".", "element", ".", "empty", "(", ")", ".", "html", "(", "this", ".", "contents_bak", ")", ";", "this", ".", "contents_bak", "=", "''", ";", "$", ".", "Widget", ".", "prototype", ".", "destroy", ".", "apply", "(", "this", ")", ";", "}" ]

[ "Destroy", "the", "widget", "the", "uploader", "free", "associated", "resources", "and", "bring", "back", "original", "html", "." ]

[ "function", "measure", "(", ")", "{", "if", "(", "!", "tw", "||", "!", "th", ")", "{", "var", "wrapper", "=", "$", "(", "'.plupload_file:eq(0)'", ",", "self", ".", "filelist", ")", ";", "tw", "=", "wrapper", ".", "outerWidth", "(", "true", ")", ";", "th", "=", "wrapper", ".", "outerHeight", "(", "true", ")", ";", "}", "var", "aw", "=", "self", ".", "content", ".", "width", "(", ")", ",", "ah", "=", "self", ".", "content", ".", "height", "(", ")", ";", "cols", "=", "Math", ".", "floor", "(", "aw", "/", "tw", ")", ";", "num", "=", "cols", "*", "(", "Math", ".", "ceil", "(", "ah", "/", "th", ")", "+", "1", ")", ";", "}" ]

[ "calculate", "number", "of", "simultaneously", "visible", "thumbs" ]

[ "function", "obv", "(", "fn", ",", "immediate", ")", "{", "if", "(", "!", "fn", ")", "return", "state", "listeners", ".", "push", "(", "fn", ")", "if", "(", "immediate", "!==", "false", "&&", "fn", "(", "state", ")", "===", "true", ")", "obv", ".", "more", "(", ")", "return", "function", "(", ")", "{", "var", "i", "=", "listeners", ".", "indexOf", "(", "fn", ")", "listeners", ".", "splice", "(", "i", ",", "1", ")", "}", "}" ]

[ "implement", "an", "observable" ]

[ "function", "isValid", "(", "type", ",", "value", ")", "{", "switch", "(", "type", ")", "{", "case", "'email'", ":", "return", "validator", ".", "isEmail", "(", "value", ")", ";", "break", ";", "case", "'url'", ":", "return", "validator", ".", "isURL", "(", "value", ")", ";", "break", ";", "case", "'domain'", ":", "return", "validator", ".", "isFQDN", "(", "value", ")", ";", "break", ";", "case", "'ip'", ":", "return", "validator", ".", "isIP", "(", "value", ")", ";", "break", ";", "case", "'alpha'", ":", "return", "validator", ".", "isAlpha", "(", "value", ")", ";", "break", ";", "case", "'number'", ":", "return", "validator", ".", "isNumeric", "(", "value", ")", ";", "break", ";", "case", "'alphanumeric'", ":", "return", "validator", ".", "isAlphanumeric", "(", "value", ")", ";", "break", ";", "case", "'base64'", ":", "return", "validator", ".", "isBase64", "(", "value", ")", ";", "break", ";", "case", "'hexadecimal'", ":", "return", "validator", ".", "isHexadecimal", "(", "value", ")", ";", "break", ";", "case", "'hexcolor'", ":", "return", "validator", ".", "isHexColor", "(", "value", ")", ";", "break", ";", "case", "'int'", ":", "return", "validator", ".", "isInt", "(", "value", ")", ";", "break", ";", "case", "'float'", ":", "return", "validator", ".", "isFloat", "(", "value", ")", ";", "break", ";", "case", "'null'", ":", "return", "validator", ".", "isNull", "(", "value", ")", ";", "break", ";", "case", "'uuid'", ":", "return", "validator", ".", "isUUID", "(", "value", ")", ";", "break", ";", "case", "'date'", ":", "return", "validator", ".", "isDate", "(", "value", ")", ";", "break", ";", "case", "'creditcard'", ":", "return", "validator", ".", "isCreditCard", "(", "value", ")", ";", "break", ";", "case", "'isbn'", ":", "return", "validator", ".", "isISBN", "(", "value", ")", ";", "break", ";", "case", "'mobilephone'", ":", "return", "validator", ".", "isMobilePhone", "(", "value", ")", ";", "break", ";", "case", "'json'", ":", "return", "validator", ".", "isJSON", "(", "value", ")", ";", "break", ";", "case", "'ascii'", ":", "return", "validator", ".", "isAscii", "(", "value", ")", ";", "break", ";", "case", "'mongoid'", ":", "return", "validator", ".", "isMongoId", "(", "value", ")", ";", "break", ";", "default", ":", "return", "false", ";", "break", ";", "}", "}" ]

[ "call", "a", "validator", "method", "depending", "on", "type" ]

[ "function", "_buildNamespace", "(", "appName", ",", "depth", ")", "{", "var", "callerFile", ";", "// Our default depth needs to be 2, since 1 is this file. Add the user", "// supplied depth to 1 (for this file) to make it 2.", "callerFile", "=", "caller", "(", "depth", "+", "1", ")", ";", "// if for some reason we're unable to determine the caller, use the appName only", "if", "(", "!", "callerFile", ")", "{", "return", "appName", ";", "}", "// TODO in later versions of Node (v0.12.+), there is simple `path.parse`", "// which will provide us with the file name property. But until most have", "// moved up to that version, find the caller file name in this way...", "// find the filename from the path", "callerFile", "=", "path", ".", "basename", "(", "callerFile", ")", ";", "// strip off the suffix (if any)", "if", "(", "path", ".", "extname", "(", "callerFile", ")", ")", "{", "callerFile", "=", "callerFile", ".", "slice", "(", "0", ",", "callerFile", ".", "indexOf", "(", "path", ".", "extname", "(", "callerFile", ")", ")", ")", ";", "}", "return", "appName", "+", "\":\"", "+", "callerFile", ";", "}" ]

[ "Returns", "the", "descriptive", "text", "used", "in", "the", "debug", "instantiation", "which", "at", "this", "point", "is", "the", "app", "+", "calling", "filename", ".", "Allow", "the", "user", "to", "specify", "a", "depth", "for", "the", "calling", "filename", "in", "the", "case", "they", "have", "a", "wrapping", "function", "calling", "this", "." ]

[ "function", "logger", "(", "appName", ",", "options", ")", "{", "var", "namespace", ",", "log", ",", "error", ";", "options", "=", "options", "?", "options", ":", "{", "}", ";", "// merge our default options with the user supplied", "options", "=", "xtend", "(", "{", "depth", ":", "1", ",", "randomColors", ":", "false", ",", "logColor", ":", "7", ",", "errorColor", ":", "1", ",", "}", ",", "options", ")", ";", "// get the filename which is used as the namespace for the debug module.", "namespace", "=", "_buildNamespace", "(", "appName", ",", "options", ".", "depth", ")", ";", "// setup two debug'ers, one for console.log and one for console.error", "log", "=", "debug", "(", "namespace", ")", ";", "// bind the log to console.log", "log", ".", "log", "=", "console", ".", "log", ".", "bind", "(", "console", ")", ";", "error", "=", "debug", "(", "namespace", ")", ";", "// this should happen by default, but just to be sure...", "error", ".", "log", "=", "console", ".", "error", ".", "bind", "(", "console", ")", ";", "// if we don't want random colors, assign log to options.logColor (default: white (7))", "// and error to options.errorColor (default: red (1))", "if", "(", "!", "options", ".", "randomColors", ")", "{", "log", ".", "color", "=", "options", ".", "logColor", ";", "error", ".", "color", "=", "options", ".", "errorColor", ";", "}", "return", "{", "// return the two debug'ers under the log and error functions", "log", ":", "log", ",", "error", ":", "error", ",", "// include the namespace in case the client needs it", "namespace", ":", "namespace", "}", ";", "}" ]

[ "Creates", "the", "debug", "object", "using", "the", "namespace", "built", "from", "the", "appName", "and", "calling", "filename", ".", "Creates", "2", "loggers", "one", "for", "log", "one", "for", "error", "." ]

[ "function", "init_session", "(", "req", ")", "{", "debug", ".", "assert", "(", "req", ".", "session", ")", ".", "is", "(", "'object'", ")", ";", "if", "(", "!", "is", ".", "obj", "(", "req", ".", "session", ".", "client", ")", ")", "{", "req", ".", "session", ".", "client", "=", "{", "}", ";", "}", "if", "(", "(", "!", "is", ".", "obj", "(", "req", ".", "session", ".", "client", ".", "messages", ")", ")", "||", "is", ".", "array", "(", "req", ".", "session", ".", "client", ".", "messages", ")", ")", "{", "req", ".", "session", ".", "client", ".", "messages", "=", "{", "}", ";", "}", "}" ]

[ "Initialize", "the", "session" ]

[ "function", "(", "baseUrl", ",", "firebaseUrl", ",", "port", ",", "cardsDirectory", ")", "{", "// Set environment variables.", "process", ".", "env", ".", "BASE_URL", "=", "baseUrl", "||", "''", ";", "process", ".", "env", ".", "FIREBASE_URL", "=", "firebaseUrl", "||", "'https://hashdodemo.firebaseio.com/'", ",", "process", ".", "env", ".", "CARDS_DIRECTORY", "=", "cardsDirectory", "||", "process", ".", "cwd", "(", ")", ";", "process", ".", "env", ".", "PORT", "=", "port", "||", "4000", ";", "var", "Path", "=", "require", "(", "'path'", ")", ",", "Favicon", "=", "require", "(", "'serve-favicon'", ")", ",", "Hpp", "=", "require", "(", "'hpp'", ")", ";", "App", ".", "use", "(", "Timeout", "(", "'10s'", ")", ")", ";", "App", ".", "use", "(", "Favicon", "(", "Path", ".", "join", "(", "__dirname", ",", "'/public/favicon.ico'", ")", ")", ")", ";", "App", ".", "use", "(", "Express", ".", "static", "(", "'public'", ")", ")", ";", "// Hacky, quick fix required for now.", "// **********************************", "App", ".", "use", "(", "'/js'", ",", "Express", ".", "static", "(", "Path", ".", "join", "(", "__dirname", ",", "'/node_modules/hashdo/public/js'", ")", ")", ")", ";", "App", ".", "use", "(", "'/css'", ",", "Express", ".", "static", "(", "Path", ".", "join", "(", "__dirname", ",", "'/node_modules/hashdo/public/css'", ")", ")", ")", ";", "// **********************************", "App", ".", "use", "(", "BodyParser", ".", "urlencoded", "(", "{", "extended", ":", "false", ",", "limit", ":", "'5mb'", "}", ")", ")", ";", "App", ".", "use", "(", "Hpp", "(", ")", ")", ";", "App", ".", "use", "(", "Cors", "(", ")", ")", ";", "App", ".", "use", "(", "haltOnTimedout", ")", ";", "function", "haltOnTimedout", "(", "req", ",", "res", ",", "next", ")", "{", "if", "(", "!", "req", ".", "timedout", ")", "next", "(", ")", ";", "}", "// Assume cards directory is based off root if a full path is not provided.", "if", "(", "!", "Path", ".", "isAbsolute", "(", "process", ".", "env", ".", "CARDS_DIRECTORY", ")", ")", "{", "process", ".", "env", ".", "CARDS_DIRECTORY", "=", "Path", ".", "join", "(", "process", ".", "cwd", "(", ")", ",", "process", ".", "env", ".", "CARDS_DIRECTORY", ")", ";", "}", "HashDo", ".", "packs", ".", "init", "(", "baseUrl", ",", "process", ".", "env", ".", "CARDS_DIRECTORY", ")", ";", "// Make public card directories static", "HashDo", ".", "packs", ".", "cards", "(", ")", ".", "forEach", "(", "function", "(", "card", ")", "{", "var", "packDirectory", "=", "Path", ".", "join", "(", "cardsDirectory", ",", "'hashdo-'", "+", "card", ".", "pack", ")", ";", "App", ".", "use", "(", "'/'", "+", "card", ".", "pack", "+", "'/'", "+", "card", ".", "card", ",", "Express", ".", "static", "(", "Path", ".", "join", "(", "packDirectory", ",", "'public'", ",", "card", ".", "card", ")", ")", ")", ";", "}", ")", ";", "}" ]

[ "Configured", "process", "events", "and", "middleware", "required", "to", "run", "the", "web", "application", ".", "This", "function", "should", "always", "be", "called", "before", "starting", "the", "web", "server", "." ]

[ "function", "(", "callback", ")", "{", "var", "APIController", "=", "require", "(", "'./controllers/api'", ")", ",", "DefaultController", "=", "require", "(", "'./controllers/index'", ")", ",", "PackController", "=", "require", "(", "'./controllers/pack'", ")", ",", "CardController", "=", "require", "(", "'./controllers/card'", ")", ",", "WebHookController", "=", "require", "(", "'./controllers/webhook'", ")", ",", "ProxyController", "=", "require", "(", "'./controllers/proxy'", ")", ",", "JsonParser", "=", "BodyParser", ".", "json", "(", "{", "strict", ":", "false", "}", ")", ";", "// Disable caching middleware. ", "var", "nocache", "=", "function", "(", "req", ",", "res", ",", "next", ")", "{", "res", ".", "header", "(", "'Cache-Control'", ",", "'private, no-cache, no-store, must-revalidate'", ")", ";", "res", ".", "header", "(", "'Expires'", ",", "'-1'", ")", ";", "res", ".", "header", "(", "'Pragma'", ",", "'no-cache'", ")", ";", "next", "(", ")", ";", "}", ";", "// Setup routes late to give implementers routes higher priority and allow middleware as well.", "App", ".", "get", "(", "'/api/count'", ",", "nocache", ",", "APIController", ".", "count", ")", ";", "App", ".", "get", "(", "'/api/cards'", ",", "nocache", ",", "APIController", ".", "cards", ")", ";", "App", ".", "get", "(", "'/api/card'", ",", "nocache", ",", "APIController", ".", "card", ")", ";", "App", ".", "post", "(", "'/api/card/state/save'", ",", "APIController", ".", "saveState", ")", ";", "App", ".", "post", "(", "'/api/card/state/clear'", ",", "APIController", ".", "clearState", ")", ";", "App", ".", "post", "(", "'/api/card/analytics'", ",", "APIController", ".", "recordAnalyticEvents", ")", ";", "// Proxy", "App", ".", "post", "(", "'/proxy/:pack/:card'", ",", "ProxyController", ".", "post", ")", ";", "// Web Hooks", "App", ".", "post", "(", "'/webhook/:pack/:card'", ",", "WebHookController", ".", "process", ")", ";", "// Card Routes", "App", ".", "post", "(", "'/:pack/:card'", ",", "JsonParser", ",", "CardController", ".", "post", ")", ";", "App", ".", "get", "(", "'/:pack/:card'", ",", "CardController", ".", "get", ")", ";", "App", ".", "get", "(", "'/:pack'", ",", "PackController", ")", ";", "App", ".", "get", "(", "'/'", ",", "DefaultController", ")", ";", "var", "exit", "=", "function", "(", ")", "{", "HashDo", ".", "db", ".", "disconnect", "(", "function", "(", ")", "{", "process", ".", "exit", "(", "0", ")", ";", "}", ")", ";", "}", ";", "// Gracefully disconnect from the database on expected exit.", "process", ".", "on", "(", "'SIGINT'", ",", "exit", ")", ";", "process", ".", "on", "(", "'SIGTERM'", ",", "exit", ")", ";", "// Global error handler (always exit for programmatic errors).", "process", ".", "on", "(", "'uncaughtException'", ",", "function", "(", "err", ")", "{", "console", ".", "error", "(", "'FATAL: '", ",", "err", ".", "message", ")", ";", "console", ".", "error", "(", "err", ".", "stack", ")", ";", "process", ".", "exit", "(", "1", ")", ";", "}", ")", ";", "// Connect to the database and start server on successful connection.", "HashDo", ".", "db", ".", "connect", "(", "function", "(", "err", ")", "{", "if", "(", "err", ")", "{", "console", ".", "error", "(", "'FATAL: Could not connect to database.'", ",", "err", ")", ";", "process", ".", "exit", "(", "1", ")", ";", "}", "else", "{", "console", ".", "log", "(", "'WEB: Starting web server on port %d...'", ",", "process", ".", "env", ".", "PORT", ")", ";", "App", ".", "listen", "(", "process", ".", "env", ".", "PORT", ",", "function", "(", ")", "{", "console", ".", "log", "(", ")", ";", "console", ".", "log", "(", "'Let\\'s #Do'", ")", ";", "callback", "&&", "callback", "(", ")", ";", "}", ")", ";", "}", "}", ")", ";", "}" ]

[ "Sets", "up", "internal", "routes", "and", "starts", "the", "web", "server", "Ensure", "you", "call", "the", "init", "function", "before", "starting", "the", "web", "server", "." ]

[ "function", "run", "(", "files", ",", "options", ")", "{", "// If translations or templates are not supplied then error", "if", "(", "options", ".", "translations", ".", "length", "===", "0", ")", "{", "grunt", ".", "fail", ".", "fatal", "(", "'Please supply translations'", ")", ";", "}", "// If a missing translation regex has been supplied report the missing count", "if", "(", "options", ".", "missingTranslationRegex", "!==", "null", ")", "{", "linter", ".", "setMissingTranslationRegex", "(", "options", ".", "missingTranslationRegex", ")", ";", "}", "// Add the translation keys to the linter", "options", ".", "translations", ".", "forEach", "(", "function", "(", "file", ")", "{", "var", "files", "=", "grunt", ".", "file", ".", "expand", "(", "file", ")", ";", "files", ".", "forEach", "(", "function", "(", "file", ")", "{", "if", "(", "!", "grunt", ".", "file", ".", "exists", "(", "file", ")", ")", "{", "grunt", ".", "fail", ".", "fatal", "(", "'File '", "+", "file", "+", "' does not exist'", ")", ";", "}", "linter", ".", "addKeys", "(", "grunt", ".", "file", ".", "readJSON", "(", "file", ")", ")", ";", "}", ")", ";", "}", ")", ";", "// Iterate through files and run them through the linter", "files", ".", "forEach", "(", "function", "(", "file", ")", "{", "if", "(", "!", "grunt", ".", "file", ".", "exists", "(", "file", ")", ")", "{", "grunt", ".", "fail", ".", "fatal", "(", "'File '", "+", "file", "+", "' does not exist'", ")", ";", "}", "linter", ".", "check", "(", "grunt", ".", "file", ".", "read", "(", "file", ")", ")", ";", "}", ")", ";", "}" ]

[ "Run", "the", "linter", "against", "the", "given", "files", "and", "options" ]

[ "function", "logError", "(", "e", ")", "{", "e", "=", "e", "instanceof", "Error", "?", "e", ":", "e", "?", "new", "Error", "(", "e", ")", ":", "null", ";", "if", "(", "e", ")", "{", "if", "(", "options", "&&", "util", ".", "isRegExp", "(", "options", ".", "hideTokenRegExp", ")", ")", "{", "e", ".", "message", "=", "e", ".", "message", ".", "replace", "(", "options", ".", "hideTokenRegExp", ",", "function", "(", "match", ",", "prefix", ",", "token", ",", "suffix", ")", "{", "return", "prefix", "+", "'[SECURE]'", "+", "suffix", ";", "}", ")", ";", "}", "errors", ".", "unshift", "(", "e", ")", ";", "rbot", ".", "log", ".", "error", "(", "e", ".", "stack", "||", "e", ".", "message", ")", ";", "}", "}" ]

[ "Logs", "an", "error" ]

[ "function", "loadFile", "(", "name", ",", "dir", ",", "options", ")", "{", "var", "pathname", "=", "path", ".", "normalize", "(", "path", ".", "join", "(", "options", ".", "prefix", ",", "name", ")", ")", ";", "var", "obj", "=", "{", "}", ";", "var", "filename", "=", "(", "obj", ".", "path", "=", "path", ".", "join", "(", "dir", ",", "name", ")", ")", ";", "var", "stats", "=", "fs", ".", "statSync", "(", "filename", ")", ";", "var", "buffer", "=", "fs", ".", "readFileSync", "(", "filename", ")", ";", "obj", ".", "cacheControl", "=", "options", ".", "cacheControl", ";", "obj", ".", "maxAge", "=", "obj", ".", "maxAge", "?", "obj", ".", "maxAge", ":", "options", ".", "maxAge", "||", "0", ";", "obj", ".", "type", "=", "obj", ".", "mime", "=", "mime", ".", "lookup", "(", "pathname", ")", "||", "\"application/octet-stream\"", ";", "obj", ".", "mtime", "=", "stats", ".", "mtime", ";", "obj", ".", "length", "=", "stats", ".", "size", ";", "obj", ".", "md5", "=", "crypto", ".", "createHash", "(", "\"md5\"", ")", ".", "update", "(", "buffer", ")", ".", "digest", "(", "\"base64\"", ")", ";", "debug", "(", "\"file: \"", "+", "JSON", ".", "stringify", "(", "obj", ",", "null", ",", "2", ")", ")", ";", "if", "(", "options", ".", "buffer", ")", "obj", ".", "buffer", "=", "buffer", ";", "buffer", "=", "null", ";", "return", "obj", ";", "}" ]

[ "load", "file", "and", "add", "file", "content", "to", "cache" ]

[ "function", "on", "(", "name", ",", "hdl", ")", "{", "var", "list", "=", "eventHandlers", "[", "name", "]", "||", "(", "eventHandlers", "[", "name", "]", "=", "[", "]", ")", ";", "list", ".", "push", "(", "hdl", ")", ";", "return", "this", ";", "}" ]

[ "Bind", "an", "event", "listener", "to", "the", "model", "." ]

[ "function", "(", "string", ")", "{", "var", "pattern", "=", "/", "(^|\\W)(\\w)(\\w*)", "/", "g", ",", "result", "=", "[", "]", ",", "match", ";", "while", "(", "pattern", ".", "exec", "(", "string", ")", ")", "{", "result", ".", "push", "(", "RegExp", ".", "$1", "+", "RegExp", ".", "$2", ".", "toUpperCase", "(", ")", "+", "RegExp", ".", "$3", ")", ";", "}", "return", "result", ".", "join", "(", "''", ")", ";", "}" ]

[ "Upper", "first", "letter" ]

[ "function", "(", "module", ")", "{", "for", "(", "var", "i", "=", "0", ";", "i", "<", "module", ".", "include", ".", "length", ";", "i", "++", ")", "{", "var", "curInclude", "=", "module", ".", "include", "[", "i", "]", ";", "if", "(", "curInclude", ".", "substr", "(", "0", ",", "2", ")", "==", "'^!'", ")", "{", "module", ".", "include", "[", "i", "]", "=", "curInclude", ".", "substr", "(", "2", ")", ";", "attachBuildIds", ".", "push", "(", "curInclude", ".", "substr", "(", "2", ")", ")", ";", "}", "}", "}" ]

[ "remove", "the", "^!", "builds", "from", "the", "current", "module" ]

[ "function", "(", "customEvent", ",", "callback", ",", "context", ",", "filter", ",", "prepend", ")", "{", "return", "this", ".", "_addMultiSubs", "(", "false", ",", "customEvent", ",", "callback", ",", "context", ",", "filter", ",", "prepend", ")", ";", "}" ]

[ "Subscribes", "to", "a", "customEvent", ".", "The", "callback", "will", "be", "executed", "after", "the", "defaultFn", "." ]

[ "function", "(", "customEvent", ",", "callback", ",", "context", ",", "filter", ",", "prepend", ")", "{", "return", "this", ".", "_addMultiSubs", "(", "true", ",", "customEvent", ",", "callback", ",", "context", ",", "filter", ",", "prepend", ")", ";", "}" ]

[ "Subscribes", "to", "a", "customEvent", ".", "The", "callback", "will", "be", "executed", "before", "the", "defaultFn", "." ]

[ "function", "(", "emitterName", ")", "{", "var", "instance", "=", "this", ",", "pattern", ";", "if", "(", "emitterName", ")", "{", "pattern", "=", "new", "RegExp", "(", "'^'", "+", "emitterName", "+", "':'", ")", ";", "instance", ".", "_ce", ".", "itsa_each", "(", "function", "(", "value", ",", "key", ")", "{", "key", ".", "match", "(", "pattern", ")", "&&", "(", "delete", "instance", ".", "_ce", "[", "key", "]", ")", ";", "}", ")", ";", "}", "else", "{", "instance", ".", "_ce", ".", "itsa_each", "(", "function", "(", "value", ",", "key", ")", "{", "delete", "instance", ".", "_ce", "[", "key", "]", ";", "}", ")", ";", "}", "}" ]

[ "Removes", "all", "event", "-", "definitions", "of", "an", "emitter", "specified", "by", "its", "emitterName", ".", "When", "emitterName", "is", "not", "set", "ALL", "event", "-", "definitions", "will", "be", "removed", "." ]

[ "function", "(", "e", ",", "checkFilter", ",", "before", ",", "preProcessor", ",", "subscribers", ")", "{", "// subscribers, plural", "var", "subs", ",", "passesThis", ",", "passesFilter", ";", "if", "(", "subscribers", "&&", "!", "e", ".", "status", ".", "halted", "&&", "!", "e", ".", "silent", ")", "{", "subs", "=", "before", "?", "subscribers", ".", "b", ":", "subscribers", ".", "a", ";", "subs", "&&", "subs", ".", "some", "(", "function", "(", "subscriber", ")", "{", "if", "(", "preProcessor", "&&", "preProcessor", "(", "subscriber", ",", "e", ")", ")", "{", "return", "true", ";", "}", "// check: does it need to be itself because of subscribing through 'this'", "passesThis", "=", "(", "!", "subscriber", ".", "s", "||", "(", "subscriber", ".", "o", "===", "e", ".", "target", ")", ")", ";", "// check: does it pass the filter", "passesFilter", "=", "(", "!", "checkFilter", "||", "!", "subscriber", ".", "f", "||", "subscriber", ".", "f", ".", "call", "(", "subscriber", ".", "o", ",", "e", ")", ")", ";", "if", "(", "passesThis", "&&", "passesFilter", ")", "{", "// finally: invoke subscriber", "subscriber", ".", "cb", ".", "call", "(", "subscriber", ".", "o", ",", "e", ")", ";", "}", "if", "(", "e", ".", "status", ".", "unSilencable", "&&", "e", ".", "silent", ")", "{", "console", ".", "warn", "(", "NAME", ",", "' event '", "+", "e", ".", "emitter", "+", "':'", "+", "e", ".", "type", "+", "' cannot made silent: this customEvent is defined as unSilencable'", ")", ";", "e", ".", "silent", "=", "false", ";", "}", "return", "e", ".", "silent", "||", "(", "before", "&&", "e", ".", "status", ".", "halted", ")", ";", "// remember to check whether it was halted for any reason", "}", ")", ";", "}", "}" ]

[ "Does", "the", "actual", "invocation", "of", "a", "subscriber", "." ]

[ "function", "askForGithubAuth", "(", "options", ",", "cb", ")", "{", "if", "(", "typeof", "options", "===", "'function'", ")", "{", "cb", "=", "options", ";", "options", "=", "{", "}", ";", "}", "options", "=", "options", "||", "{", "}", ";", "options", ".", "store", "=", "options", ".", "store", "||", "'default'", ";", "if", "(", "typeof", "options", ".", "store", "===", "'string'", ")", "{", "options", ".", "store", "=", "'for-github-auth.'", "+", "options", ".", "store", ";", "}", "loadQuestions", "(", "options", ".", "store", ")", ";", "var", "creds", "=", "{", "}", ";", "ask", ".", "once", "(", "'github-auth.type'", ",", "options", ",", "function", "(", "err", ",", "type", ")", "{", "if", "(", "err", ")", "return", "cb", "(", "err", ")", ";", "creds", ".", "type", "=", "type", ";", "ask", ".", "once", "(", "[", "'github-auth'", ",", "type", "]", ".", "join", "(", "'.'", ")", ",", "options", ",", "function", "(", "err", ",", "answer", ")", "{", "if", "(", "err", ")", "return", "cb", "(", "err", ")", ";", "if", "(", "type", "===", "'oauth'", ")", "{", "creds", ".", "token", "=", "answer", ";", "}", "else", "{", "creds", ".", "username", "=", "answer", ".", "username", ";", "creds", ".", "password", "=", "answer", ".", "password", ";", "}", "cb", "(", "null", ",", "creds", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Prompt", "a", "user", "for", "their", "github", "authentication", "credentials", ".", "Save", "the", "answer", "so", "they", "re", "only", "asked", "once", "." ]

[ "function", "StripMQ", "(", "input", ",", "options", ",", "formatOptions", ")", "{", "options", "||", "(", "options", "=", "{", "}", ")", ";", "formatOptions", "||", "(", "formatOptions", "=", "{", "}", ")", ";", "options", "=", "{", "type", ":", "options", ".", "type", "||", "'screen'", ",", "width", ":", "options", ".", "width", "||", "1024", ",", "'device-width'", ":", "options", "[", "'device-width'", "]", "||", "options", ".", "width", "||", "1024", ",", "height", ":", "options", ".", "height", "||", "768", ",", "'device-height'", ":", "options", "[", "'device-height'", "]", "||", "options", ".", "height", "||", "768", ",", "resolution", ":", "options", ".", "resolution", "||", "'1dppx'", ",", "orientation", ":", "options", ".", "orientation", "||", "'landscape'", ",", "'aspect-ratio'", ":", "options", "[", "'aspect-ratio'", "]", "||", "options", ".", "width", "/", "options", ".", "height", "||", "1024", "/", "768", ",", "color", ":", "options", ".", "color", "||", "3", "}", ";", "var", "tree", "=", "css", ".", "parse", "(", "input", ")", ";", "tree", "=", "stripMediaQueries", "(", "tree", ",", "options", ")", ";", "return", "css", ".", "stringify", "(", "tree", ",", "formatOptions", ")", ";", "}" ]

[ "strip", "media", "queries" ]

[ "function", "parseSpans", "(", "text", ")", "{", "var", "links", "=", "parseLinks", "(", "text", ")", ";", "/*Represented as\r\n\t\t[{\r\n\t\thref: \"http://yada\",\r\n\t\tstart: startIndex,\r\n\t\tend: endIndex\r\n\t\t}]*/", "var", "spans", "=", "[", "]", ";", "var", "lastSpan", "=", "null", ";", "function", "isPrefixedLinkSpan", "(", "span", ")", "{", "return", "span", "&&", "\"href\"", "in", "span", "&&", "span", ".", "prefix", "&&", "\"proposed\"", "in", "span", ".", "prefix", ";", "}", "function", "isTextSpan", "(", "span", ")", "{", "return", "span", "&&", "!", "(", "\"href\"", "in", "span", ")", ";", "}", "function", "addTextSpan", "(", "text", ")", "{", "//if the last span was a candidate\r", "if", "(", "isPrefixedLinkSpan", "(", "lastSpan", ")", ")", "{", "//make sure there is a valid suffix\r", "if", "(", "regexen", ".", "matchMarkdownLinkSuffix", ".", "test", "(", "text", ")", ")", "{", "//is there any valid whitespace remaining?\r", "text", "=", "RegExp", ".", "$3", ";", "//use the title (if specified)\r", "if", "(", "RegExp", ".", "$2", ")", "{", "lastSpan", ".", "title", "=", "RegExp", ".", "$2", ";", "}", "//use the proposed link text for the verified link\r", "lastSpan", ".", "text", "=", "lastSpan", ".", "prefix", ".", "proposed", ".", "linkText", ";", "//if there was valid prefix text, use it\r", "if", "(", "lastSpan", ".", "prefix", ".", "proposed", ".", "text", ")", "{", "lastSpan", ".", "prefix", ".", "text", "=", "lastSpan", ".", "prefix", ".", "proposed", ".", "text", ";", "delete", "lastSpan", ".", "prefix", "[", "\"proposed\"", "]", ";", "//clean up proposal\t\r", "}", "else", "{", "spans", ".", "splice", "(", "spans", ".", "length", "-", "2", ",", "1", ")", ";", "//remove prefix\r", "lastSpan", "=", "lastSpan", ".", "prefix", ";", "}", "}", "else", "{", "delete", "lastSpan", ".", "prefix", "[", "\"proposed\"", "]", ";", "//clean up proposal...no match...no modification\r", "}", "delete", "lastSpan", "[", "\"prefix\"", "]", ";", "//clean up prefix scratchwork\r", "}", "if", "(", "text", ")", "{", "lastSpan", "=", "{", "text", ":", "text", "}", ";", "spans", ".", "push", "(", "lastSpan", ")", ";", "}", "}", "function", "addLinkSpan", "(", "linkSpan", ")", "{", "var", "span", "=", "{", "href", ":", "linkSpan", ".", "href", "}", ";", "if", "(", "isTextSpan", "(", "lastSpan", ")", "&&", "regexen", ".", "matchMarkdownLinkPrefix", ".", "test", "(", "lastSpan", ".", "text", ")", ")", "{", "lastSpan", ".", "proposed", "=", "{", "text", ":", "RegExp", ".", "$1", ",", "linkText", ":", "RegExp", ".", "$2", "}", ";", "span", ".", "prefix", "=", "lastSpan", ";", "}", "lastSpan", "=", "span", ";", "spans", ".", "push", "(", "lastSpan", ")", ";", "}", "//No links found, all text\r", "if", "(", "links", ".", "length", "===", "0", ")", "{", "addTextSpan", "(", "text", ")", ";", "}", "//One or more links found\r", "else", "{", "var", "firstLink", "=", "links", "[", "0", "]", ",", "lastLink", "=", "links", "[", "links", ".", "length", "-", "1", "]", ";", "//Was there text before the first link?\r", "if", "(", "firstLink", ".", "start", ">", "0", ")", "{", "addTextSpan", "(", "text", ".", "substring", "(", "0", ",", "firstLink", ".", "start", ")", ")", ";", "}", "//Handle single link\r", "if", "(", "links", ".", "length", "===", "1", ")", "{", "addLinkSpan", "(", "firstLink", ")", ";", "}", "else", "{", "//push the firstLink\r", "addLinkSpan", "(", "firstLink", ")", ";", "var", "prevLink", "=", "firstLink", ";", "//loop from the second\r", "for", "(", "var", "i", "=", "1", ";", "i", "<", "links", ".", "length", ";", "i", "++", ")", "{", "//is there text between?\r", "if", "(", "links", "[", "i", "]", ".", "start", "-", "prevLink", ".", "end", ">=", "1", ")", "{", "addTextSpan", "(", "text", ".", "substring", "(", "prevLink", ".", "end", ",", "links", "[", "i", "]", ".", "start", ")", ")", ";", "}", "//add link\r", "addLinkSpan", "(", "prevLink", "=", "links", "[", "i", "]", ")", ";", "}", "}", "//Was there text after the links?\r", "if", "(", "lastLink", ".", "end", "<", "(", "text", ".", "length", ")", ")", "{", "addTextSpan", "(", "text", ".", "substring", "(", "lastLink", ".", "end", ")", ")", ";", "}", "}", "return", "spans", ";", "}" ]

[ "Parses", "the", "text", "into", "an", "array", "of", "spans" ]

[ "function", "makeFuncAsciiDomainReplace", "(", "ctx", ")", "{", "return", "function", "(", "asciiDomain", ")", "{", "var", "asciiStartPosition", "=", "ctx", ".", "domain", ".", "indexOf", "(", "asciiDomain", ",", "ctx", ".", "asciiEndPosition", ")", ";", "ctx", ".", "asciiEndPosition", "=", "asciiStartPosition", "+", "asciiDomain", ".", "length", ";", "ctx", ".", "lastLink", "=", "{", "href", ":", "asciiDomain", ",", "start", ":", "ctx", ".", "cursor", ".", "start", "+", "asciiStartPosition", ",", "end", ":", "ctx", ".", "cursor", ".", "start", "+", "ctx", ".", "asciiEndPosition", "}", ";", "ctx", ".", "lastLinkInvalidMatch", "=", "asciiDomain", ".", "match", "(", "regexen", ".", "invalidShortDomain", ")", ";", "if", "(", "!", "ctx", ".", "lastLinkInvalidMatch", ")", "{", "ctx", ".", "links", ".", "push", "(", "ctx", ".", "lastLink", ")", ";", "}", "}", ";", "}" ]

[ "return", "a", "closure", "to", "handle", "a", "custom", "ascii", "domain", "replace" ]

[ "function", "(", "stdout", ",", "next", ")", "{", "var", "lines", "=", "stdout", ".", "split", "(", "\"\\n\"", ")", ";", "var", "filenames", "=", "_", ".", "transform", "(", "lines", ",", "function", "(", "result", ",", "line", ")", "{", "var", "status", "=", "line", ".", "slice", "(", "0", ",", "2", ")", ";", "if", "(", "regExp", ".", "test", "(", "status", ")", ")", "{", "result", ".", "push", "(", "_", ".", "last", "(", "line", ".", "split", "(", "' '", ")", ")", ")", ";", "}", "}", ")", ";", "next", "(", "null", ",", "filenames", ")", ";", "}" ]

[ "collect", "filename", "by", "status", "stdout" ]

[ "function", "(", "filenames", ")", "{", "var", "isIn", "=", "_", ".", "some", "(", "filenames", ",", "function", "(", "line", ")", "{", "return", "file", ".", "path", ".", "indexOf", "(", "line", ")", "!==", "-", "1", ";", "}", ")", ";", "if", "(", "isIn", ")", "{", "self", ".", "push", "(", "file", ")", ";", "}", "callback", "(", ")", ";", "}" ]

[ "filter", "file", "from", "stream" ]

[ "function", "Message", "(", "rawText", ")", "{", "this", ".", "rawText", "=", "rawText", ";", "this", ".", "_parsed", "=", "false", ";", "this", ".", "_isFetch", "=", "false", ";", "this", ".", "_isNoop", "=", "false", ";", "this", ".", "_list", "=", "[", "]", ";", "this", ".", "_search", "=", "[", "]", ";", "this", ".", "_fetch", "=", "{", "text", ":", "''", "}", ";", "this", ".", "_parse", "(", ")", ";", "}" ]

[ "Create", "a", "new", "instance", "of", "Message", ".", "Message", "parses", "a", "messages", "of", "th", "IMAP", "server", "." ]

[ "function", "(", ")", "{", "if", "(", "this", ".", "_lock", ")", "return", "this", ".", "_lock", "=", "true", "let", "task", "=", "this", ".", "_tasks", ".", "shift", "(", ")", "let", "tstType", "=", "this", ".", "error", "?", "[", "'catch'", ",", "'end'", "]", ":", "[", "'then'", ",", "'end'", "]", "while", "(", "task", "&&", "!", "~", "tstType", ".", "indexOf", "(", "task", ".", "type", ")", ")", "{", "task", "=", "this", ".", "_tasks", ".", "shift", "(", ")", "}", "if", "(", "task", ")", "{", "let", "cb", "=", "(", "err", ",", "res", ")", "=>", "{", "this", ".", "error", "=", "err", "this", ".", "result", "=", "res", "||", "this", ".", "result", "this", ".", "_lock", "=", "false", "this", ".", "_run", "(", ")", "}", "let", "fn", "=", "task", ".", "fn", "if", "(", "task", ".", "type", "===", "'end'", ")", "{", "// .end", "fn", "(", "this", ".", "error", ",", "this", ".", "result", ")", "}", "else", "{", "try", "{", "if", "(", "task", ".", "type", "===", "'catch'", ")", "{", "// .catch", "fn", "(", "this", ".", "error", ",", "this", ".", "result", ",", "cb", ")", "}", "else", "{", "// .then", "fn", "(", "this", ".", "result", ",", "cb", ")", "}", "}", "catch", "(", "e", ")", "{", "cb", "(", "e", ")", "}", "}", "}", "else", "{", "this", ".", "_lock", "=", "false", "}", "}" ]

[ "runs", "the", "next", "function" ]

[ "function", "(", "time", ")", "{", "var", "self", "=", "this", ";", "self", ".", "eventDetection", ".", "recordRelease", "(", "time", ")", ";", "if", "(", "self", ".", "eventDetection", ".", "isLongPress", "(", ")", ")", "{", "// this is a \"long-press\" - reset detection states and notify the \"long-press\" observers", "self", ".", "eventDetection", ".", "reset", "(", ")", ";", "self", ".", "_notifyObservers", "(", "self", ".", "onLongPressCallbackRegistry", ")", ";", "}", "else", "{", "if", "(", "self", ".", "eventDetection", ".", "onReleaseCount", ">=", "2", ")", "{", "// this is a double-press (or more) event, so notify the \"double-press\" observers", "self", ".", "eventDetection", ".", "reset", "(", ")", ";", "self", ".", "_notifyObservers", "(", "self", ".", "onDoublePressCallbackRegistry", ")", ";", "}", "setTimeout", "(", "function", "(", ")", "{", "if", "(", "self", ".", "eventDetection", ".", "onReleaseCount", "==", "1", ")", "{", "// second press did not occur within the allotted time, so notify the \"short-press\" observers", "self", ".", "eventDetection", ".", "reset", "(", ")", ";", "self", ".", "_notifyObservers", "(", "self", ".", "onShortPressCallbackRegistry", ")", ";", "}", "}", ",", "300", ")", ";", "// @-@:p0 make this configurable?", "}", "}" ]

[ "Handle", "the", "button", "-", "release", "event", "generated", "by", "the", "button", "associated", "with", "this", "ButtonMgr", "instance", "." ]

[ "function", "longWait", "(", "message", ",", "timer", ",", "cb", ")", "{", "setTimeout", "(", "function", "(", ")", "{", "console", ".", "log", "(", "message", ")", ";", "cb", "(", "\"pang\"", ")", ";", "//always return \"pang\"", "}", ",", "timer", ")", ";", "//wait one second before logging", "}" ]

[ "scenario", "2", "skip", "will", "call", "the", "next", "function", "as", "soon", "as", "the", "execution", "context", "leaves", "the", "function", "and", "will", "ignore", "anything", "passed", "in", "the", "callback" ]

[ "function", "resolveDeps", "(", "args", ")", "{", "return", "deps", ".", "map", "(", "function", "(", "dep", ")", "{", "if", "(", "args", "&&", "args", ".", "length", "&&", "typeof", "dep", "===", "'number'", ")", "{", "return", "args", "[", "dep", "]", ";", "}", "dep", "=", "that", "[", "dep", "]", ";", "if", "(", "dep", ")", "{", "return", "dep", ";", "}", "}", ")", ";", "}" ]

[ "Returns", "the", "dependencies", "of", "the", "current", "dependency", "and", "merges", "in", "any", "supplied", "named", "arguments", ".", "Arguments", "take", "precedence", "over", "dependencies", "in", "the", "container", "." ]

[ "function", "getInst", "(", "bind", ",", "args", ")", "{", "args", "=", "resolveDeps", "(", "args", ")", ";", "return", "isCtor", "?", "applyCtor", "(", "func", ",", "args", ")", ":", "func", ".", "apply", "(", "bind", ",", "args", ")", ";", "}" ]

[ "Returns", "a", "dependency", ".", "It", "checks", "to", "see", "if", "it", "s", "a", "constructor", "function", "or", "a", "regular", "function", "and", "calls", "it", "accordingly", "." ]

[ "function", "resolveInst", "(", "bind", ",", "args", ")", "{", "return", "isTransient", "?", "getInst", "(", "bind", ",", "args", ")", ":", "cache", "||", "(", "cache", "=", "getInst", "(", "bind", ")", ")", ";", "}" ]

[ "Resolves", "the", "dependency", "based", "on", "if", "it", "s", "a", "singleton", "or", "transient", "dependency", ".", "Both", "forms", "allow", "arguments", ".", "If", "it", "s", "a", "singleton", "then", "no", "arguments", "are", "allowed", ".", "If", "it", "s", "transient", "named", "arguments", "are", "allowed", "." ]

[ "function", "init", "(", "func", ")", "{", "func", "=", "ensureFunc", "(", "func", ")", ";", "cache", "=", "undefined", ";", "deps", "=", "parseDepsFromFunc", "(", "func", ")", ";", "}" ]

[ "Initialises", "or", "re", "-", "initialises", "the", "state", "of", "the", "dependency", "." ]

[ "function", "getItemDefinedGroups", "(", ")", "{", "var", "groups", "=", "{", "}", ",", "itemName", ",", "item", ",", "itemToolbar", ",", "group", ",", "order", ";", "for", "(", "itemName", "in", "editor", ".", "ui", ".", "items", ")", "{", "item", "=", "editor", ".", "ui", ".", "items", "[", "itemName", "]", ";", "itemToolbar", "=", "item", ".", "toolbar", "||", "'others'", ";", "if", "(", "itemToolbar", ")", "{", "// Break the toolbar property into its parts: \"group_name[,order]\".\r", "itemToolbar", "=", "itemToolbar", ".", "split", "(", "','", ")", ";", "group", "=", "itemToolbar", "[", "0", "]", ";", "order", "=", "parseInt", "(", "itemToolbar", "[", "1", "]", "||", "-", "1", ",", "10", ")", ";", "// Initialize the group, if necessary.\r", "groups", "[", "group", "]", "||", "(", "groups", "[", "group", "]", "=", "[", "]", ")", ";", "// Push the data used to build the toolbar later.\r", "groups", "[", "group", "]", ".", "push", "(", "{", "name", ":", "itemName", ",", "order", ":", "order", "}", ")", ";", "}", "}", "// Put the items in the right order.\r", "for", "(", "group", "in", "groups", ")", "{", "groups", "[", "group", "]", "=", "groups", "[", "group", "]", ".", "sort", "(", "function", "(", "a", ",", "b", ")", "{", "return", "a", ".", "order", "==", "b", ".", "order", "?", "0", ":", "b", ".", "order", "<", "0", "?", "-", "1", ":", "a", ".", "order", "<", "0", "?", "1", ":", "a", ".", "order", "<", "b", ".", "order", "?", "-", "1", ":", "1", ";", "}", ")", ";", "}", "return", "groups", ";", "}" ]

[ "Returns", "an", "object", "containing", "all", "toolbar", "groups", "used", "by", "ui", "items", "." ]