Datasets:

---

CM

/

codexglue_code2text_javascript

like 12

[ "function", "interceptDeath", "(", "process", ",", "events", ")", "{", "var", "closeEvent", "=", "helpers", ".", "support", ".", "close", ";", "// all channels are closed", "process", ".", "once", "(", "closeEvent", "?", "'close'", ":", "'exit'", ",", "events", ".", "close", ")", ";", "// the process died", "if", "(", "closeEvent", ")", "{", "process", ".", "once", "(", "'exit'", ",", "events", ".", "exit", ")", ";", "}", "else", "{", "// intercept internal onexit call", "var", "internalHandle", "=", "process", ".", "_internal", ".", "onexit", ";", "process", ".", "_internal", ".", "onexit", "=", "function", "(", ")", "{", "events", ".", "exit", "(", ")", ";", "internalHandle", ".", "apply", "(", "this", ",", "arguments", ")", ";", "}", ";", "}", "}" ]

[ "An", "helper", "function", "there", "will", "intercept", "internal", "exit", "event", "if", "necessary" ]

[ "function", "hashsum", "(", "hash", ",", "str", ")", "{", "// you have to convert from string to array buffer", "var", "ab", "// you have to represent the algorithm as an object ", ",", "algo", "=", "{", "name", ":", "algos", "[", "hash", "]", "}", ";", "if", "(", "'string'", "===", "typeof", "str", ")", "{", "ab", "=", "str2ab", "(", "str", ")", ";", "}", "else", "{", "ab", "=", "str", ";", "}", "// All crypto digest methods return a promise", "return", "crypto", ".", "subtle", ".", "digest", "(", "algo", ",", "ab", ")", ".", "then", "(", "function", "(", "digest", ")", "{", "// you have to convert the ArrayBuffer to a DataView and then to a hex String", "return", "ab2hex", "(", "digest", ")", ";", "}", ")", ".", "catch", "(", "function", "(", "e", ")", "{", "// if you specify an unsupported digest algorithm or non-ArrayBuffer, you'll get an error", "console", ".", "error", "(", "'sha1sum ERROR'", ")", ";", "console", ".", "error", "(", "e", ")", ";", "throw", "e", ";", "}", ")", ";", "}" ]

[ "a", "more", "general", "convenience", "function" ]

[ "function", "ab2hex", "(", "ab", ")", "{", "var", "dv", "=", "new", "DataView", "(", "ab", ")", ",", "i", ",", "len", ",", "hex", "=", "''", ",", "c", ";", "for", "(", "i", "=", "0", ",", "len", "=", "dv", ".", "byteLength", ";", "i", "<", "len", ";", "i", "+=", "1", ")", "{", "c", "=", "dv", ".", "getUint8", "(", "i", ")", ".", "toString", "(", "16", ")", ";", "if", "(", "c", ".", "length", "<", "2", ")", "{", "c", "=", "'0'", "+", "c", ";", "}", "hex", "+=", "c", ";", "}", "return", "hex", ";", "}" ]

[ "convert", "from", "arraybuffer", "to", "hex" ]

[ "function", "str2ab", "(", "stringToEncode", ",", "insertBom", ")", "{", "stringToEncode", "=", "stringToEncode", ".", "replace", "(", "/", "\\r\\n", "/", "g", ",", "\"\\n\"", ")", ";", "var", "utftext", "=", "[", "]", ",", "n", ",", "c", ";", "if", "(", "true", "===", "insertBom", ")", "{", "utftext", "[", "0", "]", "=", "0xef", ";", "utftext", "[", "1", "]", "=", "0xbb", ";", "utftext", "[", "2", "]", "=", "0xbf", ";", "}", "for", "(", "n", "=", "0", ";", "n", "<", "stringToEncode", ".", "length", ";", "n", "+=", "1", ")", "{", "c", "=", "stringToEncode", ".", "charCodeAt", "(", "n", ")", ";", "if", "(", "c", "<", "128", ")", "{", "utftext", "[", "utftext", ".", "length", "]", "=", "c", ";", "}", "else", "if", "(", "(", "c", ">", "127", ")", "&&", "(", "c", "<", "2048", ")", ")", "{", "utftext", "[", "utftext", ".", "length", "]", "=", "(", "c", ">>", "6", ")", "|", "192", ";", "utftext", "[", "utftext", ".", "length", "]", "=", "(", "c", "&", "63", ")", "|", "128", ";", "}", "else", "{", "utftext", "[", "utftext", ".", "length", "]", "=", "(", "c", ">>", "12", ")", "|", "224", ";", "utftext", "[", "utftext", ".", "length", "]", "=", "(", "(", "c", ">>", "6", ")", "&", "63", ")", "|", "128", ";", "utftext", "[", "utftext", ".", "length", "]", "=", "(", "c", "&", "63", ")", "|", "128", ";", "}", "}", "return", "new", "Uint8Array", "(", "utftext", ")", ".", "buffer", ";", "}" ]

[ "convert", "from", "string", "to", "arraybuffer" ]

[ "function", "escapeCurly", "(", "text", ",", "escapes", ")", "{", "var", "newText", "=", "text", ".", "slice", "(", "0", ",", "escapes", "[", "0", "]", ")", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "escapes", ".", "length", ";", "i", "+=", "3", ")", "{", "var", "from", "=", "escapes", "[", "i", "]", ";", "var", "to", "=", "escapes", "[", "i", "+", "1", "]", ";", "var", "type", "=", "escapes", "[", "i", "+", "2", "]", ";", "// Which escape do we have here?", "if", "(", "type", "===", "0", ")", "{", "newText", "+=", "'{{'", ";", "}", "else", "{", "newText", "+=", "'}}'", ";", "}", "newText", "+=", "text", ".", "slice", "(", "to", ",", "escapes", "[", "i", "+", "3", "]", ")", ";", "}", "return", "newText", ";", "}" ]

[ "Return", "a", "text", "where", "all", "escapes", "as", "defined", "in", "the", "toplevel", "function", "are", "indeed", "escaped", "." ]

[ "function", "(", "input", ",", "output", ",", "literal", ",", "cb", ")", "{", "var", "text", "=", "''", ";", "input", ".", "on", "(", "'data'", ",", "function", "gatherer", "(", "data", ")", "{", "text", "+=", "''", "+", "data", ";", "// Converting to UTF-8 string.", "}", ")", ";", "input", ".", "on", "(", "'end'", ",", "function", "writer", "(", ")", "{", "try", "{", "var", "write", "=", "function", "(", "data", ")", "{", "output", ".", "write", "(", "data", ")", ";", "}", ";", "template", "(", "text", ")", "(", "write", ",", "literal", ")", ";", "}", "catch", "(", "e", ")", "{", "if", "(", "cb", ")", "{", "cb", "(", "e", ")", ";", "}", "}", "finally", "{", "// There are streams you cannot end.", "try", "{", "output", ".", "end", "(", ")", ";", "}", "catch", "(", "e", ")", "{", "}", "finally", "{", "if", "(", "cb", ")", "{", "cb", "(", "null", ")", ";", "}", "}", "}", "}", ")", ";", "}" ]

[ "Main", "entry", "point", ".", "input", "and", "output", "are", "two", "streams", "one", "readable", "the", "other", "writable", "." ]

[ "function", "(", "input", ")", "{", "var", "code", "=", "'var $_isidentifier = '", "+", "$_isidentifier", ".", "toString", "(", ")", "+", "';\\n'", "+", "// FIXME: could we remove that eval?", "'eval(('", "+", "literaltovar", ".", "toString", "(", ")", "+", "')($_scope));\\n'", ";", "code", "+=", "'var $_parsers = {\\n'", ";", "var", "parsernames", "=", "Object", ".", "keys", "(", "parsers", ")", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "parsernames", ".", "length", ";", "i", "++", ")", "{", "code", "+=", "' '", "+", "JSON", ".", "stringify", "(", "parsernames", "[", "i", "]", ")", "+", "': '", "+", "parsers", "[", "parsernames", "[", "i", "]", "]", ".", "toString", "(", ")", "+", "',\\n'", ";", "}", ";", "code", "+=", "'}\\n'", ";", "code", "+=", "'var $_written = \"\";\\n'", "+", "'var $_write = function(data) { $_written += data; };\\n'", ";", "code", "+=", "compile", "(", "input", ")", ";", "code", "+=", "'$_written\\n'", ";", "return", "function", "(", "$_write", ",", "$_scope", ",", "timeout", ",", "cb", ")", "{", "var", "res", ";", "try", "{", "res", "=", "vm", ".", "runInNewContext", "(", "code", ",", "{", "$_scope", ":", "$_scope", "}", ",", "{", "timeout", ":", "timeout", "||", "1000", "}", ")", ";", "}", "catch", "(", "err", ")", "{", "console", ".", "error", "(", "err", ")", ";", "$_write", "(", "''", ")", ";", "if", "(", "cb", ")", "{", "cb", "(", "err", ")", ";", "}", "return", ";", "}", "$_write", "(", "res", ")", ";", "if", "(", "cb", ")", "{", "cb", "(", "null", ")", ";", "}", "}", ";", "}" ]

[ "Like", "template", "with", "a", "timeout", "and", "sandbox", "." ]

[ "function", "(", "input", ")", "{", "var", "code", "=", "'var $_parsers = {\\n'", ";", "var", "parsernames", "=", "Object", ".", "keys", "(", "parsers", ")", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "parsernames", ".", "length", ";", "i", "++", ")", "{", "code", "+=", "' '", "+", "JSON", ".", "stringify", "(", "parsernames", "[", "i", "]", ")", "+", "': '", "+", "parsers", "[", "parsernames", "[", "i", "]", "]", ".", "toString", "(", ")", "+", "',\\n'", ";", "}", ";", "code", "+=", "'}\\n'", ";", "code", "+=", "compile", "(", "input", ")", "+", "'\\nif (typeof $_end === \"function\") {$_end();}'", ";", "var", "script", "=", "new", "vm", ".", "Script", "(", "code", ",", "{", "timeout", ":", "4", "*", "60", "*", "1000", "}", ")", ";", "var", "runner", "=", "function", "(", "scope", ")", "{", "var", "output", "=", "''", ";", "var", "pipeOpen", "=", "false", ";", "var", "ended", "=", "false", ";", "var", "stream", "=", "new", "Readable", "(", "{", "encoding", ":", "'utf8'", ",", "read", ":", "function", "(", ")", "{", "pipeOpen", "=", "true", ";", "if", "(", "ended", "&&", "output", "===", "''", ")", "{", "pipeOpen", "=", "this", ".", "push", "(", "null", ")", ";", "}", "else", "if", "(", "output", "!==", "''", ")", "{", "pipeOpen", "=", "this", ".", "push", "(", "output", ")", ";", "output", "=", "''", ";", "}", "}", ",", "}", ")", ";", "scope", ".", "$_scope", "=", "scope", ";", "scope", ".", "$_write", "=", "function", "(", "data", ")", "{", "output", "+=", "''", "+", "data", ";", "if", "(", "pipeOpen", "&&", "output", "!==", "''", ")", "{", "pipeOpen", "=", "stream", ".", "push", "(", "output", ")", ";", "output", "=", "''", ";", "}", "}", ";", "scope", ".", "$_end", "=", "function", "(", ")", "{", "ended", "=", "true", ";", "if", "(", "pipeOpen", ")", "{", "stream", ".", "push", "(", "null", ")", ";", "}", "}", ";", "script", ".", "runInNewContext", "(", "scope", ")", "return", "stream", ";", "}", ";", "runner", ".", "code", "=", "code", ";", "return", "runner", ";", "}" ]

[ "string", "is", "a", "template", ".", "Return", "a", "function", "that", "takes", "a", "scope", "and", "returns", "a", "readable", "stream", "." ]

[ "function", "(", "applicationId", ",", "deviceDetails", ",", "environment", ")", "{", "if", "(", "!", "applicationId", ")", "{", "logger", ".", "wtf", "(", "'No applicationID specified'", ")", ";", "}", "this", ".", "applicationId", "=", "applicationId", ";", "this", ".", "deviceDetails", "=", "deviceDetails", ";", "this", ".", "environment", "=", "environment", ";", "this", ".", "_currentAds", "=", "[", "]", ";", "this", ".", "_loadingAds", "=", "[", "]", ";", "this", ".", "_adsWithoutImages", "=", "[", "]", ";", "}" ]

[ "Creates", "a", "new", "instance", "of", "the", "adManager" ]

[ "function", "getNewToken", "(", "credentials", ",", "oauth2Client", ",", "callback", ")", "{", "var", "authUrl", "=", "oauth2Client", ".", "generateAuthUrl", "(", "{", "access_type", ":", "'offline'", ",", "scope", ":", "SCOPES", "}", ")", ";", "console", ".", "log", "(", "'Authorize this app by visiting this url: '", ",", "authUrl", ")", ";", "var", "rl", "=", "readline", ".", "createInterface", "(", "{", "input", ":", "process", ".", "stdin", ",", "output", ":", "process", ".", "stdout", "}", ")", ";", "rl", ".", "question", "(", "'Enter the code from that page here: '", ",", "function", "(", "code", ")", "{", "rl", ".", "close", "(", ")", ";", "oauth2Client", ".", "getToken", "(", "code", ",", "function", "(", "err", ",", "token", ")", "{", "if", "(", "err", ")", "{", "console", ".", "log", "(", "'Error while trying to retrieve access token'", ",", "err", ")", ";", "return", ";", "}", "oauth2Client", ".", "credentials", "=", "token", ";", "storeToken", "(", "credentials", ",", "token", ")", ";", "callback", "(", "oauth2Client", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Get", "and", "store", "new", "token", "after", "prompting", "for", "user", "authorization", "and", "then", "execute", "the", "given", "callback", "with", "the", "authorized", "OAuth2", "client", "." ]

[ "function", "listLabels", "(", "auth", ")", "{", "var", "gmail", "=", "google", ".", "gmail", "(", "'v1'", ")", ";", "gmail", ".", "users", ".", "labels", ".", "list", "(", "{", "auth", ":", "auth", ",", "userId", ":", "'me'", ",", "}", ",", "function", "(", "err", ",", "response", ")", "{", "if", "(", "err", ")", "{", "console", ".", "log", "(", "'The API returned an error: '", "+", "err", ")", ";", "return", ";", "}", "var", "labels", "=", "response", ".", "labels", ";", "if", "(", "labels", ".", "length", "===", "0", ")", "{", "console", ".", "log", "(", "'No labels found.'", ")", ";", "}", "else", "{", "console", ".", "log", "(", "'Labels:'", ")", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "labels", ".", "length", ";", "i", "++", ")", "{", "var", "label", "=", "labels", "[", "i", "]", ";", "console", ".", "log", "(", "'- %s'", ",", "label", ".", "name", ")", ";", "}", "}", "}", ")", ";", "}" ]

[ "Lists", "the", "labels", "in", "the", "user", "s", "account", "." ]

[ "function", "processDeltas", "(", "deltas", ")", "{", "let", "updates", "=", "{", "changed", ":", "{", "}", ",", "removed", ":", "{", "}", "}", ";", "deltas", ".", "forEach", "(", "delta", "=>", "{", "const", "entityType", "=", "delta", "[", "0", "]", ";", "const", "changeType", "=", "delta", "[", "1", "]", ";", "const", "entity", "=", "delta", "[", "2", "]", ";", "const", "key", "=", "_getEntityKey", "(", "entityType", ",", "entity", ")", ";", "if", "(", "!", "key", ")", "{", "// We don't know how to manage this entity, so ignore it.", "return", ";", "}", "const", "entityGroup", "=", "_getEntityGroup", "(", "entityType", ")", ";", "const", "updateCollection", "=", "updates", "[", "changeType", "+", "'d'", "]", ";", "if", "(", "!", "updateCollection", "[", "entityGroup", "]", ")", "{", "updateCollection", "[", "entityGroup", "]", "=", "{", "}", ";", "}", "updateCollection", "[", "entityGroup", "]", "[", "key", "]", "=", "_parseEntity", "(", "entityType", ",", "entity", ")", ";", "}", ")", ";", "return", "updates", ";", "}" ]

[ "Get", "the", "consolidated", "updates", "from", "the", "deltas", "." ]

[ "function", "_getEntityKey", "(", "entityType", ",", "entity", ")", "{", "switch", "(", "entityType", ")", "{", "case", "'remote-application'", ":", "case", "'application'", ":", "case", "'unit'", ":", "return", "entity", ".", "name", ";", "case", "'machine'", ":", "case", "'relation'", ":", "return", "entity", ".", "id", ";", "case", "'annotation'", ":", "return", "entity", ".", "tag", ";", "default", ":", "// This is an unknown entity type so ignore it as we don't know how to", "// handle it.", "return", "null", ";", "}", "}" ]

[ "Get", "the", "identifier", "for", "the", "entity", "based", "upon", "its", "type", "." ]

[ "function", "_parseEntity", "(", "entityType", ",", "entity", ")", "{", "switch", "(", "entityType", ")", "{", "case", "'remote-application'", ":", "return", "parsers", ".", "parseRemoteApplication", "(", "entity", ")", ";", "case", "'application'", ":", "return", "parsers", ".", "parseApplication", "(", "entity", ")", ";", "case", "'unit'", ":", "return", "parsers", ".", "parseUnit", "(", "entity", ")", ";", "case", "'machine'", ":", "return", "parsers", ".", "parseMachine", "(", "entity", ")", ";", "case", "'relation'", ":", "return", "parsers", ".", "parseRelation", "(", "entity", ")", ";", "case", "'annotation'", ":", "return", "parsers", ".", "parseAnnotation", "(", "entity", ")", ";", "default", ":", "// This is an unknown entity type so ignore it as we don't know how to", "// handle it.", "return", "null", ";", "}", "}" ]

[ "Parse", "the", "entity", "response", "into", "a", "friendly", "format", "." ]

[ "function", "getMilliseconds", "(", "time", ")", "{", "if", "(", "typeof", "time", "==", "'number'", ")", "{", "return", "time", ";", "}", "var", "matches", "=", "time", ".", "match", "(", "/", "(^\\d*\\.?\\d*)(\\w*)", "/", ")", ";", "var", "num", "=", "matches", "&&", "matches", "[", "1", "]", ";", "var", "unit", "=", "matches", "&&", "matches", "[", "2", "]", ";", "if", "(", "!", "num", ".", "length", ")", "{", "return", "0", ";", "}", "num", "=", "parseFloat", "(", "num", ")", ";", "var", "mult", "=", "msUnits", "[", "unit", "]", "||", "1", ";", "return", "num", "*", "mult", ";", "}" ]

[ "munge", "time", "-", "like", "parameter", "into", "millisecond", "number", "0", ".", "4s", "-", ">", "40" ]

[ "function", "compileFile", "(", "srcFullPath", ",", "saveOutFullPath", ",", "onlyCopy", ")", "{", "var", "options", "=", "arguments", ".", "length", ">", "3", "&&", "arguments", "[", "3", "]", "!==", "undefined", "?", "arguments", "[", "3", "]", ":", "{", "}", ";", "var", "content", "=", "fs", ".", "readFileSync", "(", "srcFullPath", ",", "'utf8'", ")", ";", "//when get file content empty, maybe file is locked", "if", "(", "!", "content", ")", "{", "return", ";", "}", "// only copy file content", "if", "(", "onlyCopy", ")", "{", "fse", ".", "copySync", "(", "srcFullPath", ",", "saveOutFullPath", ")", ";", "return", ";", "}", "try", "{", "var", "startTime", "=", "Date", ".", "now", "(", ")", ";", "var", "data", "=", "compileByBabel", "(", "content", ",", "{", "filename", ":", "srcFullPath", "// sourceMaps: true,", "// sourceFileName: relativePath", "}", ")", ";", "var", "endTime", "=", "Date", ".", "now", "(", ")", ";", "if", "(", "options", ".", "debug", ")", "{", "console", ".", "log", "(", "'Compile file '", "+", "srcFullPath", ",", "'Babel cost '", "+", "(", "endTime", "-", "startTime", ")", "+", "' ms'", ")", ";", "}", "// save file", "fse", ".", "outputFileSync", "(", "saveOutFullPath", ",", "data", ".", "code", ")", ";", "return", "true", ";", "}", "catch", "(", "e", ")", "{", "console", ".", "error", "(", "'compile file '", "+", "srcFullPath", "+", "' error'", ",", "e", ")", ";", "}", "return", "false", ";", "}" ]

[ "compile", "single", "file" ]

[ "function", "getFiles", "(", "paths", ")", "{", "var", "result", "=", "fileUtil", ".", "getAllFiles", "(", "paths", ")", ";", "var", "files", "=", "result", ".", "map", "(", "function", "(", "item", ")", "{", "return", "item", ".", "relativePath", ";", "// return path.join(item.basePath, item.relativePath);", "}", ")", ";", "return", "files", ";", "}" ]

[ "get", "all", "files" ]

[ "function", "TypedOneOf", "(", "config", ")", "{", "const", "oneOf", "=", "this", ";", "// validate oneOf", "if", "(", "!", "config", ".", "hasOwnProperty", "(", "'oneOf'", ")", ")", "{", "throw", "Error", "(", "'Invalid configuration. Missing required one-of property: oneOf. Must be an array of schema configurations.'", ")", ";", "}", "if", "(", "!", "Array", ".", "isArray", "(", "config", ".", "oneOf", ")", "||", "config", ".", "oneOf", ".", "filter", "(", "v", "=>", "!", "v", "||", "typeof", "v", "!==", "'object'", ")", ".", "length", ")", "{", "throw", "Error", "(", "'Invalid configuration value for property: oneOf. Must be an array of schema configurations.'", ")", ";", "}", "// create each unique schema", "const", "hashes", "=", "{", "}", ";", "const", "schemas", "=", "config", ".", "oneOf", ".", "map", "(", "item", "=>", "FullyTyped", "(", "item", ")", ")", ".", "filter", "(", "schema", "=>", "{", "const", "hash", "=", "schema", ".", "hash", "(", ")", ";", "if", "(", "hashes", "[", "hash", "]", ")", "return", "false", ";", "hashes", "[", "hash", "]", "=", "true", ";", "return", "true", ";", "}", ")", ";", "// define properties", "Object", ".", "defineProperties", "(", "oneOf", ",", "{", "oneOf", ":", "{", "/**\n * @property\n * @name TypedOneOf#oneOf\n * @type {object}\n */", "value", ":", "schemas", ",", "writable", ":", "false", "}", "}", ")", ";", "return", "oneOf", ";", "}" ]

[ "Create", "a", "TypedOneOf", "instance", "." ]

[ "function", "bin", "(", "argv", ")", "{", "program", ".", "version", "(", "pkg", ".", "version", ")", ".", "usage", "(", "'[options] <sourceURI> <destURI>'", ")", ".", "parse", "(", "argv", ")", "var", "sourceURI", "=", "program", ".", "args", "[", "0", "]", "var", "destURI", "=", "program", ".", "args", "[", "1", "]", "if", "(", "!", "sourceURI", "||", "!", "destURI", ")", "{", "program", ".", "help", "(", ")", "}", "shell", ".", "mv", "(", "sourceURI", ",", "destURI", ",", "function", "(", "err", ",", "res", ",", "uri", ")", "{", "if", "(", "!", "err", ")", "{", "debug", "(", "res", ")", "}", "else", "{", "console", ".", "error", "(", "err", ")", "}", "}", ")", "}" ]

[ "mv", "as", "a", "command", "." ]

[ "function", "(", "evt", ")", "{", "if", "(", "evt", "!==", "'change'", "&&", "evt", "!==", "'rename'", ")", "{", "return", ";", "}", "fs", ".", "stat", "(", "file", ",", "function", "(", "err", ",", "current", ")", "{", "if", "(", "err", ")", "{", "self", ".", "logger_", ".", "error", "(", "err", ".", "message", ")", ";", "self", ".", "emit", "(", "'error.watch'", ",", "err", ".", "message", ")", ";", "return", ";", "}", "if", "(", "current", ".", "size", "!==", "prev", ".", "size", "||", "+", "current", ".", "mtime", ">", "+", "prev", ".", "mtime", ")", "{", "prev", "=", "current", ";", "// save new stats", "self", ".", "logger_", ".", "debug", "(", "util", ".", "format", "(", "'%s has been modified'", ",", "file", ")", ")", ";", "self", ".", "emit", "(", "'watch'", ")", ";", "}", "}", ")", ";", "}" ]

[ "filename", "is", "not", "supported", "when", "MacOSX" ]

[ "function", "(", "fn", ",", "syntheticArgs", ")", "{", "var", "$this", "=", "this", ";", "syntheticArgs", "=", "syntheticArgs", "||", "[", "]", ";", "/**\n\t\t * Ensure to have it in the next event loop for better async\n\t\t */", "var", "processResponder", "=", "function", "(", ")", "{", "try", "{", "if", "(", "fn", ")", "{", "/**\n\t\t\t\t\t * Insert a done() or ok() argument to other needed arguments\n\t\t\t\t\t */", "syntheticArgs", ".", "unshift", "(", "function", "(", ")", "{", "/**\n\t\t\t\t\t\t * Call the next in queue\n\t\t\t\t\t\t */", "$this", ".", "next", ".", "apply", "(", "$this", ",", "arguments", ")", ";", "}", ")", ";", "/**\n\t\t\t\t\t * Call the function finally\n\t\t\t\t\t */", "fn", ".", "apply", "(", "this", ",", "syntheticArgs", ")", ";", "}", "else", "{", "syntheticArgs", "=", "syntheticArgs", "||", "[", "]", ";", "/**\n\t\t\t\t\t * If no function passed, call the next in queue\n\t\t\t\t\t */", "$this", ".", "next", ".", "apply", "(", "this", ",", "syntheticArgs", ")", ";", "}", "}", "catch", "(", "e", ")", "{", "/**\n\t\t\t\t * An error caught is thrown directly to the catch handler, if any\n\t\t\t\t */", "if", "(", "this", ".", "onCatch", ")", "{", "this", ".", "onCatch", "(", "e", ")", ";", "}", "else", "{", "throw", "e", ";", "}", "}", "}", ";", "if", "(", "typeof", "process", "===", "\"undefined\"", ")", "{", "processResponder", "(", ")", ";", "}", "else", "{", "process", ".", "nextTick", "(", "processResponder", ")", ";", "}", "/**\n\t\t * Return self for chaining\n\t\t */", "return", "this", ";", "}" ]

[ "Executes", "a", "given", "function", "with", "provided", "arguments", "and", "then", "calls", "the", "next", "one", "in", "queue" ]

[ "function", "(", ")", "{", "try", "{", "if", "(", "fn", ")", "{", "/**\n\t\t\t\t\t * Insert a done() or ok() argument to other needed arguments\n\t\t\t\t\t */", "syntheticArgs", ".", "unshift", "(", "function", "(", ")", "{", "/**\n\t\t\t\t\t\t * Call the next in queue\n\t\t\t\t\t\t */", "$this", ".", "next", ".", "apply", "(", "$this", ",", "arguments", ")", ";", "}", ")", ";", "/**\n\t\t\t\t\t * Call the function finally\n\t\t\t\t\t */", "fn", ".", "apply", "(", "this", ",", "syntheticArgs", ")", ";", "}", "else", "{", "syntheticArgs", "=", "syntheticArgs", "||", "[", "]", ";", "/**\n\t\t\t\t\t * If no function passed, call the next in queue\n\t\t\t\t\t */", "$this", ".", "next", ".", "apply", "(", "this", ",", "syntheticArgs", ")", ";", "}", "}", "catch", "(", "e", ")", "{", "/**\n\t\t\t\t * An error caught is thrown directly to the catch handler, if any\n\t\t\t\t */", "if", "(", "this", ".", "onCatch", ")", "{", "this", ".", "onCatch", "(", "e", ")", ";", "}", "else", "{", "throw", "e", ";", "}", "}", "}" ]

[ "Ensure", "to", "have", "it", "in", "the", "next", "event", "loop", "for", "better", "async" ]

[ "function", "(", "err", ")", "{", "/**\n\t\t * If err is an Error object, break the chain and call catch\n\t\t */", "if", "(", "err", "&&", "(", "err", ".", "constructor", ".", "name", "===", "\"Error\"", "||", "err", ".", "constructor", ".", "name", "===", "\"TypeError\"", ")", "&&", "this", ".", "onCatch", ")", "{", "this", ".", "onCatch", "(", "err", ")", ";", "return", ";", "}", "var", "nextFn", "=", "this", ".", "fnStack", ".", "shift", "(", ")", ";", "if", "(", "nextFn", ")", "{", "/**\n\t\t\t * Ensure arguments are passed as an Array\n\t\t\t */", "var", "args", "=", "Array", ".", "prototype", ".", "slice", ".", "call", "(", "arguments", ")", ";", "return", "this", ".", "execute", "(", "nextFn", ".", "fn", ",", "args", ")", ";", "}", "}" ]

[ "Calls", "the", "next", "function", "in", "queue", "or", "calls", "the", "function", "passed", "in", "catch", "if", "error", "occurs" ]

[ "function", "(", "xml", ",", "command", ",", "version", ")", "{", "var", "formatVersion", "=", "version", "||", "JSDAS", ".", "Formats", ".", "current", ";", "var", "format", "=", "JSDAS", ".", "Formats", "[", "formatVersion", "]", "[", "command", "]", ";", "var", "json", "=", "JSDAS", ".", "Parser", ".", "parseElement", "(", "xml", ",", "format", ")", ";", "return", "json", ";", "}" ]

[ "Private", "methods", "Given", "a", "valid", "DAS", "XML", "it", "returns", "its", "translation", "to", "JSON" ]

[ "function", "(", "xml", ",", "format", ")", "{", "var", "out", "=", "{", "}", ";", "//The Document object does not have all the functionality of a standard node (i.e. it can't have attributes).", "//So, if we are in the Document element, move to its ¿¿only?? child, the root.", "if", "(", "xml", ".", "nodeType", "==", "9", ")", "{", "//detect the Document node type", "xml", "=", "xml", ".", "firstChild", ";", "while", "(", "xml", ".", "nodeType", "!=", "1", "&&", "xml", ".", "nextSibling", ")", "//Document nodes (9) can't have text (3) nodes as children. Test only for elements (1)", "xml", "=", "xml", ".", "nextSibling", ";", "}", "//get properties", "if", "(", "format", ".", "properties", ")", "{", "var", "props", "=", "format", ".", "properties", ";", "for", "(", "var", "nprop", "=", "0", ",", "lenprop", "=", "props", ".", "length", ";", "nprop", "<", "lenprop", ";", "++", "nprop", ")", "{", "var", "f", "=", "props", "[", "nprop", "]", ";", "var", "name", "=", "f", ".", "jsname", "||", "f", ".", "name", ";", "out", "[", "name", "]", "=", "this", ".", "parseProperty", "(", "xml", ",", "f", ")", ";", "}", "}", "//get childs", "if", "(", "format", ".", "childs", ")", "{", "var", "ch", "=", "format", ".", "childs", ";", "if", "(", "ch", "===", "'text'", ")", "{", "//if thextual child", "/*\n\t\t\t\t * Due to browser compatibility the textContent may come from this 3 different methods:\n\t\t\t\t * xml.innerText = IE\n\t\t\t\t * xml.textContent = Firefox\n\t\t\t\t * xml.text = IE\n\t\t\t\t */", "out", "[", "'textContent'", "]", "=", "xml", ".", "innerText", "||", "xml", ".", "textContent", "||", "xml", ".", "text", ";", "}", "else", "{", "//childs different than text", "for", "(", "var", "i", "=", "0", ",", "len", "=", "ch", ".", "length", ";", "i", "<", "len", ";", "++", "i", ")", "{", "var", "f", "=", "ch", "[", "i", "]", ";", "//var els = xml.getElementsByTagName(f.tagname);", "//Hack: since getElementsByTagName is case sensitive for XML documents and DAS XMLs can be found ", "//in different casing, use a regular expresion tofilter the elements.", "//FIX: This is an unefficient parsing method. Other ways should be explored.", "var", "els", "=", "[", "]", ";", "var", "all_els", "=", "xml", ".", "getElementsByTagName", "(", "'*'", ")", ";", "for", "(", "var", "iael", "=", "0", ",", "lenael", "=", "all_els", ".", "length", ";", "iael", "<", "lenael", ";", "++", "iael", ")", "{", "var", "curr_node", "=", "all_els", "[", "iael", "]", ";", "if", "(", "new", "RegExp", "(", "'^'", "+", "f", ".", "tagname", "+", "'$'", ",", "'i'", ")", ".", "test", "(", "curr_node", ".", "nodeName", ")", ")", "{", "els", ".", "push", "(", "curr_node", ")", ";", "}", "}", "//End of tag casing hack", "if", "(", "f", ".", "mandatory", "&&", "this", ".", "checkMandatoryElements", "&&", "(", "!", "els", "||", "els", ".", "length", "==", "0", ")", ")", "{", "//if a mandatory element is not present...", "//JSDAS.Console.log(\"Mandatory element is not present.\");", "}", "if", "(", "els", ".", "length", ">", "0", ")", "{", "//if there are elements of the given tagName", "var", "name", "=", "f", ".", "jsname", "||", "f", ".", "tagname", ";", "if", "(", "f", ".", "multiple", ")", "{", "//if its a multiple instance child, create an array and push all instances", "out", "[", "name", "]", "=", "[", "]", ";", "for", "(", "var", "iel", "=", "0", ",", "lenel", "=", "els", ".", "length", ";", "iel", "<", "lenel", ";", "++", "iel", ")", "{", "out", "[", "name", "]", ".", "push", "(", "this", ".", "parseElement", "(", "els", "[", "iel", "]", ",", "f", ")", ")", ";", "}", "}", "else", "{", "out", "[", "name", "]", "=", "this", ".", "parseElement", "(", "els", "[", "0", "]", ",", "f", ")", ";", "}", "}", "}", "}", "}", "return", "out", ";", "}" ]

[ "true", "to", "raise", "an", "error", "if", "a", "mandatory", "element", "is", "not", "present", "Private", "functions", "(", "actually", "not", "really", "private", ".", "just", "not", "API", "documented" ]

[ "function", "(", "url", ",", "callback", ",", "errorcallback", ")", "{", "if", "(", "!", "this", ".", "initialized", ")", "{", "this", ".", "initialize", "(", ")", ";", "}", "var", "xmlloader", "=", "JSDAS", ".", "XMLLoader", ";", "//get a reference to myself", "var", "usingCORS", "=", "true", ";", "var", "xhr", "=", "this", ".", "xhrCORS", "(", "'GET'", ",", "url", ")", ";", "if", "(", "!", "xhr", ")", "{", "//if the browser is not CORS capable, fallback to proxy if available", "if", "(", "this", ".", "proxyURL", ")", "{", "var", "xhr", "=", "this", ".", "xhr", "(", ")", ";", "xhr", ".", "open", "(", "'GET'", ",", "this", ".", "proxyURL", "+", "'?url='", "+", "url", ",", "true", ")", ";", "usingCORS", "=", "false", ";", "}", "else", "{", "errorcallback", "&&", "errorcallback", "(", "{", "id", ":", "'no_proxy'", ",", "msg", ":", "\"Cross-Origin requests are not supported but no proxy has been defined\"", "}", ")", ";", "}", "}", "//At this point, we've got a valid XHR", "//xhr.setRequestHeader(\"X-Requested-With\", \"XMLHttpRequest\");", "//xhr.setRequestHeader(\"Accept\", \"application/xml, text/xml\");", "var", "xmlloader", "=", "this", ";", "//necessary so the closures get the variable", "var", "change", "=", "function", "(", "xhr", ")", "{", "if", "(", "xhr", "&&", "(", "xhr", ".", "readyState", "==", "4", ")", ")", "{", "if", "(", "xmlloader", ".", "httpSuccess", "(", "xhr", ")", ")", "{", "processResponse", "(", "xhr", ")", ";", "}", "else", "{", "//if it failed, it mighht be that the source has no CORS enabled. In such case, fallback to proxy before erroring", "if", "(", "usingCORS", "&&", "xmlloader", ".", "proxyURL", ")", "{", "//if it failed when using CORS and we've got a proxy, try to get the data via the proxy", "xhr", "=", "undefined", ";", "usingCORS", "=", "false", ";", "var", "new_xhr", "=", "xmlloader", ".", "xhr", "(", ")", ";", "new_xhr", ".", "open", "(", "'GET'", ",", "xmlloader", ".", "proxyURL", "+", "'?url='", "+", "url", ",", "true", ")", ";", "new_xhr", ".", "onreadystatechange", "=", "function", "(", ")", "{", "change", "(", "new_xhr", ")", ";", "}", "new_xhr", ".", "send", "(", "null", ")", ";", "}", "else", "{", "errorcallback", "&&", "errorcallback", "(", "{", "id", ":", "\"xmlhttprequest_error\"", ",", "msg", ":", "xhr", ".", "status", "}", ")", ";", "}", "}", "//to prevent IE memory leaks", "xhr", "=", "undefined", ";", "}", "}", ";", "var", "processResponse", "=", "function", "(", "xhr", ")", "{", "//WARNING: Since Uniprot (and maybe others) do not respond with a correct content-type, we cannot check it here. Should be reactivated as soon as the servers are updated.", "//var ct = xhr.getResponseHeader(\"content-type\");", "//var xml = ct && ct.indexOf(\"xml\") >= 0;", "//if (xml) {", "var", "data", "=", "xhr", ".", "responseXML", ";", "if", "(", "!", "data", ")", "{", "//This block is here since we cannot rely on content type headers", "errorcallback", "&&", "errorcallback", "(", "{", "id", ":", "'not_xml'", ",", "msg", ":", "\"The response was not XML\"", "}", ")", ";", "}", "if", "(", "data", ".", "documentElement", ".", "nodeName", "!=", "'parsererror'", ")", "{", "callback", "(", "data", ")", ";", "return", ";", "}", "//} //if anything went wrong, the document was not XML", "//errorcallback && errorcallback({id: 'not_xml', msg: \"The response was not XML\"});", "}", ";", "xhr", ".", "onreadystatechange", "=", "function", "(", ")", "{", "change", "(", "xhr", ")", ";", "}", ";", "// Send the data", "try", "{", "xhr", ".", "send", "(", "null", ")", ";", "}", "catch", "(", "e", ")", "{", "//This code will rarely be called. Only when there's a problem on sernding the request.", "if", "(", "usingCORS", "&&", "this", ".", "proxyURL", ")", "{", "//if it failed when using CORS and we've got a proxy, try to get the data via the proxy", "var", "xhr", "=", "this", ".", "xhr", "(", ")", ";", "xhr", ".", "open", "(", "'GET'", ",", "this", ".", "proxyURL", "+", "'?url='", "+", "url", ",", "true", ")", ";", "xhr", ".", "onreadystatechange", "=", "function", "(", ")", "{", "change", "(", "xhr", ")", ";", "}", "try", "{", "xhr", ".", "send", "(", "null", ")", ";", "}", "catch", "(", "e", ")", "{", "errorcallback", "&&", "errorcallback", "(", "{", "id", ":", "'sending_error'", ",", "msg", ":", "\"There was an error when sending the request\"", "}", ")", ";", "}", "}", "else", "{", "errorcallback", "&&", "errorcallback", "(", "{", "id", ":", "'sending_error'", ",", "msg", ":", "\"There was an error when sending the request\"", "}", ")", ";", "}", "}", "}" ]

[ "This", "function", "loads", "an", "external", "XML", "using", "a", "proxy", "on", "the", "server", "to", "comply", "with", "the", "SOP" ]

[ "function", "(", "xhr", ")", "{", "if", "(", "xhr", "&&", "(", "xhr", ".", "readyState", "==", "4", ")", ")", "{", "if", "(", "xmlloader", ".", "httpSuccess", "(", "xhr", ")", ")", "{", "processResponse", "(", "xhr", ")", ";", "}", "else", "{", "//if it failed, it mighht be that the source has no CORS enabled. In such case, fallback to proxy before erroring", "if", "(", "usingCORS", "&&", "xmlloader", ".", "proxyURL", ")", "{", "//if it failed when using CORS and we've got a proxy, try to get the data via the proxy", "xhr", "=", "undefined", ";", "usingCORS", "=", "false", ";", "var", "new_xhr", "=", "xmlloader", ".", "xhr", "(", ")", ";", "new_xhr", ".", "open", "(", "'GET'", ",", "xmlloader", ".", "proxyURL", "+", "'?url='", "+", "url", ",", "true", ")", ";", "new_xhr", ".", "onreadystatechange", "=", "function", "(", ")", "{", "change", "(", "new_xhr", ")", ";", "}", "new_xhr", ".", "send", "(", "null", ")", ";", "}", "else", "{", "errorcallback", "&&", "errorcallback", "(", "{", "id", ":", "\"xmlhttprequest_error\"", ",", "msg", ":", "xhr", ".", "status", "}", ")", ";", "}", "}", "//to prevent IE memory leaks", "xhr", "=", "undefined", ";", "}", "}" ]

[ "necessary", "so", "the", "closures", "get", "the", "variable" ]

[ "function", "writeLaunchCode", "(", "config", ")", "{", "var", "{", "name", ",", "stub", "}", "=", "config", ".", "holder", "if", "(", "!", "name", "||", "!", "stub", ")", "{", "throw", "new", "Error", "(", "'invalid name or stub'", ")", "}", "var", "code", "=", "`", "${", "name", "}", "${", "stub", "}", "${", "stub", "}", "${", "stub", "}", "`", ".", "replace", "(", "/", "\\n|(\\s{2})", "/", "g", ",", "''", ")", "var", "output", "=", "path", ".", "join", "(", "config", ".", "$path", ".", "target", ".", "client", ",", "'launch.js'", ")", "fs", ".", "writeFileSync", "(", "output", ",", "code", ",", "'utf8'", ")", "logger", ".", "done", "(", "'view ::'", ",", "'launch code generated'", ")", "}" ]

[ "write", "launch", "code" ]

[ "function", "NoiseSampler", "(", "size", ")", "{", "if", "(", "!", "size", ")", "throw", "\"no size specified to NoiseSampler\"", ";", "this", ".", "size", "=", "size", ";", "this", ".", "scale", "=", "1", ";", "this", ".", "offset", "=", "0", ";", "this", ".", "smooth", "=", "true", ";", "this", ".", "seamless", "=", "false", ";", "// this.scales = [", "// 10, 0.1, 0.2, 1", "// ];", "// this.strengths = [", "// 0.1, 0.3, 0.2, 1", "// ];", "this", ".", "scales", "=", "[", "1", ",", "20", ",", "0.5", "]", ";", "this", ".", "strengths", "=", "[", "1", ",", "0.1", ",", "0.5", "]", ";", "this", ".", "data", "=", "new", "Float32Array", "(", "this", ".", "size", "*", "this", ".", "size", ")", ";", "}" ]

[ "Samples", "a", "1", "-", "component", "texture", "noise", "in", "this", "case" ]

[ "function", "(", "x", ",", "y", ")", "{", "//avoid negatives", "if", "(", "this", ".", "seamless", ")", "{", "x", "=", "(", "x", "%", "this", ".", "size", "+", "this", ".", "size", ")", "%", "this", ".", "size", "y", "=", "(", "y", "%", "this", ".", "size", "+", "this", ".", "size", ")", "%", "this", ".", "size", "}", "else", "{", "x", "=", "clamp", "(", "x", ",", "0", ",", "this", ".", "size", ")", "y", "=", "clamp", "(", "y", ",", "0", ",", "this", ".", "size", ")", "}", "if", "(", "this", ".", "smooth", ")", "return", "sampling", ".", "bilinear", "(", "this", ".", "data", ",", "this", ".", "size", ",", "this", ".", "size", ",", "x", ",", "y", ")", ";", "else", "return", "sampling", ".", "nearest", "(", "this", ".", "data", ",", "this", ".", "size", ",", "this", ".", "size", ",", "x", ",", "y", ")", ";", "}" ]

[ "returns", "a", "float", "-", "1", "to", "1" ]

[ "function", "is", "(", "constructor", ",", "value", ")", "{", "return", "value", "!==", "null", "&&", "(", "value", ".", "constructor", "===", "constructor", "||", "value", "instanceof", "constructor", ")", ";", "}" ]

[ "Determines", "if", "value", "is", "an", "instance", "of", "constructor", "." ]

[ "function", "isDataBinaryRobust", "(", "data", ")", "{", "// console.log('data is binary ?')", "var", "patternVertex", "=", "/", "vertex[\\s]+([\\-+]?[0-9]+\\.?[0-9]*([eE][\\-+]?[0-9]+)?)+[\\s]+([\\-+]?[0-9]*\\.?[0-9]+([eE][\\-+]?[0-9]+)?)+[\\s]+([\\-+]?[0-9]*\\.?[0-9]+([eE][\\-+]?[0-9]+)?)+", "/", "g", ";", "var", "text", "=", "ensureString", "(", "data", ")", ";", "var", "isBinary", "=", "patternVertex", ".", "exec", "(", "text", ")", "===", "null", ";", "return", "isBinary", ";", "}" ]

[ "a", "more", "robust", "version", "of", "the", "above", "that", "does", "NOT", "require", "the", "whole", "file" ]

[ "function", "(", "err", ",", "r", ")", "{", "if", "(", "err", ")", "{", "numberOfValidConnections", "=", "numberOfValidConnections", "-", "1", ";", "errorObject", "=", "err", ";", "return", "false", ";", "}", "else", "if", "(", "r", ".", "result", "[", "'$err'", "]", ")", "{", "errorObject", "=", "r", ".", "result", ";", "return", "false", ";", "}", "else", "if", "(", "r", ".", "result", "[", "'errmsg'", "]", ")", "{", "errorObject", "=", "r", ".", "result", ";", "return", "false", ";", "}", "else", "{", "numberOfValidConnections", "=", "numberOfValidConnections", "+", "1", ";", "}", "return", "true", ";", "}" ]

[ "Handle", "the", "error" ]

[ "function", "(", "options", ")", "{", "Configurable", ".", "call", "(", "this", ")", ";", "this", ".", "_resources", "=", "[", "]", ";", "this", ".", "_serializer", "=", "require", "(", "__dirname", "+", "'/lib/Serializer'", ")", ";", "this", ".", "setAll", "(", "_", ".", "extend", "(", "{", "}", ",", "defaults", ",", "options", ")", ")", ";", "// List of IDs used to find duplicate handlers fast", "this", ".", "_ids", "=", "{", "// id: handler", "}", ";", "// List of names for handlers set by the user", "this", ".", "_names", "=", "{", "// name: handler", "}", ";", "}" ]

[ "espressojs", "constructor", "function" ]

[ "function", "makeValidation", "(", "name", ",", "exp", ",", "parser", ")", "{", "return", "function", "(", "input", ")", "{", "if", "(", "typeof", "input", "!==", "'string'", ")", "{", "throw", "new", "TypeError", "(", "'Cannot validate '", "+", "name", "+", "'. Input must be a string.'", ")", ";", "}", "var", "validate", "=", "function", "(", ")", "{", "return", "input", ".", "match", "(", "exp", ")", "?", "true", ":", "false", ";", "}", ";", "return", "{", "valid", ":", "validate", "(", ")", ",", "parse", ":", "function", "(", ")", "{", "if", "(", "!", "validate", "(", ")", ")", "{", "return", "false", ";", "}", "var", "captures", "=", "exp", ".", "exec", "(", "input", ")", ";", "return", "parser", "(", "captures", ")", ";", "}", "}", ";", "}", ";", "}" ]

[ "this", "makes", "a", "validation", "function", "for", "a", "string", "type", "defined", "by", "name" ]

[ "function", "pipeEvents", "(", "source", ",", "destination", ",", "event", ")", "{", "source", ".", "on", "(", "event", ",", "function", "(", "data", ")", "{", "destination", ".", "emit", "(", "event", ",", "data", ")", ";", "}", ")", ";", "}" ]

[ "pipe", "specific", "events", "from", "source", "event", "emitter", "to", "destination", "event", "emitter" ]

[ "function", "get", "(", "key", ")", "{", "let", "val", "=", "process", ".", "env", "[", "key", "]", ";", "return", "val", "in", "types", "?", "types", "[", "val", "]", ":", "util", ".", "isNumeric", "(", "val", ")", "?", "parseFloat", "(", "val", ")", ":", "val", ";", "}" ]

[ "get", "env", "variable", "converts", "to", "native", "type" ]

[ "function", "set", "(", "key", ",", "val", ")", "{", "return", "process", ".", "env", "[", "key", "]", "=", "(", "process", ".", "env", "[", "key", "]", "===", "undefined", "?", "val", ":", "process", ".", "env", "[", "key", "]", ")", ";", "}" ]

[ "sets", "environment", "variable", "if", "it", "does", "not", "exist", "already", "env", "variables", "are", "stringified", "when", "set" ]

[ "function", "load", "(", "file", ")", "{", "let", "contents", "=", "null", ";", "file", "=", "path", ".", "resolve", "(", "file", ")", ";", "// handle .env files", "if", "(", "constants", ".", "REGEX", ".", "envfile", ".", "test", "(", "file", ")", ")", "{", "contents", "=", "util", ".", "parse", "(", "fs", ".", "readFileSync", "(", "file", ",", "'utf8'", ")", ")", ";", "// handle .js/.json files", "}", "else", "{", "contents", "=", "require", "(", "file", ")", ";", "}", "return", "env", "(", "contents", ")", ";", "}" ]

[ "load", "a", "file", "s", "contents", "and", "add", "to", "env" ]

[ "function", "init", "(", ")", "{", "// set NODE_ENV to --env value", "if", "(", "argv", ".", "env", ")", "{", "set", "(", "'NODE_ENV'", ",", "argv", ".", "env", ")", ";", "}", "// load evironment files", "[", "'./.env'", ",", "'./config/.env'", ",", "'./env'", ",", "'./config/env'", "]", ".", "map", "(", "file", "=>", "{", "try", "{", "load", "(", "file", ")", ";", "}", "catch", "(", "err", ")", "{", "if", "(", "env", "(", "'DEBUG'", ")", ")", "{", "console", ".", "error", "(", "`", "${", "err", ".", "message", "}", "`", ")", ";", "}", "}", "}", ")", ";", "// set default vars", "set", "(", "'NODE_ENV'", ",", "'development'", ")", ";", "[", "'DEVELOPMENT'", ",", "'PRODUCTION'", "]", ".", "map", "(", "str", "=>", "{", "set", "(", "str", ",", "get", "(", "'NODE_ENV'", ")", "===", "str", ".", "toLowerCase", "(", ")", ")", ";", "}", ")", ";", "}" ]

[ "attempt", "to", "load", "env", "configuration", "files" ]

[ "function", "_expandParentsForNode", "(", "node", ")", "{", "// get the actual parent nodes in the editor", "var", "parents", "=", "[", "]", ";", "$", "(", "node", ")", ".", "parentsUntil", "(", "'#tinymce'", ")", ".", "each", "(", "function", "(", "index", ",", "el", ")", "{", "parents", ".", "push", "(", "el", ".", "id", ")", ";", "}", ")", ";", "parents", ".", "reverse", "(", ")", ";", "// TODO handling for readonly mode where only headings are in the tree", "// expand the corresponding nodes in the tree", "for", "(", "var", "i", "=", "0", ";", "i", "<", "parents", ".", "length", ";", "i", "++", ")", "{", "var", "parentId", "=", "parents", "[", "i", "]", ";", "var", "parentNode", "=", "$", "(", "'[name=\"'", "+", "parentId", "+", "'\"]'", ",", "$tree", ")", ";", "var", "isOpen", "=", "$tree", ".", "jstree", "(", "'is_open'", ",", "parentNode", ")", ";", "if", "(", "!", "isOpen", ")", "{", "$tree", ".", "jstree", "(", "'open_node'", ",", "parentNode", ",", "null", ",", "false", ")", ";", "}", "}", "}" ]

[ "Expands", "the", "parents", "of", "a", "particular", "node" ]

[ "function", "selectNode", "(", "$node", ",", "selectContents", ",", "multiselect", ",", "external", ")", "{", "var", "id", "=", "$node", ".", "attr", "(", "'name'", ")", ";", "_removeCustomClasses", "(", ")", ";", "// clear other selections if not multiselect", "if", "(", "!", "multiselect", ")", "{", "if", "(", "tree", ".", "currentlySelectedNodes", ".", "indexOf", "(", "id", ")", "!=", "-", "1", ")", "{", "tree", ".", "currentlySelectedNodes", "=", "[", "id", "]", ";", "}", "else", "{", "tree", ".", "currentlySelectedNodes", "=", "[", "]", ";", "}", "}", "if", "(", "id", ")", "{", "var", "isEntity", "=", "w", ".", "entitiesManager", ".", "getEntity", "(", "id", ")", "!==", "undefined", ";", "var", "aChildren", "=", "$node", ".", "children", "(", "'a'", ")", ";", "if", "(", "isEntity", ")", "{", "tree", ".", "currentlySelectedNodes", "=", "[", "]", ";", "aChildren", ".", "addClass", "(", "'nodeSelected'", ")", ".", "removeClass", "(", "'contentsSelected'", ")", ";", "if", "(", "tree", ".", "currentlySelectedEntity", "!==", "id", ")", "{", "tree", ".", "currentlySelectedEntity", "=", "id", ";", "tree", ".", "selectionType", "=", "null", ";", "if", "(", "!", "external", ")", "{", "ignoreSelect", "=", "true", ";", "w", ".", "entitiesManager", ".", "highlightEntity", "(", "id", ",", "null", ",", "true", ")", ";", "}", "}", "}", "else", "if", "(", "w", ".", "structs", "[", "id", "]", "!=", "null", ")", "{", "tree", ".", "currentlySelectedEntity", "=", "null", ";", "if", "(", "tree", ".", "currentlySelectedNodes", ".", "indexOf", "(", "id", ")", "!=", "-", "1", "&&", "!", "external", ")", "{", "// already selected node, toggle selection type", "selectContents", "=", "!", "selectContents", ";", "}", "else", "{", "tree", ".", "currentlySelectedNodes", ".", "push", "(", "id", ")", ";", "}", "if", "(", "selectContents", ")", "{", "aChildren", ".", "addClass", "(", "'contentsSelected'", ")", ".", "removeClass", "(", "'nodeSelected'", ")", ";", "}", "else", "{", "aChildren", ".", "addClass", "(", "'nodeSelected'", ")", ".", "removeClass", "(", "'contentsSelected'", ")", ";", "}", "tree", ".", "selectionType", "=", "selectContents", "?", "tree", ".", "CONTENTS_SELECTED", ":", "tree", ".", "NODE_SELECTED", ";", "if", "(", "!", "external", ")", "{", "if", "(", "w", ".", "structs", "[", "id", "]", ".", "_tag", "==", "w", ".", "header", ")", "{", "w", ".", "dialogManager", ".", "show", "(", "'header'", ")", ";", "}", "else", "{", "ignoreSelect", "=", "true", ";", "// set to true so tree.highlightNode code isn't run by editor's onNodeChange handler", "w", ".", "selectStructureTag", "(", "tree", ".", "currentlySelectedNodes", ",", "selectContents", ")", ";", "}", "}", "}", "}", "}" ]

[ "Performs", "actual", "selection", "of", "a", "tree", "node" ]

[ "function", "resolveCapabilities", "(", "capabilities", ",", "capabilitiesDictionary", ")", "{", "if", "(", "typeof", "capabilities", "!==", "\"string\"", ")", "{", "// we do not know how to parse non string capabilities, let's assume it", "// is selenium compliant capabilities and return it.", "return", "capabilities", ";", "}", "// try to parse as a JSON string", "try", "{", "return", "JSON", ".", "parse", "(", "capabilities", ")", ";", "}", "catch", "(", "e", ")", "{", "}", "// No luck with JSON assumption.", "// Try to read from configuration.", "if", "(", "capabilities", "in", "capabilitiesDictionary", ")", "{", "return", "capabilitiesDictionary", "[", "capabilities", "]", ";", "}", "// still no luck ?", "// assume this is browserName...", "return", "{", "browserName", ":", "capabilities", "}", ";", "}" ]

[ "Actual", "resolution", "for", "capabilities", "." ]

[ "function", "sinonDoublistFs", "(", "test", ")", "{", "if", "(", "module", ".", "exports", ".", "trace", ")", "{", "nodeConsole", "=", "require", "(", "'long-con'", ")", ".", "create", "(", ")", ";", "log", "=", "nodeConsole", ".", "set", "(", "'nlFirst'", ",", "true", ")", ".", "set", "(", "'time'", ",", "false", ")", ".", "set", "(", "'traceDepth'", ",", "true", ")", ".", "create", "(", "null", ",", "console", ".", "log", ")", ";", "// eslint-disable-line no-console", "nodeConsole", ".", "traceMethods", "(", "'FileStub'", ",", "FileStub", ",", "log", ",", "null", ",", "/", "^prototype$", "/", ")", ";", "nodeConsole", ".", "traceMethods", "(", "'FileStub'", ",", "FileStub", ".", "prototype", ",", "log", ",", "null", ",", "/", "^(get|set)$", "/", ")", ";", "nodeConsole", ".", "traceMethods", "(", "'wrapFs'", ",", "wrapFs", ",", "log", ")", ";", "nodeConsole", ".", "traceMethods", "(", "'mixin'", ",", "mixin", ",", "log", ")", ";", "}", "else", "{", "log", "=", "function", "noOpLogger", "(", ")", "{", "}", ";", "}", "if", "(", "is", ".", "string", "(", "test", ")", ")", "{", "globalInjector", "[", "test", "]", "(", ")", ";", "return", ";", "}", "// Ex. 'mocha'", "if", "(", "is", ".", "fn", "(", "realFs", ".", "exists", ")", ")", "{", "return", ";", "}", "// Already doubled", "// Mix in stubFile(), stubTree(), etc.", "Object", ".", "keys", "(", "mixin", ")", ".", "forEach", "(", "function", "forEachMixinMethod", "(", "method", ")", "{", "test", "[", "method", "]", "=", "mixin", "[", "method", "]", ".", "bind", "(", "test", ")", ";", "}", ")", ";", "// Replace a selection of `fs`", "Object", ".", "keys", "(", "wrapFs", ")", ".", "forEach", "(", "function", "forEachWrapFsMethod", "(", "method", ")", "{", "realFs", "[", "method", "]", "=", "fs", "[", "method", "]", ";", "fs", "[", "method", "]", "=", "wrapFs", "[", "method", "]", ";", "}", ")", ";", "fileStubMap", "=", "{", "}", ";", "context", "=", "test", ";", "}" ]

[ "Init", "fs", "stubs", "." ]

[ "function", "FileStub", "(", ")", "{", "this", ".", "settings", "=", "{", "name", ":", "''", ",", "buffer", ":", "new", "Buffer", "(", "0", ")", ",", "readdir", ":", "false", ",", "parentName", ":", "''", ",", "stats", ":", "{", "dev", ":", "2114", ",", "ino", ":", "48064969", ",", "mode", ":", "33188", ",", "nlink", ":", "1", ",", "uid", ":", "85", ",", "gid", ":", "100", ",", "rdev", ":", "0", ",", "size", ":", "0", ",", "blksize", ":", "4096", ",", "blocks", ":", "0", ",", "atime", ":", "'Mon, 10 Oct 2011 23:24:11 GMT'", ",", "mtime", ":", "'Mon, 10 Oct 2011 23:24:11 GMT'", ",", "ctime", ":", "'Mon, 10 Oct 2011 23:24:11 GMT'", "}", "}", ";", "}" ]

[ "FileStub", "constructor", "." ]

[ "function", "intermediatePaths", "(", "sparse", ")", "{", "const", "dense", "=", "{", "}", ";", "[", "]", ".", "concat", "(", "sparse", ")", ".", "forEach", "(", "function", "forEachPath", "(", "path", ")", "{", "path", "=", "rtrimSlash", "(", "path", ")", ";", "dense", "[", "path", "]", "=", "{", "}", ";", "// Store as keys to omit dupes", "const", "curParts", "=", "trimSlash", "(", "path", ")", ".", "split", "(", "'/'", ")", ";", "const", "gapParts", "=", "[", "]", ";", "curParts", ".", "forEach", "(", "function", "forEachPart", "(", "part", ")", "{", "const", "parent", "=", "'/'", "+", "gapParts", ".", "join", "(", "'/'", ")", ";", "gapParts", ".", "push", "(", "part", ")", ";", "// Incrementally include all parts to collect gaps", "const", "intermediate", "=", "'/'", "+", "gapParts", ".", "join", "(", "'/'", ")", ";", "if", "(", "!", "dense", "[", "intermediate", "]", ")", "{", "dense", "[", "intermediate", "]", "=", "{", "}", ";", "}", "// Collect gap", "if", "(", "!", "dense", "[", "parent", "]", ")", "{", "dense", "[", "parent", "]", "=", "{", "}", ";", "}", "// Store its relatinship", "if", "(", "parent", "===", "'/'", ")", "{", "dense", "[", "parent", "]", "[", "trimSlash", "(", "intermediate", ".", "slice", "(", "1", ")", ")", "]", "=", "1", ";", "}", "else", "{", "// Guard against '' child name from sparse path w/ trailing slash", "const", "childName", "=", "intermediate", ".", "replace", "(", "parent", "+", "'/'", ",", "''", ")", ";", "if", "(", "childName", ")", "{", "dense", "[", "parent", "]", "[", "childName", "]", "=", "1", ";", "}", "}", "}", ")", ";", "}", ")", ";", "Object", ".", "keys", "(", "dense", ")", ".", "forEach", "(", "function", "forEachDensePath", "(", "name", ")", "{", "dense", "[", "name", "]", "=", "Object", ".", "keys", "(", "dense", "[", "name", "]", ")", ";", "}", ")", ";", "return", "dense", ";", "}" ]

[ "Given", "an", "array", "files", "and", "directories", "in", "any", "order", "and", "relationship", "return", "an", "object", "describing", "how", "to", "build", "file", "trees", "that", "contain", "them", "all", "with", "no", "directory", "gaps", "." ]

[ "function", "withOptions", "(", "scope", ",", "defaultOptions", ")", "{", "return", "function", "(", "plugin", ",", "options", ")", "{", "return", "scope", ".", "use", "(", "this", ",", "scope", ",", "plugin", ",", "scope", ".", "combine", "(", "defaultOptions", ",", "options", ")", ")", "}", "}" ]

[ "create", "a", "closure", "to", "hold", "the", "provided", "scope", "and", "defaultOptions", "." ]

[ "function", "(", "o", ")", "{", "var", "r", "=", "[", "]", ";", "for", "(", "var", "i", "in", "o", ")", "{", "if", "(", "o", ".", "hasOwnProperty", "(", "i", ")", ")", "{", "r", ".", "push", "(", "i", ")", ";", "}", "}", "return", "r", ";", "}" ]

[ "This", "technically", "means", "that", "each", "and", "find", "on", "IE8", "iterate", "through", "the", "object", "twice", ".", "This", "code", "doesn", "t", "run", "on", "IE8", "much", "so", "it", "s", "an", "acceptable", "tradeoff", ".", "If", "it", "becomes", "a", "problem", "we", "can", "always", "duplicate", "the", "feature", "detection", "inside", "each", "and", "find", "as", "well", "." ]

[ "function", "splitKeys", "(", "keys", ")", "{", "if", "(", "typeof", "(", "keys", ")", "===", "'string'", ")", "{", "return", "keys", ".", "replace", "(", "/", "^\\s*\\.\\s*", "/", ",", "''", ")", ".", "replace", "(", "/", "(?:\\s*\\.\\s*)+", "/", "g", ",", "'.'", ")", ".", "split", "(", "'.'", ")", ";", "}", "else", "if", "(", "Array", ".", "isArray", "(", "keys", ")", ")", "{", "return", "[", "]", ".", "concat", "(", "keys", ")", ";", "}", "return", ";", "}" ]

[ "Normalize", "and", "split", "keys", "for", "get", "and", "set", "method", ".", "Splits", "by", "." ]

[ "function", "Ops", "(", "ref", ",", "key", ")", "{", "this", ".", "ref", "=", "ref", ";", "this", ".", "key", "=", "key", ";", "if", "(", "this", ".", "ref", "[", "this", ".", "key", "]", "===", "undefined", ")", "{", "this", ".", "ref", "[", "this", ".", "key", "]", "=", "0", ";", "}", "this", ".", "_toNumber", "(", ")", ";", "this", ".", "isNumber", "=", "(", "typeof", "this", ".", "ref", "[", "this", ".", "key", "]", "===", "'number'", ")", ";", "this", ".", "isBoolean", "=", "(", "typeof", "this", ".", "ref", "[", "this", ".", "key", "]", "===", "'boolean'", ")", ";", "this", ".", "isString", "=", "(", "typeof", "this", ".", "ref", "[", "this", ".", "key", "]", "===", "'string'", ")", ";", "this", ".", "isArray", "=", "Array", ".", "isArray", "(", "this", ".", "ref", "[", "this", ".", "key", "]", ")", ";", "this", ".", "isObject", "=", "(", "!", "this", ".", "isArray", "&&", "typeof", "this", ".", "ref", "[", "this", ".", "key", "]", "===", "'object'", ")", ";", "}" ]

[ "Helper", "class", "for", "hashTree", ".", "use" ]

[ "function", "_createList", "(", "list", ")", "{", "var", "listContent", "=", "[", "]", ";", "if", "(", "list", ")", "{", "listContent", ".", "push", "(", "\"<table>\"", ")", ";", "Ember", ".", "$", ".", "each", "(", "list", ",", "function", "(", "property", ",", "value", ")", "{", "listContent", ".", "push", "(", "\"<tr><td>\"", ",", "property", ",", "\"</td><td>\"", ",", "value", ",", "\"</td></tr>\"", ")", ";", "}", ")", ";", "listContent", ".", "push", "(", "\"</table>\"", ")", ";", "return", "listContent", ".", "join", "(", "\"\"", ")", ";", "}", "}" ]

[ "Last", "node", "over", "which", "tooltip", "was", "displayed", "Converts", "the", "provided", "list", "object", "into", "a", "tabular", "form", "." ]

[ "function", "_setData", "(", "data", ")", "{", "_element", ".", "find", "(", "'.tip-title'", ")", ".", "html", "(", "data", ".", "title", "||", "\"\"", ")", ";", "_element", ".", "find", "(", "'.tip-text'", ")", ".", "html", "(", "data", ".", "text", "||", "\"\"", ")", ";", "_element", ".", "find", "(", "'.tip-text'", ")", "[", "data", ".", "text", "?", "'show'", ":", "'hide'", "]", "(", ")", ";", "_element", ".", "find", "(", "'.tip-list'", ")", ".", "html", "(", "_createList", "(", "data", ".", "kvList", ")", "||", "\"\"", ")", ";", "}" ]

[ "Tip", "supports", "3", "visual", "entities", "in", "the", "tooltip", ".", "Title", "description", "text", "and", "a", "list", ".", "_setData", "sets", "all", "these", "based", "on", "the", "passed", "data", "object" ]

[ "function", "(", "tipElement", ",", "svg", ")", "{", "_element", "=", "tipElement", ";", "_bubble", "=", "_element", ".", "find", "(", "'.bubble'", ")", ";", "_svg", "=", "svg", ";", "_svgPoint", "=", "svg", "[", "0", "]", ".", "createSVGPoint", "(", ")", ";", "}" ]

[ "Set", "the", "tip", "defaults" ]

[ "function", "(", "node", ",", "data", ",", "event", ")", "{", "var", "point", "=", "data", ".", "position", "||", "(", "node", ".", "getScreenCTM", "?", "_svgPoint", ".", "matrixTransform", "(", "node", ".", "getScreenCTM", "(", ")", ")", ":", "{", "x", ":", "event", ".", "x", ",", "y", ":", "event", ".", "y", "}", ")", ",", "windMid", "=", "_window", ".", "height", "(", ")", ">>", "1", ",", "winWidth", "=", "_window", ".", "width", "(", ")", ",", "showAbove", "=", "point", ".", "y", "<", "windMid", ",", "offsetX", "=", "0", ",", "width", "=", "0", ";", "if", "(", "_data", "!==", "data", ")", "{", "_data", "=", "data", ";", "_node", "=", "node", ";", "_setData", "(", "data", ")", ";", "}", "if", "(", "showAbove", ")", "{", "_element", ".", "removeClass", "(", "'below'", ")", ";", "_element", ".", "addClass", "(", "'above'", ")", ";", "}", "else", "{", "_element", ".", "removeClass", "(", "'above'", ")", ";", "_element", ".", "addClass", "(", "'below'", ")", ";", "point", ".", "y", "-=", "_element", ".", "height", "(", ")", ";", "}", "width", "=", "_element", ".", "width", "(", ")", ";", "offsetX", "=", "(", "width", "-", "11", ")", ">>", "1", ";", "if", "(", "point", ".", "x", "-", "offsetX", "<", "0", ")", "{", "offsetX", "=", "point", ".", "x", "-", "20", ";", "}", "else", "if", "(", "point", ".", "x", "+", "offsetX", ">", "winWidth", ")", "{", "offsetX", "=", "point", ".", "x", "-", "(", "winWidth", "-", "10", "-", "width", ")", ";", "}", "_bubble", ".", "css", "(", "{", "left", ":", "-", "offsetX", "}", ")", ";", "Ember", ".", "run", ".", "debounce", "(", "Tip", ",", "\"showTip\"", ",", "500", ")", ";", "_element", ".", "css", "(", "{", "left", ":", "point", ".", "x", ",", "top", ":", "point", ".", "y", "}", ")", ";", "}" ]

[ "Display", "a", "tooltip", "over", "an", "svg", "element", "." ]

[ "function", "report", "(", "test", ")", "{", "return", "{", "test_file", ":", "test", ".", "file", "+", "': '", "+", "test", ".", "fullTitle", "(", ")", ",", "start", ":", "test", ".", "start", ",", "end", ":", "test", ".", "end", ",", "exit_code", ":", "test", ".", "exit_code", ",", "elapsed", ":", "test", ".", "duration", "/", "1000", ",", "error", ":", "errorJSON", "(", "test", ".", "err", "||", "{", "}", ")", ",", "url", ":", "test", ".", "url", ",", "status", ":", "test", ".", "state", "}", ";", "}" ]

[ "Return", "an", "object", "with", "all", "of", "the", "relevant", "information", "for", "the", "test", "." ]

[ "function", "writeLogs", "(", "test", ",", "dirName", ")", "{", "var", "logs", "=", "test", ".", "fullTitle", "(", ")", "+", "'\\n'", "+", "test", ".", "file", "+", "'\\nStart: '", "+", "test", ".", "start", "+", "'\\nEnd: '", "+", "test", ".", "end", "+", "'\\nElapsed: '", "+", "test", ".", "duration", "+", "'\\nStatus: '", "+", "test", ".", "state", ";", "if", "(", "test", ".", "state", "===", "'fail'", ")", "{", "logs", "+=", "'\\nError: '", "+", "test", ".", "err", ".", "stack", ";", "}", "mkdirp", ".", "sync", "(", "testDir", "(", "test", ",", "dirName", ")", ")", ";", "fs", ".", "writeFileSync", "(", "testURL", "(", "test", ",", "dirName", ")", ",", "logs", ")", ";", "test", ".", "url", "=", "testURL", "(", "test", ",", "dirName", ")", ";", "}" ]

[ "Writes", "logs", "to", "a", "file", "in", "the", "specified", "directory" ]

[ "function", "generateFileName", "(", "className", ")", "{", "return", "className", ".", "replace", "(", "/", "component", "/", "gi", ",", "''", ")", ".", "replace", "(", "/", "system", "/", "gi", ",", "''", ")", ".", "replace", "(", "'2D'", ",", "'2d'", ")", ".", "replace", "(", "'3D'", ",", "'3d'", ")", ".", "replace", "(", "/", "^[A-Z]", "/", ",", "function", "(", "c", ")", "{", "return", "c", ".", "toLowerCase", "(", ")", ";", "}", ")", ".", "replace", "(", "/", "[A-Z]", "/", "g", ",", "function", "(", "c", ")", "{", "return", "'-'", "+", "c", ".", "toLowerCase", "(", ")", ";", "}", ")", "+", "'.js'", ";", "}" ]

[ "Generates", "a", "filename", "based", "on", "the", "class", "name", "given" ]

[ "function", "(", "ast", ",", "reporter", ",", "version", ")", "{", "this", ".", "ast", "=", "ast", ";", "this", ".", "reporter", "=", "reporter", ";", "this", ".", "psykickVersion", "=", "'psykick'", "+", "version", ";", "// Store the Templates so the Systems can access them later", "this", ".", "_templatesByName", "=", "{", "}", ";", "}" ]

[ "Compiles", "the", "AST", "into", "actual", "code" ]

[ "function", "CoreEvent", "(", "typeArg", ",", "detail", ")", "{", "if", "(", "detail", "==", "undefined", ")", "{", "detail", "=", "{", "}", ";", "}", "/**\r\n\t * Error:\r\n\t * Failed to construct 'CustomEvent': Please use the 'new' operator, this \r\n\t * DOM object constructor cannot be called as a function.\r\n\t * \r\n\t * In reason of that the browser did not allow to extend CustomEvent in\r\n\t * common way, we use our event class only as constant holder. \r\n\t */", "return", "new", "CustomEvent", "(", "typeArg", ",", "{", "detail", ":", "detail", "}", ")", ";", "}" ]

[ "CoreJS", "events", "." ]

[ "function", "Ajax", "(", "method", ",", "url", ",", "sendData", ")", "{", "DOMEventListener", ".", "call", "(", "this", ")", ";", "/**\r\n\t * Request object.\r\n\t *\r\n\t * @access protected\r\n\t * @type {XMLHttpRequest}\r\n\t */", "this", ".", "_request", "=", "new", "Ajax", ".", "XHRSystem", "(", ")", ";", "/**\r\n\t * Method of the request.\r\n\t *\r\n\t * @access protected \r\n\t * @type {String}\r\n\t */", "this", ".", "_method", "=", "method", ";", "/**\r\n\t * Address of request.\r\n\t *\r\n\t * @access protected\r\n\t * @type {String}\r\n\t */", "this", ".", "_url", "=", "url", ";", "/**\r\n\t * Data to send.\r\n\t *\r\n\t * @access protected\r\n\t * @type {(Object|String)}\r\n\t */", "this", ".", "_sendData", "=", "sendData", ";", "/**\r\n\t * The content type of sending data.\r\n\t * \r\n\t * @access public\r\n\t * @type {String}\r\n\t */", "this", ".", "contentType", "=", "\"application/binary\"", ";", "/**\r\n\t * Context conatiner.\r\n\t * @access private\r\n\t */", "var", "self", "=", "this", ";", "/**\r\n\t * Override onload of XMLHTTPRequest.\r\n\t * Convert callback function into `Event`.\r\n\t */", "this", ".", "_request", ".", "onload", "=", "function", "(", "event", ")", "{", "self", ".", "dispatchEvent", "(", "new", "Ajax", ".", "Event", "(", "Ajax", ".", "Event", ".", "LOAD", ",", "{", "response", ":", "self", ".", "_request", ".", "response", ",", "responseText", ":", "self", ".", "_request", ".", "responseText", ",", "responseType", ":", "self", ".", "_request", ".", "responseType", ",", "responseURL", ":", "self", ".", "_request", ".", "responseURL", ",", "responseXML", ":", "self", ".", "_request", ".", "responseXML", ",", "status", ":", "self", ".", "_request", ".", "status", ",", "lengthComputable", ":", "event", ".", "lengthComputable", ",", "loaded", ":", "event", ".", "loaded", ",", "total", ":", "event", ".", "total", "}", ")", ")", ";", "}", ";", "/**\r\n\t * Override onprogress of XMLHTTPRequest.\r\n\t * Convert callback function into `Event`.\r\n\t */", "this", ".", "_request", ".", "onprogress", "=", "function", "(", "event", ")", "{", "self", ".", "dispatchEvent", "(", "new", "Ajax", ".", "Event", "(", "Ajax", ".", "Event", ".", "PROGRESS", ",", "{", "lengthComputable", ":", "event", ".", "lengthComputable", ",", "loaded", ":", "event", ".", "loaded", ",", "total", ":", "event", ".", "total", "}", ")", ")", ";", "}", ";", "}" ]

[ "Asynchronous", "JavaScript", "and", "XML", ".", "Wrapper", "to", "equalize", "and", "simplify", "the", "usage", "for", "AJAX", "calls", "." ]

[ "function", "use", "(", "fullQualifiedClassName", ")", "{", "var", "container", "=", "use", ".", "getContainer", "(", "fullQualifiedClassName", ")", ";", "if", "(", "container", ".", "_loader", "===", "null", ")", "{", "use", ".", "loadCount", "++", ";", "container", ".", "_loader", "=", "Ajax", ".", "factory", "(", "\"get\"", ",", "container", ".", "_path", "+", "use", ".", "fileExtension", ")", ";", "container", ".", "_loader", ".", "addEventListener", "(", "Ajax", ".", "Event", ".", "LOAD", ",", "function", "(", "event", ")", "{", "var", "domains", ",", "className", ";", "use", ".", "loadCount", "--", ";", "// Load into script ram\r", "container", ".", "_class", "=", "new", "Function", "(", "event", ".", "detail", ".", "responseText", ")", ";", "// Import into context\r", "domains", "=", "fullQualifiedClassName", ".", "split", "(", "use", ".", "classPathDelimiter", ")", ";", "className", "=", "domains", ".", "pop", "(", ")", ";", "namespace", "(", "domains", ".", "join", "(", "use", ".", "classPathDelimiter", ")", ",", "function", "(", ")", "{", "var", "contextBackup", "=", "null", ",", "property", ";", "// Save old class name\r", "if", "(", "this", ".", "hasOwnProperty", "(", "className", ")", ")", "{", "contextBackup", "=", "this", "[", "className", "]", ";", "}", "// Run loaded code\r", "container", ".", "_class", ".", "call", "(", "this", ")", ";", "// Restore backup\r", "if", "(", "contextBackup", "===", "null", ")", "return", ";", "if", "(", "this", "[", "className", "]", "!==", "contextBackup", ")", "{", "for", "(", "property", "in", "contextBackup", ")", "{", "if", "(", "property", "==", "className", ")", "continue", ";", "if", "(", "this", "[", "className", "]", ".", "hasOwnProperty", "(", "property", ")", ")", "{", "throw", "new", "Error", "(", "\"CoreJs: \"", "+", "\"Overlapping namespace with class \"", "+", "\"property '\"", "+", "fullQualifiedClassName", "+", "\".\"", "+", "property", "+", "\"' detected.\"", ")", ";", "}", "else", "{", "this", "[", "className", "]", "[", "property", "]", "=", "contextBackup", "[", "property", "]", ";", "}", "}", "}", "}", ")", ";", "}", ")", ";", "container", ".", "_loader", ".", "addEventListener", "(", "Ajax", ".", "Event", ".", "LOAD", ",", "namespace", ".", "handleEvent", ")", ";", "container", ".", "_loader", ".", "load", "(", ")", ";", "}", "}" ]

[ "Auto", "load", "system", "." ]

[ "function", "Client", "(", "endpointUrl", ",", "sourceId", ")", "{", "this", ".", "restClient", "=", "new", "restClient", ".", "Client", "(", ")", ";", "this", ".", "endpointUrl", "=", "endpointUrl", ";", "if", "(", "this", ".", "endpointUrl", ")", "{", "// Remove the trailing slash if necessary", "if", "(", "this", ".", "endpointUrl", ".", "indexOf", "(", "'/'", ",", "this", ".", "endpointUrl", ".", "length", "-", "1", ")", "!==", "-", "1", ")", "{", "this", ".", "endpointUrl", "=", "this", ".", "endpointUrl", ".", "substr", "(", "0", ",", "this", ".", "endpointUrl", ".", "length", "-", "2", ")", ";", "}", "// Add the default version if not present", "// TODO: The client should take care of the version in a better way", "if", "(", "this", ".", "endpointUrl", ".", "indexOf", "(", "'/v1'", ",", "this", ".", "endpointUrl", ".", "length", "-", "3", ")", "===", "-", "1", ")", "{", "this", ".", "endpointUrl", "=", "this", ".", "endpointUrl", "+", "'/v1'", ";", "}", "}", "if", "(", "sourceId", "!==", "undefined", ")", "{", "this", ".", "sourceId", "=", "sourceId", ";", "}", "}" ]

[ "Constructor", "for", "the", "iFLUX", "Client", "." ]

[ "function", "processChildren", "(", "ele", ",", "children", ")", "{", "if", "(", "children", "&&", "children", ".", "constructor", "===", "Array", ")", "{", "for", "(", "var", "i", "=", "0", ";", "i", "<", "children", ".", "length", ";", "i", "++", ")", "{", "processChildren", "(", "ele", ",", "children", "[", "i", "]", ")", ";", "}", "}", "else", "if", "(", "children", "instanceof", "Node", ")", "{", "ele", ".", "appendChild", "(", "children", ")", ";", "}", "else", "if", "(", "children", ")", "{", "ele", ".", "appendChild", "(", "document", ".", "createTextNode", "(", "children", ")", ")", ";", "}", "}" ]

[ "Implementation", "of", "templating", "syntax", "for", "jsx", "." ]

[ "function", "getDrives", "(", ")", "{", "return", "getDrivesNow", "(", ")", ".", "then", "(", "function", "(", "drives", ")", "{", "// if new drive events during scan, redo scan", "if", "(", "newEvents", ")", "return", "getDrives", "(", ")", ";", "recordDrives", "(", "drives", ")", ";", "if", "(", "self", ".", "options", ".", "scanInterval", ")", "self", ".", "scanTimer", "=", "setTimeout", "(", "updateDrives", ",", "self", ".", "options", ".", "scanInterval", ")", ";", "// return drives array, cloned so not altered by future events", "return", "self", ".", "drives", ".", "slice", "(", "0", ")", ";", "}", ")", ";", "}" ]

[ "get", "drives", "initially", "connected" ]

[ "function", "getDrivesNow", "(", ")", "{", "reading", "=", "true", ";", "newEvents", "=", "false", ";", "return", "fs", ".", "readdirAsync", "(", "drivesPath", ")", ".", "then", "(", "function", "(", "files", ")", "{", "var", "drives", "=", "files", ".", "filter", "(", "function", "(", "name", ")", "{", "return", "name", "!=", "'.DS_Store'", ";", "}", ")", ";", "return", "drives", ";", "}", ")", ";", "}" ]

[ "scan", "for", "connected", "drives" ]

[ "function", "onRead", "(", "key", ")", "{", "if", "(", "key", "!==", "null", ")", "{", "if", "(", "cli", ".", "debug", ")", "console", ".", "log", "(", "'Key:'", ",", "key", ")", "// Exits on CTRL-C", "if", "(", "key", "===", "'\\u0003'", ")", "process", ".", "exit", "(", ")", "// If enter is pressed and the program is waiting for the user to press enter", "// so that the emulator can step forward, then call the appropriate callback", "if", "(", "key", ".", "charCodeAt", "(", "0", ")", "===", "13", "&&", "readingFn", "(", ")", "&&", "onReadCb", ")", "onReadCb", "(", "key", ".", "charCodeAt", "(", "0", ")", ")", "else", "if", "(", "cpu", ")", "{", "// Since the CPU is initialized and the program is not waiting for the user", "// to press enter, pass the pressed key to the LC-2 CPU Console.", "cpu", ".", "console", ".", "input", "(", "key", ")", "}", "readingFn", "(", "false", ")", "}", "}" ]

[ "This", "function", "processes", "an", "input", "key", "from", "STDIN", "." ]

[ "function", "end", "(", ")", "{", "console", ".", "log", "(", "'\\n=== REG DUMP ===\\n'", "+", "cpu", ".", "regdump", "(", ")", ".", "join", "(", "'\\n'", ")", ")", "if", "(", "options", ".", "memDump", ")", "console", ".", "log", "(", "'\\n\\n=== MEM DUMP ===\\n'", "+", "cpu", ".", "memdump", "(", "0", ",", "65535", ")", ".", "join", "(", "'\\n'", ")", ")", "process", ".", "exit", "(", ")", "// workaround for stdin event listener hanging", "}" ]

[ "Called", "when", "the", "LC", "-", "2", "program", "has", "finished", "running" ]

[ "function", "processSimple", "(", "names", ",", "current", ",", "stopAt", ",", "collector", ",", "done", ")", "{", "const", "name", "=", "names", "[", "current", "]", ";", "File", ".", "stat", "(", "Path", ".", "join", "(", "\"node_modules\"", ",", "name", ",", "\"hitchy.json\"", ")", ",", "(", "error", ",", "stat", ")", "=>", "{", "if", "(", "error", ")", "{", "if", "(", "error", ".", "code", "===", "\"ENOENT\"", ")", "{", "collector", ".", "push", "(", "name", ")", ";", "}", "else", "{", "done", "(", "error", ")", ";", "return", ";", "}", "}", "else", "if", "(", "stat", ".", "isFile", "(", ")", ")", "{", "if", "(", "!", "quiet", ")", "{", "console", ".", "error", "(", "`", "${", "name", "}", "`", ")", ";", "}", "}", "else", "{", "done", "(", "new", "Error", "(", "`", "${", "name", "}", "`", ")", ")", ";", "return", ";", "}", "if", "(", "++", "current", "<", "stopAt", ")", "{", "processSimple", "(", "names", ",", "current", ",", "stopAt", ",", "collector", ",", "done", ")", ";", "}", "else", "{", "done", "(", "null", ",", "collector", ")", ";", "}", "}", ")", ";", "}" ]

[ "Successively", "tests", "provided", "names", "of", "dependencies", "for", "matching", "existing", "folder", "in", "local", "sub", "-", "folder", "node_modules", "each", "containing", "file", "hitchy", ".", "json", "." ]

[ "function", "installMissing", "(", "error", ",", "collected", ")", "{", "if", "(", "error", ")", "{", "console", ".", "error", "(", "`", "${", "error", ".", "message", "}", "`", ")", ";", "process", ".", "exit", "(", "1", ")", ";", "return", ";", "}", "if", "(", "collected", ".", "length", "<", "1", ")", "{", "postProcess", "(", "0", ")", ";", "}", "else", "{", "if", "(", "!", "quiet", ")", "{", "console", ".", "error", "(", "`", "\\n", "${", "collected", ".", "map", "(", "d", "=>", "`", "${", "d", "}", "`", ")", ".", "join", "(", "\"\\n\"", ")", "}", "`", ")", ";", "}", "const", "npm", "=", "Child", ".", "exec", "(", "`", "${", "collected", ".", "join", "(", "\" \"", ")", "}", "`", ",", "{", "stdio", ":", "\"pipe\"", ",", "}", ")", ";", "npm", ".", "stdout", ".", "pipe", "(", "process", ".", "stdout", ")", ";", "npm", ".", "stderr", ".", "pipe", "(", "process", ".", "stderr", ")", ";", "npm", ".", "on", "(", "\"exit\"", ",", "postProcess", ")", ";", "}", "}" ]

[ "Installs", "collected", "dependencies", "considered", "missing", "or", "handles", "provided", "error", "." ]

[ "function", "postProcess", "(", "errorCode", ")", "{", "if", "(", "errorCode", ")", "{", "console", ".", "error", "(", "`", "${", "collected", ".", "join", "(", "\", \"", ")", "}", "${", "errorCode", "}", "`", ")", ";", "}", "else", "if", "(", "exec", ")", "{", "const", "cmd", "=", "exec", ".", "join", "(", "\" \"", ")", ";", "if", "(", "!", "quiet", ")", "{", "console", ".", "error", "(", "`", "${", "cmd", "}", "`", ")", ";", "}", "const", "followup", "=", "Child", ".", "exec", "(", "cmd", ")", ";", "followup", ".", "stdout", ".", "pipe", "(", "process", ".", "stdout", ")", ";", "followup", ".", "stderr", ".", "pipe", "(", "process", ".", "stderr", ")", ";", "followup", ".", "on", "(", "\"exit\"", ",", "code", "=>", "{", "process", ".", "exit", "(", "code", ")", ";", "}", ")", ";", "return", ";", "}", "process", ".", "exit", "(", "errorCode", ")", ";", "}" ]

[ "Handles", "event", "of", "having", "passed", "installation", "of", "missing", "dependencies", "." ]

[ "function", "(", "fn", ")", "{", "var", "hasOK", "=", "(", "typeof", "btnOK", "!==", "\"undefined\"", ")", ",", "hasCancel", "=", "(", "typeof", "btnCancel", "!==", "\"undefined\"", ")", ",", "hasInput", "=", "(", "typeof", "input", "!==", "\"undefined\"", ")", ",", "val", "=", "\"\"", ",", "self", "=", "this", ",", "ok", ",", "cancel", ",", "common", ",", "key", ",", "reset", ";", "// ok event handler", "ok", "=", "function", "(", "event", ")", "{", "if", "(", "typeof", "event", ".", "preventDefault", "!==", "\"undefined\"", ")", "event", ".", "preventDefault", "(", ")", ";", "common", "(", "event", ")", ";", "if", "(", "typeof", "input", "!==", "\"undefined\"", ")", "val", "=", "input", ".", "value", ";", "if", "(", "typeof", "fn", "===", "\"function\"", ")", "{", "if", "(", "typeof", "input", "!==", "\"undefined\"", ")", "{", "fn", "(", "true", ",", "val", ")", ";", "}", "else", "fn", "(", "true", ")", ";", "}", "return", "false", ";", "}", ";", "// cancel event handler", "cancel", "=", "function", "(", "event", ")", "{", "if", "(", "typeof", "event", ".", "preventDefault", "!==", "\"undefined\"", ")", "event", ".", "preventDefault", "(", ")", ";", "common", "(", "event", ")", ";", "if", "(", "typeof", "fn", "===", "\"function\"", ")", "fn", "(", "false", ")", ";", "return", "false", ";", "}", ";", "// common event handler (keyup, ok and cancel)", "common", "=", "function", "(", "event", ")", "{", "self", ".", "hide", "(", ")", ";", "self", ".", "unbind", "(", "document", ".", "body", ",", "\"keyup\"", ",", "key", ")", ";", "self", ".", "unbind", "(", "btnReset", ",", "\"focus\"", ",", "reset", ")", ";", "if", "(", "hasInput", ")", "self", ".", "unbind", "(", "form", ",", "\"submit\"", ",", "ok", ")", ";", "if", "(", "hasOK", ")", "self", ".", "unbind", "(", "btnOK", ",", "\"click\"", ",", "ok", ")", ";", "if", "(", "hasCancel", ")", "self", ".", "unbind", "(", "btnCancel", ",", "\"click\"", ",", "cancel", ")", ";", "}", ";", "// keyup handler", "key", "=", "function", "(", "event", ")", "{", "var", "keyCode", "=", "event", ".", "keyCode", ";", "if", "(", "keyCode", "===", "keys", ".", "SPACE", "&&", "!", "hasInput", ")", "ok", "(", "event", ")", ";", "if", "(", "keyCode", "===", "keys", ".", "ESC", "&&", "hasCancel", ")", "cancel", "(", "event", ")", ";", "}", ";", "// reset focus to first item in the dialog", "reset", "=", "function", "(", "event", ")", "{", "if", "(", "hasInput", ")", "input", ".", "focus", "(", ")", ";", "else", "if", "(", "!", "hasCancel", "||", "self", ".", "buttonReverse", ")", "btnOK", ".", "focus", "(", ")", ";", "else", "btnCancel", ".", "focus", "(", ")", ";", "}", ";", "// handle reset focus link", "// this ensures that the keyboard focus does not", "// ever leave the dialog box until an action has", "// been taken", "this", ".", "bind", "(", "btnReset", ",", "\"focus\"", ",", "reset", ")", ";", "// handle OK click", "if", "(", "hasOK", ")", "this", ".", "bind", "(", "btnOK", ",", "\"click\"", ",", "ok", ")", ";", "// handle Cancel click", "if", "(", "hasCancel", ")", "this", ".", "bind", "(", "btnCancel", ",", "\"click\"", ",", "cancel", ")", ";", "// listen for keys, Cancel => ESC", "this", ".", "bind", "(", "document", ".", "body", ",", "\"keyup\"", ",", "key", ")", ";", "// bind form submit", "if", "(", "hasInput", ")", "this", ".", "bind", "(", "form", ",", "\"submit\"", ",", "ok", ")", ";", "if", "(", "!", "this", ".", "transition", ".", "supported", ")", "{", "this", ".", "setFocus", "(", ")", ";", "}", "}" ]

[ "Set", "the", "proper", "button", "click", "events" ]

[ "function", "(", "item", ")", "{", "var", "html", "=", "\"\"", ",", "type", "=", "item", ".", "type", ",", "message", "=", "item", ".", "message", ",", "css", "=", "item", ".", "cssClass", "||", "\"\"", ";", "html", "+=", "\"<div class=\\\"alertify-dialog\\\">\"", ";", "if", "(", "_alertify", ".", "buttonFocus", "===", "\"none\"", ")", "html", "+=", "\"<a href=\\\"#\\\" id=\\\"alertify-noneFocus\\\" class=\\\"alertify-hidden\\\"></a>\"", ";", "if", "(", "type", "===", "\"prompt\"", ")", "html", "+=", "\"<form id=\\\"alertify-form\\\">\"", ";", "html", "+=", "\"<article class=\\\"alertify-inner\\\">\"", ";", "html", "+=", "dialogs", ".", "message", ".", "replace", "(", "\"{{message}}\"", ",", "message", ")", ";", "if", "(", "type", "===", "\"prompt\"", ")", "html", "+=", "dialogs", ".", "input", ";", "html", "+=", "dialogs", ".", "buttons", ".", "holder", ";", "html", "+=", "\"</article>\"", ";", "if", "(", "type", "===", "\"prompt\"", ")", "html", "+=", "\"</form>\"", ";", "html", "+=", "\"<a id=\\\"alertify-resetFocus\\\" class=\\\"alertify-resetFocus\\\" href=\\\"#\\\">Reset Focus</a>\"", ";", "html", "+=", "\"</div>\"", ";", "switch", "(", "type", ")", "{", "case", "\"confirm\"", ":", "html", "=", "html", ".", "replace", "(", "\"{{buttons}}\"", ",", "this", ".", "appendButtons", "(", "dialogs", ".", "buttons", ".", "cancel", ",", "dialogs", ".", "buttons", ".", "ok", ")", ")", ";", "html", "=", "html", ".", "replace", "(", "\"{{ok}}\"", ",", "this", ".", "labels", ".", "ok", ")", ".", "replace", "(", "\"{{cancel}}\"", ",", "this", ".", "labels", ".", "cancel", ")", ";", "break", ";", "case", "\"prompt\"", ":", "html", "=", "html", ".", "replace", "(", "\"{{buttons}}\"", ",", "this", ".", "appendButtons", "(", "dialogs", ".", "buttons", ".", "cancel", ",", "dialogs", ".", "buttons", ".", "submit", ")", ")", ";", "html", "=", "html", ".", "replace", "(", "\"{{ok}}\"", ",", "this", ".", "labels", ".", "ok", ")", ".", "replace", "(", "\"{{cancel}}\"", ",", "this", ".", "labels", ".", "cancel", ")", ";", "break", ";", "case", "\"alert\"", ":", "html", "=", "html", ".", "replace", "(", "\"{{buttons}}\"", ",", "dialogs", ".", "buttons", ".", "ok", ")", ";", "html", "=", "html", ".", "replace", "(", "\"{{ok}}\"", ",", "this", ".", "labels", ".", "ok", ")", ";", "break", ";", "default", ":", "break", ";", "}", "elDialog", ".", "className", "=", "\"alertify alertify-\"", "+", "type", "+", "\" \"", "+", "css", ";", "elCover", ".", "className", "=", "\"alertify-cover\"", ";", "return", "html", ";", "}" ]

[ "Build", "the", "proper", "message", "box" ]

[ "function", "(", "elem", ",", "wait", ")", "{", "// Unary Plus: +\"2\" === 2", "var", "timer", "=", "(", "wait", "&&", "!", "isNaN", "(", "wait", ")", ")", "?", "+", "wait", ":", "this", ".", "delay", ",", "self", "=", "this", ",", "hideElement", ",", "transitionDone", ";", "// set click event on log messages", "this", ".", "bind", "(", "elem", ",", "\"click\"", ",", "function", "(", ")", "{", "hideElement", "(", "elem", ")", ";", "}", ")", ";", "// Hide the dialog box after transition", "// This ensure it doens't block any element from being clicked", "transitionDone", "=", "function", "(", "event", ")", "{", "event", ".", "stopPropagation", "(", ")", ";", "// unbind event so function only gets called once", "self", ".", "unbind", "(", "this", ",", "self", ".", "transition", ".", "type", ",", "transitionDone", ")", ";", "// remove log message", "elLog", ".", "removeChild", "(", "this", ")", ";", "if", "(", "!", "elLog", ".", "hasChildNodes", "(", ")", ")", "elLog", ".", "className", "+=", "\" alertify-logs-hidden\"", ";", "}", ";", "// this sets the hide class to transition out", "// or removes the child if css transitions aren't supported", "hideElement", "=", "function", "(", "el", ")", "{", "// ensure element exists", "if", "(", "typeof", "el", "!==", "\"undefined\"", "&&", "el", ".", "parentNode", "===", "elLog", ")", "{", "// whether CSS transition exists", "if", "(", "self", ".", "transition", ".", "supported", ")", "{", "self", ".", "bind", "(", "el", ",", "self", ".", "transition", ".", "type", ",", "transitionDone", ")", ";", "el", ".", "className", "+=", "\" alertify-log-hide\"", ";", "}", "else", "{", "elLog", ".", "removeChild", "(", "el", ")", ";", "if", "(", "!", "elLog", ".", "hasChildNodes", "(", ")", ")", "elLog", ".", "className", "+=", "\" alertify-logs-hidden\"", ";", "}", "}", "}", ";", "// never close (until click) if wait is set to 0", "if", "(", "wait", "===", "0", ")", "return", ";", "// set timeout to auto close the log message", "setTimeout", "(", "function", "(", ")", "{", "hideElement", "(", "elem", ")", ";", "}", ",", "timer", ")", ";", "}" ]

[ "Close", "the", "log", "messages" ]

[ "function", "(", "message", ",", "type", ",", "fn", ",", "placeholder", ",", "cssClass", ")", "{", "// set the current active element", "// this allows the keyboard focus to be resetted", "// after the dialog box is closed", "elCallee", "=", "document", ".", "activeElement", ";", "// check to ensure the alertify dialog element", "// has been successfully created", "var", "check", "=", "function", "(", ")", "{", "if", "(", "(", "elLog", "&&", "elLog", ".", "scrollTop", "!==", "null", ")", "&&", "(", "elCover", "&&", "elCover", ".", "scrollTop", "!==", "null", ")", ")", "return", ";", "else", "check", "(", ")", ";", "}", ";", "// error catching", "if", "(", "typeof", "message", "!==", "\"string\"", ")", "throw", "new", "Error", "(", "\"message must be a string\"", ")", ";", "if", "(", "typeof", "type", "!==", "\"string\"", ")", "throw", "new", "Error", "(", "\"type must be a string\"", ")", ";", "if", "(", "typeof", "fn", "!==", "\"undefined\"", "&&", "typeof", "fn", "!==", "\"function\"", ")", "throw", "new", "Error", "(", "\"fn must be a function\"", ")", ";", "// initialize alertify if it hasn't already been done", "if", "(", "typeof", "this", ".", "init", "===", "\"function\"", ")", "{", "this", ".", "init", "(", ")", ";", "check", "(", ")", ";", "}", "queue", ".", "push", "(", "{", "type", ":", "type", ",", "message", ":", "message", ",", "callback", ":", "fn", ",", "placeholder", ":", "placeholder", ",", "cssClass", ":", "cssClass", "}", ")", ";", "if", "(", "!", "isopen", ")", "this", ".", "setup", "(", ")", ";", "return", "this", ";", "}" ]

[ "Create", "a", "dialog", "box" ]

[ "function", "(", ")", "{", "var", "transitionDone", ",", "self", "=", "this", ";", "// remove reference from queue", "queue", ".", "splice", "(", "0", ",", "1", ")", ";", "// if items remaining in the queue", "if", "(", "queue", ".", "length", ">", "0", ")", "this", ".", "setup", "(", "true", ")", ";", "else", "{", "isopen", "=", "false", ";", "// Hide the dialog box after transition", "// This ensure it doens't block any element from being clicked", "transitionDone", "=", "function", "(", "event", ")", "{", "event", ".", "stopPropagation", "(", ")", ";", "elDialog", ".", "className", "+=", "\" alertify-isHidden\"", ";", "// unbind event so function only gets called once", "self", ".", "unbind", "(", "elDialog", ",", "self", ".", "transition", ".", "type", ",", "transitionDone", ")", ";", "}", ";", "// whether CSS transition exists", "if", "(", "this", ".", "transition", ".", "supported", ")", "{", "this", ".", "bind", "(", "elDialog", ",", "this", ".", "transition", ".", "type", ",", "transitionDone", ")", ";", "elDialog", ".", "className", "=", "\"alertify alertify-hide alertify-hidden\"", ";", "}", "else", "{", "elDialog", ".", "className", "=", "\"alertify alertify-hide alertify-hidden alertify-isHidden\"", ";", "}", "elCover", ".", "className", "=", "\"alertify-cover alertify-cover-hidden\"", ";", "// set focus to the last element or body", "// after the dialog is closed", "elCallee", ".", "focus", "(", ")", ";", "}", "}" ]

[ "Hide", "the", "dialog", "and", "rest", "to", "defaults" ]

[ "function", "(", ")", "{", "// ensure legacy browsers support html5 tags", "document", ".", "createElement", "(", "\"nav\"", ")", ";", "document", ".", "createElement", "(", "\"article\"", ")", ";", "document", ".", "createElement", "(", "\"section\"", ")", ";", "// cover", "elCover", "=", "document", ".", "createElement", "(", "\"div\"", ")", ";", "elCover", ".", "setAttribute", "(", "\"id\"", ",", "\"alertify-cover\"", ")", ";", "elCover", ".", "className", "=", "\"alertify-cover alertify-cover-hidden\"", ";", "document", ".", "body", ".", "appendChild", "(", "elCover", ")", ";", "// main element", "elDialog", "=", "document", ".", "createElement", "(", "\"section\"", ")", ";", "elDialog", ".", "setAttribute", "(", "\"id\"", ",", "\"alertify\"", ")", ";", "elDialog", ".", "className", "=", "\"alertify alertify-hidden\"", ";", "document", ".", "body", ".", "appendChild", "(", "elDialog", ")", ";", "// log element", "elLog", "=", "document", ".", "createElement", "(", "\"section\"", ")", ";", "elLog", ".", "setAttribute", "(", "\"id\"", ",", "\"alertify-logs\"", ")", ";", "elLog", ".", "className", "=", "\"alertify-logs alertify-logs-hidden\"", ";", "document", ".", "body", ".", "appendChild", "(", "elLog", ")", ";", "// set tabindex attribute on body element", "// this allows script to give it focus", "// after the dialog is closed", "document", ".", "body", ".", "setAttribute", "(", "\"tabindex\"", ",", "\"0\"", ")", ";", "// set transition type", "this", ".", "transition", "=", "getTransitionEvent", "(", ")", ";", "// clean up init method", "delete", "this", ".", "init", ";", "}" ]

[ "Initialize", "Alertify", "Create", "the", "2", "main", "elements" ]

[ "function", "(", "message", ",", "type", ",", "wait", ")", "{", "// check to ensure the alertify dialog element", "// has been successfully created", "var", "check", "=", "function", "(", ")", "{", "if", "(", "elLog", "&&", "elLog", ".", "scrollTop", "!==", "null", ")", "return", ";", "else", "check", "(", ")", ";", "}", ";", "// initialize alertify if it hasn't already been done", "if", "(", "typeof", "this", ".", "init", "===", "\"function\"", ")", "{", "this", ".", "init", "(", ")", ";", "check", "(", ")", ";", "}", "elLog", ".", "className", "=", "\"alertify-logs\"", ";", "this", ".", "notify", "(", "message", ",", "type", ",", "wait", ")", ";", "return", "this", ";", "}" ]

[ "Show", "a", "new", "log", "message", "box" ]

[ "function", "(", "fromQueue", ")", "{", "var", "item", "=", "queue", "[", "0", "]", ",", "self", "=", "this", ",", "transitionDone", ";", "// dialog is open", "isopen", "=", "true", ";", "// Set button focus after transition", "transitionDone", "=", "function", "(", "event", ")", "{", "event", ".", "stopPropagation", "(", ")", ";", "self", ".", "setFocus", "(", ")", ";", "// unbind event so function only gets called once", "self", ".", "unbind", "(", "elDialog", ",", "self", ".", "transition", ".", "type", ",", "transitionDone", ")", ";", "}", ";", "// whether CSS transition exists", "if", "(", "this", ".", "transition", ".", "supported", "&&", "!", "fromQueue", ")", "{", "this", ".", "bind", "(", "elDialog", ",", "this", ".", "transition", ".", "type", ",", "transitionDone", ")", ";", "}", "// build the proper dialog HTML", "elDialog", ".", "innerHTML", "=", "this", ".", "build", "(", "item", ")", ";", "// assign all the common elements", "btnReset", "=", "$", "(", "\"alertify-resetFocus\"", ")", ";", "btnOK", "=", "$", "(", "\"alertify-ok\"", ")", "||", "undefined", ";", "btnCancel", "=", "$", "(", "\"alertify-cancel\"", ")", "||", "undefined", ";", "btnFocus", "=", "(", "_alertify", ".", "buttonFocus", "===", "\"cancel\"", ")", "?", "btnCancel", ":", "(", "(", "_alertify", ".", "buttonFocus", "===", "\"none\"", ")", "?", "$", "(", "\"alertify-noneFocus\"", ")", ":", "btnOK", ")", ",", "input", "=", "$", "(", "\"alertify-text\"", ")", "||", "undefined", ";", "form", "=", "$", "(", "\"alertify-form\"", ")", "||", "undefined", ";", "// add placeholder value to the input field", "if", "(", "typeof", "item", ".", "placeholder", "===", "\"string\"", "&&", "item", ".", "placeholder", "!==", "\"\"", ")", "input", ".", "value", "=", "item", ".", "placeholder", ";", "if", "(", "fromQueue", ")", "this", ".", "setFocus", "(", ")", ";", "this", ".", "addListeners", "(", "item", ".", "callback", ")", ";", "}" ]

[ "Initiate", "all", "the", "required", "pieces", "for", "the", "dialog", "box" ]

[ "function", "(", "el", ",", "event", ",", "fn", ")", "{", "if", "(", "typeof", "el", ".", "removeEventListener", "===", "\"function\"", ")", "{", "el", ".", "removeEventListener", "(", "event", ",", "fn", ",", "false", ")", ";", "}", "else", "if", "(", "el", ".", "detachEvent", ")", "{", "el", ".", "detachEvent", "(", "\"on\"", "+", "event", ",", "fn", ")", ";", "}", "}" ]

[ "Unbind", "events", "to", "elements" ]

[ "function", "output", "(", "sourceCode", ",", "filePath", ")", "{", "return", "new", "Promise", "(", "function", "(", "resolve", ",", "reject", ")", "{", "mkdirp", "(", "path", ".", "dirname", "(", "filePath", ")", ",", "function", "(", "ioErr", ")", "{", "if", "(", "ioErr", ")", "{", "reject", "(", "ioErr", ")", ";", "throw", "ioErr", ";", "}", "fs", ".", "writeFile", "(", "filePath", ",", "sourceCode", ",", "function", "(", "writeErr", ")", "{", "if", "(", "writeErr", ")", "{", "reject", "(", "writeErr", ")", ";", "throw", "writeErr", ";", "}", "resolve", "(", ")", ";", "}", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Output", "file", "by", "source", "code", "string" ]

[ "function", "ValueTemplate", "(", "type", ",", "defaultValue", ",", "validator", ")", "{", "this", ".", "type", "=", "type", ";", "this", ".", "defaultValue", "=", "defaultValue", ";", "this", ".", "validator", "=", "validator", ";", "}" ]

[ "Creates", "a", "ValueTemplate", "." ]

[ "function", "PropertyTemplate", "(", "name", ",", "required", ",", "nullable", ",", "template", ")", "{", "this", ".", "name", "=", "name", ";", "this", ".", "required", "=", "required", ";", "this", ".", "nullable", "=", "nullable", ";", "this", ".", "template", "=", "template", ";", "}" ]

[ "Creates", "a", "PropertyTemplate", "." ]

[ "function", "getByFirstImage", "(", "file", ",", "attributes", ")", "{", "var", "$", "=", "cheerio", ".", "load", "(", "file", ".", "contents", ".", "toString", "(", ")", ")", ",", "img", "=", "$", "(", "'img'", ")", ".", "first", "(", ")", ",", "obj", "=", "{", "}", ";", "if", "(", "img", ".", "length", ")", "{", "_", ".", "forEach", "(", "attributes", ",", "function", "(", "attribute", ")", "{", "obj", "[", "attribute", "]", "=", "img", ".", "attr", "(", "attribute", ")", ";", "}", ")", ";", "return", "obj", ";", "}", "else", "{", "return", "undefined", ";", "}", "}" ]

[ "retrieve", "cover", "from", "file", "object", "by", "extracting", "the", "first", "image" ]

[ "function", "(", "name", ",", "socket", ")", "{", "var", "self", "=", "this", ";", "// check input", "if", "(", "name", "&&", "socket", ")", "{", "log", "(", "'ws'", ",", "'init'", ",", "name", ",", "'connection'", ")", ";", "// main data structure", "pool", "[", "name", "]", "=", "{", "socket", ":", "socket", ",", "time", ":", "+", "new", "Date", "(", ")", ",", "count", ":", "0", ",", "active", ":", "true", "}", ";", "// disable link on close", "pool", "[", "name", "]", ".", "socket", ".", "on", "(", "'close'", ",", "function", "(", ")", "{", "self", ".", "remove", "(", "name", ")", ";", "}", ")", ";", "// await for an answer", "pool", "[", "name", "]", ".", "socket", ".", "on", "(", "'message'", ",", "function", "(", "message", ")", "{", "// has link to talk back", "if", "(", "pool", "[", "name", "]", ".", "response", ")", "{", "log", "(", "'ws'", ",", "'get'", ",", "name", ",", "message", ")", ";", "pool", "[", "name", "]", ".", "response", ".", "end", "(", "message", ")", ";", "}", "}", ")", ";", "return", "true", ";", "}", "// failure", "log", "(", "'ws'", ",", "'init'", ",", "name", ",", "'fail to connect (wrong name or link)'", ")", ";", "return", "false", ";", "}" ]

[ "New", "WebSocket", "creation", "." ]

[ "function", "(", "name", ")", "{", "// valid connection", "if", "(", "name", "in", "pool", ")", "{", "log", "(", "'ws'", ",", "'exit'", ",", "name", ",", "'close'", ")", ";", "return", "delete", "pool", "[", "name", "]", ";", "}", "// failure", "log", "(", "'ws'", ",", "'del'", ",", "name", ",", "'fail to remove (invalid connection)'", ")", ";", "return", "false", ";", "}" ]

[ "Clear", "resources", "on", "WebSocket", "deletion", "." ]

[ "function", "(", "name", ")", "{", "// valid connection", "if", "(", "name", "in", "pool", ")", "{", "return", "{", "active", ":", "pool", "[", "name", "]", ".", "active", ",", "count", ":", "pool", "[", "name", "]", ".", "count", "}", ";", "}", "// failure", "return", "{", "active", ":", "false", "}", ";", "}" ]

[ "Detailed", "information", "of", "the", "named", "WebSocket", "instance", "." ]

[ "function", "(", "name", ",", "data", ",", "response", ")", "{", "log", "(", "'ws'", ",", "'send'", ",", "name", ",", "data", ")", ";", "// store link to talk back when ready", "pool", "[", "name", "]", ".", "response", "=", "response", ";", "// actual post", "pool", "[", "name", "]", ".", "socket", ".", "send", "(", "data", ")", ";", "pool", "[", "name", "]", ".", "count", "++", ";", "}" ]

[ "Forward", "the", "request", "to", "the", "given", "session", "." ]

[ "function", "(", "req", ",", "res", ")", "{", "if", "(", "res", ".", "locals", ".", "success", ")", "{", "options", ".", "success", "(", "model", ",", "response", ")", ";", "}", "else", "{", "options", ".", "error", "(", "model", ",", "response", ")", ";", "}", "}" ]

[ "Create", "a", "route", "handler", "wrapper", "to", "call", "success", "or", "error", "." ]

[ "function", "(", "s", ")", "{", "var", "currentState", "=", "history", "[", "historyIndex", "]", ";", "if", "(", "typeof", "s", "===", "'function'", ")", "{", "s", "=", "s", "(", "history", "[", "historyIndex", "]", ".", "toJS", "(", ")", ")", ";", "}", "var", "newState", "=", "currentState", ".", "merge", "(", "s", ")", ";", "history", "=", "history", ".", "slice", "(", "0", ",", "historyIndex", "+", "1", ")", ";", "history", ".", "push", "(", "newState", ")", ";", "historyIndex", "++", ";", "return", "new", "Immutable", ".", "Map", "(", "history", "[", "historyIndex", "]", ")", ".", "toJS", "(", ")", ";", "}" ]

[ "ensure", "that", "setting", "state", "via", "assignment", "performs", "an", "immutable", "operation" ]

[ "function", "(", "name", ")", "{", "var", "type", "=", "_", ".", "reduce", "(", "name", ".", "split", "(", "'.'", ")", ",", "function", "(", "memo", ",", "val", ")", "{", "return", "memo", "[", "val", "]", ";", "}", ",", "exports", ")", ";", "return", "type", "!==", "exports", "?", "type", ":", "null", ";", "}" ]

[ "Find", "a", "type", "on", "the", "global", "object", "by", "name", ".", "Splits", "name", "on", "dots", "." ]

[ "function", "(", "model", ")", "{", "var", "coll", "=", "this", ".", "getCollection", "(", "model", ")", ";", "coll", ".", "_onModelEvent", "(", "'change:'", "+", "model", ".", "idAttribute", ",", "model", ",", "coll", ")", ";", "}" ]

[ "Explicitly", "update", "a", "model", "s", "id", "in", "it", "s", "store", "collection" ]

[ "function", "(", ")", "{", "Backbone", ".", "Relational", ".", "store", ".", "getCollection", "(", "this", ".", "instance", ")", ".", "unbind", "(", "'relational:remove'", ",", "this", ".", "_modelRemovedFromCollection", ")", ";", "Backbone", ".", "Relational", ".", "store", ".", "getCollection", "(", "this", ".", "relatedModel", ")", ".", "unbind", "(", "'relational:add'", ",", "this", ".", "_relatedModelAdded", ")", ".", "unbind", "(", "'relational:remove'", ",", "this", ".", "_relatedModelRemoved", ")", ";", "_", ".", "each", "(", "this", ".", "getReverseRelations", "(", ")", ",", "function", "(", "relation", ")", "{", "relation", ".", "removeRelated", "(", "this", ".", "instance", ")", ";", "}", ",", "this", ")", ";", "}" ]

[ "Cleanup", ".", "Get", "reverse", "relation", "call", "removeRelated", "on", "each", "." ]

[ "function", "proxyVerifyCallback", "(", "fn", ",", "args", ",", "done", ")", "{", "const", "{", "callback", ",", "index", "}", "=", "findCallback", "(", "args", ")", ";", "args", "[", "index", "]", "=", "function", "(", "err", ",", "user", ")", "{", "done", "(", "err", ",", "user", ",", "callback", ")", ";", "}", ";", "fn", ".", "apply", "(", "null", ",", "args", ")", ";", "}" ]

[ "Intercepts", "passport", "callback" ]

[ "function", "SetOrGet", "(", "input", ",", "field", ",", "def", ")", "{", "return", "input", "[", "field", "]", "=", "Deffy", "(", "input", "[", "field", "]", ",", "def", ")", ";", "}" ]

[ "SetOrGet", "Sets", "or", "gets", "an", "object", "field", "value", "." ]

[ "function", "proxyEvent", "(", "emitter", ",", "event", ",", "optionalCallback", ")", "{", "emitter", ".", "on", "(", "event", ",", "function", "(", ")", "{", "if", "(", "optionalCallback", ")", "{", "optionalCallback", ".", "apply", "(", "client", ",", "arguments", ")", "}", "client", ".", "emit", "(", "event", ")", "}", ")", "}" ]

[ "Emit", "events", "from", "a", "stream", "the", "client", "manages", "as", "the", "client", "s", "own", "." ]

[ "function", "(", "parent", ",", "app", ")", "{", "this", ".", "use", "(", "middleware", ".", "sanitizeHost", "(", "app", ")", ")", ";", "this", ".", "use", "(", "middleware", ".", "bodyParser", "(", ")", ")", ";", "this", ".", "use", "(", "middleware", ".", "cookieParser", "(", ")", ")", ";", "this", ".", "use", "(", "middleware", ".", "fragmentRedirect", "(", ")", ")", ";", "}" ]

[ "Removing", "validateCSRFToken", "to", "replace", "with", "connect", "s", "csrf", "middleware", ".", "Double", "CSRF", "protection", "makes", "dealing", "with", "static", "forms", "difficult", "by", "default", "." ]

[ "function", "Scope", "(", "site", ",", "page", ",", "params", ")", "{", "this", ".", "site", "=", "site", "this", ".", "page", "=", "page", "this", ".", "params", "=", "params", "||", "{", "}", "this", ".", "status", "=", "200", "this", ".", "_headers", "=", "{", "}", "this", ".", "locale", "=", "site", ".", "locales", ".", "default", "// Set default headers.", "this", ".", "header", "(", "\"Content-Type\"", ",", "\"text/html; charset=utf-8\"", ")", "this", ".", "header", "(", "\"Connection\"", ",", "\"close\"", ")", "this", ".", "header", "(", "\"Server\"", ",", "\"Skira\"", ")", "}" ]

[ "The", "state", "object", "are", "all", "variables", "made", "available", "to", "views", "and", "modules", "." ]

[ "function", "(", "option", ")", "{", "if", "(", "this", ".", "_self", "===", "option", ".", "exporter", ")", "{", "return", ";", "}", "if", "(", "this", ".", "_action", "&&", "!", "this", ".", "_action", ".", "test", "(", "option", ".", "action", ")", ")", "{", "return", ";", "}", "if", "(", "this", ".", "_path", "&&", "!", "this", ".", "_path", ".", "test", "(", "option", ".", "path", ")", ")", "{", "return", ";", "}", "if", "(", "this", ".", "_notePath", "||", "this", ".", "_noteAction", ")", "{", "if", "(", "!", "(", "option", "instanceof", "EventPicker", ")", "||", "option", ".", "Test", "(", "this", ")", ")", "{", "return", ";", "}", "}", "utilTick", "(", "this", ".", "_self", ",", "this", ".", "_listen", ",", "option", ",", "this", ".", "_async", ")", ";", "}" ]

[ "execute", "event", "list" ]

[ "function", "glupost", "(", "configuration", ")", "{", "const", "tasks", "=", "configuration", ".", "tasks", "||", "{", "}", "const", "template", "=", "configuration", ".", "template", "||", "{", "}", "// Expand template object with defaults.", "expand", "(", "template", ",", "{", "transforms", ":", "[", "]", ",", "dest", ":", "\".\"", "}", ")", "// Create tasks.", "const", "names", "=", "Object", ".", "keys", "(", "tasks", ")", "for", "(", "const", "name", "of", "names", ")", "{", "const", "task", "=", "retrieve", "(", "tasks", ",", "name", ")", "if", "(", "typeof", "task", "===", "\"object\"", ")", "expand", "(", "task", ",", "template", ")", "gulp", ".", "task", "(", "name", ",", "compose", "(", "task", ")", ")", "}", "watch", "(", "tasks", ")", "}" ]

[ "Create", "gulp", "tasks", "." ]

[ "function", "compose", "(", "task", ")", "{", "// Already composed action.", "if", "(", "task", ".", "action", ")", "return", "task", ".", "action", "// 1. named task.", "if", "(", "typeof", "task", "===", "\"string\"", ")", "return", "task", "// 2. a function directly.", "if", "(", "typeof", "task", "===", "\"function\"", ")", "return", "task", ".", "length", "?", "task", ":", "(", ")", "=>", "Promise", ".", "resolve", "(", "task", "(", ")", ")", "// 3. task object.", "if", "(", "typeof", "task", "!==", "\"object\"", ")", "throw", "new", "Error", "(", "\"A task must be a string, function, or object.\"", ")", "if", "(", "task", ".", "watch", "===", "true", ")", "{", "// Watching task without a valid path.", "if", "(", "!", "task", ".", "src", ")", "throw", "new", "Error", "(", "\"No path given to watch.\"", ")", "task", ".", "watch", "=", "task", ".", "src", "}", "let", "transform", "if", "(", "task", ".", "src", ")", "transform", "=", "(", ")", "=>", "pipify", "(", "task", ")", "// No transform function and no series/parallel.", "if", "(", "!", "transform", "&&", "!", "task", ".", "series", "&&", "!", "task", ".", "parallel", ")", "throw", "new", "Error", "(", "\"A task must do something.\"", ")", "// Both series and parallel.", "if", "(", "task", ".", "series", "&&", "task", ".", "parallel", ")", "throw", "new", "Error", "(", "\"A task can't have both .series and .parallel properties.\"", ")", "// Only transform function.", "if", "(", "!", "task", ".", "series", "&&", "!", "task", ".", "parallel", ")", "{", "task", ".", "action", "=", "transform", "}", "// Series/parallel sequence of tasks.", "else", "{", "const", "sequence", "=", "task", ".", "series", "?", "\"series\"", ":", "\"parallel\"", "if", "(", "transform", ")", "task", "[", "sequence", "]", ".", "push", "(", "transform", ")", "task", ".", "action", "=", "gulp", "[", "sequence", "]", "(", "...", "task", "[", "sequence", "]", ".", "map", "(", "compose", ")", ")", "}", "return", "task", ".", "action", "}" ]

[ "Convert", "task", "object", "to", "a", "function", "." ]