Datasets:

CM

/

codexglue_code2text_javascript

like 9

[ "function", "statFiles", "(", "files", ",", "source", ",", "fn", ")", "{", "var", "batch", "=", "new", "Batch", "(", ")", ";", "files", ".", "forEach", "(", "function", "(", "file", ")", "{", "batch", ".", "push", "(", "statFile", "(", "file", ",", "source", ")", ")", ";", "}", ")", ";", "batch", ".", "end", "(", "fn", ")", ";", "}" ]

[ "Get", "files", "info" ]

[ "function", "statFile", "(", "file", ",", "source", ")", "{", "return", "function", "(", "cb", ")", "{", "var", "abs", "=", "join", "(", "source", ",", "file", ")", ";", "stat", "(", "abs", ",", "function", "(", "err", ",", "stats", ")", "{", "if", "(", "err", ")", "return", "cb", "(", "err", ")", ";", "var", "manifest", "=", "{", "name", ":", "file", ",", "abs", ":", "abs", ",", "mtime", ":", "Math", ".", "floor", "(", "stats", ".", "mtime", ".", "getTime", "(", ")", "/", "1000", ")", ",", "mode", ":", "''", "+", "parseInt", "(", "stats", ".", "mode", ".", "toString", "(", "8", ")", ",", "10", ")", ",", "size", ":", "''", "+", "stats", ".", "size", "// do we need this?", "}", ";", "if", "(", "stats", ".", "isDirectory", "(", ")", ")", "return", "cb", "(", ")", ";", "if", "(", "stats", ".", "isSymbolicLink", "(", ")", ")", "return", "fs", ".", "readlink", "(", "abs", ",", "finish", "(", "'link'", ")", ")", ";", "calculateHash", "(", "abs", ",", "finish", "(", "'hash'", ")", ")", ";", "function", "finish", "(", "key", ")", "{", "return", "function", "(", "err", ",", "val", ")", "{", "if", "(", "err", ")", "return", "cb", "(", "err", ")", ";", "manifest", "[", "key", "]", "=", "val", ";", "cb", "(", "null", ",", "manifest", ")", ";", "}", ";", "}", "}", ")", ";", "}", ";", "}" ]

[ "Get", "a", "file", "manifest" ]

[ "function", "calculateHash", "(", "file", ",", "fn", ")", "{", "read", "(", "file", ",", "function", "(", "err", ",", "bin", ")", "{", "if", "(", "err", ")", "return", "fn", "(", "err", ")", ";", "fn", "(", "null", ",", "hash", "(", "'sha256'", ")", ".", "update", "(", "bin", ")", ".", "digest", "(", "'hex'", ")", ")", ";", "}", ")", ";", "}" ]

[ "Calculate", "hash", "for", "a", "file" ]

[ "function", "normalizeManifest", "(", "manifest", ",", "fn", ")", "{", "var", "obj", "=", "{", "}", ";", "manifest", ".", "forEach", "(", "function", "(", "file", ")", "{", "if", "(", "!", "file", ")", "return", ";", "obj", "[", "file", ".", "name", "]", "=", "{", "mtime", ":", "file", ".", "mtime", ",", "mode", ":", "file", ".", "mode", ",", "size", ":", "file", ".", "size", ",", "hash", ":", "file", ".", "hash", ",", "link", ":", "file", ".", "link", "}", ";", "}", ")", ";", "fn", "(", "null", ",", "obj", ")", ";", "}" ]

[ "Normalize", "the", "manifest", "into", "the", "expected", "format" ]

[ "function", "findMissing", "(", "manifest", ",", "request", ",", "host", ",", "fn", ")", "{", "request", ".", "post", "(", "host", "+", "'/manifest/diff'", ")", ".", "send", "(", "{", "manifest", ":", "JSON", ".", "stringify", "(", "manifest", ")", "}", ")", ".", "end", "(", "function", "(", "err", ",", "res", ")", "{", "if", "(", "err", ")", "return", "fn", "(", "err", ")", ";", "if", "(", "res", ".", "error", ")", "return", "fn", "(", "res", ".", "error", ")", ";", "fn", "(", "null", ",", "res", ".", "body", ")", ";", "}", ")", ";", "}" ]

[ "Find", "the", "missing", "files", "in", "the", "manifest" ]

[ "function", "selectMissing", "(", "missing", ",", "manifest", ",", "fn", ")", "{", "fn", "(", "null", ",", "manifest", ".", "filter", "(", "function", "(", "file", ")", "{", "return", "file", "&&", "~", "missing", ".", "indexOf", "(", "file", ".", "hash", ")", ";", "}", ")", ")", ";", "}" ]

[ "Find", "the", "missing", "files", "from", "the", "manifest" ]

[ "function", "uploadMissing", "(", "missing", ",", "request", ",", "host", ",", "log", ",", "fn", ")", "{", "var", "batch", "=", "new", "Batch", "(", ")", ";", "missing", ".", "forEach", "(", "function", "(", "file", ")", "{", "batch", ".", "push", "(", "uploadFile", "(", "file", ",", "request", ",", "host", ")", ")", ";", "}", ")", ";", "batch", ".", "on", "(", "'progress'", ",", "function", "(", ")", "{", "log", "(", "'.'", ")", ";", "}", ")", ";", "batch", ".", "end", "(", "function", "(", "err", ",", "res", ")", "{", "log", "(", "' done\\n'", ")", ";", "fn", "(", "err", ",", "res", ")", ";", "}", ")", ";", "}" ]

[ "Upload", "the", "missing", "files", "to", "the", "build", "server" ]

[ "function", "uploadFile", "(", "file", ",", "request", ",", "host", ")", "{", "return", "function", "(", "cb", ")", "{", "request", ".", "post", "(", "host", "+", "'/file/'", "+", "file", ".", "hash", ")", ".", "attach", "(", "'data'", ",", "file", ".", "abs", ")", ".", "end", "(", "function", "(", "err", ",", "res", ")", "{", "if", "(", "err", ")", "return", "cb", "(", "err", ")", ";", "if", "(", "res", ".", "error", ")", "return", "cb", "(", "res", ".", "error", ")", ";", "return", "cb", "(", ")", ";", "}", ")", ";", "}", ";", "}" ]

[ "Upload", "a", "single", "file", "to", "the", "build", "server" ]

[ "function", "saveManifest", "(", "manifest", ",", "request", ",", "host", ",", "fn", ")", "{", "request", ".", "post", "(", "host", "+", "'/manifest'", ")", ".", "send", "(", "{", "manifest", ":", "JSON", ".", "stringify", "(", "manifest", ")", "}", ")", ".", "end", "(", "function", "(", "err", ",", "res", ")", "{", "if", "(", "err", ")", "return", "fn", "(", "err", ")", ";", "if", "(", "res", ".", "error", ")", "return", "fn", "(", "res", ".", "error", ")", ";", "fn", "(", "null", ",", "res", ".", "headers", ".", "location", ")", ";", "}", ")", ";", "}" ]

[ "Save", "the", "manifest", "file", "to", "the", "build", "server" ]

[ "function", "use", "(", "type", ")", "{", "// Convert args to array.", "var", "args", "=", "Array", ".", "prototype", ".", "slice", ".", "call", "(", "arguments", ")", ";", "// Check if type not provided.", "if", "(", "'string'", "!==", "typeof", "type", "&&", "type", "instanceof", "Array", "===", "false", ")", "{", "type", "=", "[", "]", ";", "}", "else", "{", "if", "(", "'string'", "===", "typeof", "type", ")", "{", "//wrap string in array to homogenize handling", "type", "=", "[", "type", "]", ";", "}", "args", ".", "shift", "(", ")", ";", "}", "args", ".", "forEach", "(", "function", "(", "arg", ")", "{", "stack", ".", "push", "(", "{", "type", ":", "type", ",", "cb", ":", "arg", "}", ")", ";", "}", ")", ";", "return", "middlebot", ";", "}" ]

[ "Add", "a", "middleware", "in", "the", "stack", "for", "the", "given", "type", "." ]

[ "function", "handle", "(", "type", ",", "req", ",", "res", ",", "out", ")", "{", "var", "index", "=", "0", ";", "var", "ended", "=", "false", ";", "// When called stop middlewares execution.", "res", ".", "end", "=", "end", ";", "// Handle next middleware in stack.", "function", "next", "(", "err", ")", "{", "var", "middleware", "=", "stack", "[", "index", "++", "]", ";", "// No more middlewares or early end.", "if", "(", "!", "middleware", "||", "ended", ")", "{", "if", "(", "out", ")", "out", "(", "err", ",", "req", ",", "res", ")", ";", "return", ";", "}", "// Check if middleware type matches or if it has no type.", "if", "(", "middleware", ".", "type", ".", "indexOf", "(", "type", ")", "===", "-", "1", "&&", "middleware", ".", "type", ".", "length", ">", "0", ")", "return", "next", "(", "err", ")", ";", "try", "{", "var", "arity", "=", "middleware", ".", "cb", ".", "length", ";", "//if err, only execute error middlewares", "if", "(", "err", ")", "{", "//error middlewares have an arity of 4, the first", "//arg being the error", "if", "(", "arity", "===", "4", ")", "{", "middleware", ".", "cb", "(", "err", ",", "req", ",", "res", ",", "next", ")", ";", "}", "else", "{", "next", "(", "err", ")", ";", "}", "}", "else", "if", "(", "arity", "<", "4", ")", "{", "middleware", ".", "cb", "(", "req", ",", "res", ",", "next", ")", ";", "}", "else", "{", "next", "(", ")", ";", "}", "}", "catch", "(", "e", ")", "{", "next", "(", "e", ")", ";", "}", "}", "// Stop middlewares execution.", "function", "end", "(", ")", "{", "ended", "=", "true", ";", "}", "// Start handling.", "next", "(", ")", ";", "}" ]

[ "Handle", "all", "middlewares", "of", "the", "provided", "type", "." ]

[ "function", "writeToConsoleOrStderr", "(", "message", ")", "{", "if", "(", "typeof", "console", "==", "'object'", "&&", "typeof", "console", ".", "warn", "==", "'function'", ")", "console", ".", "warn", "(", "message", ")", ";", "else", "if", "(", "typeof", "process", "==", "'object'", "&&", "typeof", "process", ".", "stderr", "==", "'object'", "&&", "typeof", "process", ".", "stderr", ".", "write", "==", "'function'", ")", "process", ".", "stderr", ".", "write", "(", "message", ")", ";", "else", "throw", "new", "Error", "(", "message", ")", ";", "}" ]

[ "^", "Send", "message", "to", "browser", "console", "or", "CLI", "stderr" ]

[ "function", "(", "value", ")", "{", "switch", "(", "typeof", "value", ")", "{", "case", "'undefined'", ":", "return", "this", ".", "undefined", ";", "case", "'string'", ":", "return", "this", ".", "string", ";", "case", "'number'", ":", "if", "(", "value", "%", "1", "===", "0", ")", "{", "return", "this", ".", "integer", ";", "}", "else", "{", "return", "this", ".", "double", ";", "}", "break", ";", "case", "'boolean'", ":", "return", "this", ".", "boolean", ";", "case", "'function'", ":", "return", "this", "[", "\"function\"", "]", ";", "default", ":", "if", "(", "value", "===", "null", ")", "{", "return", "this", "[", "\"null\"", "]", ";", "}", "else", "if", "(", "value", "instanceof", "Date", ")", "{", "return", "this", ".", "datetime", ";", "}", "else", "if", "(", "value", "instanceof", "Array", ")", "{", "return", "this", ".", "array", ";", "}", "else", "if", "(", "Buffer", ".", "isBuffer", "(", "value", ")", ")", "{", "throw", "new", "TypeError", "(", "\"Value cannot be a buffer\"", ")", ";", "}", "else", "if", "(", "value", "instanceof", "Object", ")", "{", "return", "this", ".", "object", ";", "}", "else", "{", "throw", "new", "TypeError", "(", "'Value must either be a string, integer, double, boolean, date, array, object or function'", ")", ";", "}", "}", "}" ]

[ "Gets", "type", "code", "value", "for", "name", "." ]

[ "function", "preamble", "(", "opts", ")", "{", "var", "str", "=", "''", ";", "var", "index", "=", "opts", ".", "section", "||", "SECTION", ";", "var", "date", "=", "opts", ".", "date", "||", "new", "Date", "(", ")", ".", "toISOString", "(", ")", ";", "var", "version", "=", "opts", ".", "version", "||", "'1.0'", ";", "// section name", "var", "sname", "=", "section", "(", "index", ")", ";", "var", "title", "=", "opts", ".", "title", "||", "opts", ".", "name", ";", "if", "(", "!", "title", ")", "{", "throw", "new", "TypeError", "(", "'manual preamble requires a name or title'", ")", ";", "}", "// use comment", "if", "(", "opts", ".", "comment", ")", "{", "str", "+=", "util", ".", "format", "(", "elements", ".", "comment", ",", "opts", ".", "comment", ")", ";", "}", "//console.dir(title)", "str", "+=", "util", ".", "format", "(", "elements", ".", "th", ",", "strip", "(", "title", ".", "toUpperCase", "(", ")", ")", ",", "index", ",", "date", ",", "(", "strip", "(", "opts", ".", "name", "||", "title", ")", ")", ".", "replace", "(", "/", "\\s+.*$", "/", ",", "''", ")", "+", "' '", "+", "version", ",", "sname", ")", ";", "// add name section", "if", "(", "opts", ".", "name", ")", "{", "var", "name", "=", "strip", "(", "opts", ".", "name", ")", ";", "str", "+=", "util", ".", "format", "(", "elements", ".", "sh", ",", "header", "(", "constants", ".", "NAME", ")", ")", ";", "if", "(", "opts", ".", "description", ")", "{", "str", "+=", "util", ".", "format", "(", "'%s \\\\- %s'", "+", "EOL", ",", "name", ",", "opts", ".", "description", ")", ";", "}", "else", "{", "str", "+=", "util", ".", "format", "(", "'%s'", "+", "EOL", ",", "name", ")", ";", "}", "}", "return", "str", ";", "}" ]

[ "Gets", "the", "preamble", "for", "a", "man", "page", "." ]

[ "function", "splitActionName", "(", "actionName", ")", "{", "if", "(", "actionName", ".", "indexOf", "(", "'_'", ")", ">", "0", ")", "return", "actionName", ".", "split", "(", "'_'", ")", "else", "return", "actionName", ".", "split", "(", "/", "(?=[A-Z])", "/", ")", ".", "map", "(", "p", "=>", "p", ".", "toLowerCase", "(", ")", ")", "}" ]

[ "Returns", "an", "array", "with", "the", "action", "s", "name", "split", "by", "underscores", "or", "lowerCamelCase", "." ]

[ "function", "parseMethodName", "(", "parts", ",", "argsNames", ")", "{", "/**\r\n * argsName could be in different case from that\r\n * of function's name.\r\n */", "const", "argsNamesLower", "=", "argsNames", ".", "map", "(", "arg", "=>", "arg", ".", "toLowerCase", "(", ")", ")", "/**\r\n * Suppresses HTTP method if exists\r\n */", "if", "(", "keysMethods", ".", "indexOf", "(", "parts", "[", "0", "]", ".", "toLowerCase", "(", ")", ")", ">=", "0", ")", "parts", "=", "parts", ".", "slice", "(", "1", ")", "/**\r\n * Converts each method part into route path \r\n */", "return", "parts", ".", "reduce", "(", "(", "prev", ",", "curr", ")", "=>", "{", "if", "(", "keywordsMaps", "[", "curr", "]", ")", "prev", "+=", "keywordsMaps", "[", "curr", "]", "else", "{", "if", "(", "prev", ".", "slice", "(", "-", "1", ")", "!=", "'/'", ")", "prev", "+=", "'/'", "const", "index", "=", "argsNamesLower", ".", "indexOf", "(", "curr", ".", "toLowerCase", "(", ")", ")", "if", "(", "index", ">=", "0", ")", "{", "prev", "+=", "':'", "prev", "+=", "argsNames", "[", "index", "]", "// Preserve argument Case\r", "}", "else", "{", "prev", "+=", "curr", "}", "}", "return", "prev", "}", ",", "''", ")", "}" ]

[ "Returns", "the", "route", "path", "for", "the", "corresponding", "controller", "method", "name", "." ]

[ "function", "parseHttpMethod", "(", "parts", ")", "{", "const", "prefix", "=", "parts", "[", "0", "]", ".", "toLowerCase", "(", ")", "if", "(", "keysMethods", ".", "indexOf", "(", "prefix", ")", ">=", "0", ")", "return", "prefix", "else", "return", "GET", "}" ]

[ "Gets", "the", "HTTP", "method", "from", "the", "Controller", "method", "name", ".", "Otherwise", "returns", "get", "." ]

[ "function", "lookupParameterOnReq", "(", "name", ",", "index", ",", "length", ")", "{", "return", "(", "req", ",", "res", ")", "=>", "{", "if", "(", "req", "[", "name", "]", ")", "return", "req", "[", "name", "]", "if", "(", "req", ".", "query", "&&", "req", ".", "query", "[", "name", "]", ")", "return", "req", ".", "query", "[", "name", "]", "if", "(", "req", ".", "body", "&&", "req", ".", "body", "[", "name", "]", ")", "return", "req", ".", "body", "[", "name", "]", "if", "(", "res", ".", "locals", "&&", "res", ".", "locals", "[", "name", "]", ")", "return", "res", ".", "locals", "[", "name", "]", "if", "(", "req", ".", "app", ".", "locals", "&&", "req", ".", "app", ".", "locals", "[", "name", "]", ")", "return", "req", ".", "app", ".", "locals", "[", "name", "]", "/**\r\n * In this case there is not a matching property in Request object for\r\n * the given parameter name. \r\n * We just accept it, if that is the last parameter of the method, in which \r\n * case it should correspond to a callback.\r\n */", "if", "(", "index", "!=", "(", "length", "-", "1", ")", ")", "throw", "new", "Error", "(", "'Parameter '", "+", "name", "+", "' not found in Request object!!!'", ")", "return", "null", "}", "}" ]

[ "!!!!!DEPRECATED", ">", "=", "2", ".", "0", ".", "1", "Given", "the", "name", "of", "a", "parameter", "search", "for", "it", "in", "req", "req", ".", "query", "req", ".", "body", "res", ".", "locals", "app", ".", "locals", "." ]

[ "function", "appLoader", "(", "app", ",", "config", ")", "{", "app", ".", "define", "(", "'load'", ",", "load", "(", "'view'", ",", "config", ")", ")", ";", "var", "fn", "=", "app", ".", "view", ";", "app", ".", "define", "(", "'view'", ",", "function", "(", ")", "{", "var", "view", "=", "fn", ".", "apply", "(", "this", ",", "arguments", ")", ";", "utils", ".", "contents", ".", "sync", "(", "view", ")", ";", "return", "view", ";", "}", ")", ";", "}" ]

[ "Adds", "a", ".", "load", "method", "to", "the", "app", "instance", "for", "loading", "views", "that", "that", "don", "t", "belong", "to", "any", "particular", "collection", ".", "It", "just", "returns", "the", "object", "of", "views", "instead", "of", "caching", "them", "." ]

[ "function", "createLoader", "(", "options", ",", "fn", ")", "{", "var", "loader", "=", "new", "utils", ".", "Loader", "(", "options", ")", ";", "return", "function", "(", ")", "{", "if", "(", "!", "this", ".", "isApp", ")", "loader", ".", "cache", "=", "this", ".", "views", ";", "loader", ".", "options", ".", "loaderFn", "=", "fn", ".", "bind", "(", "this", ")", ";", "loader", ".", "load", ".", "apply", "(", "loader", ",", "arguments", ")", ";", "return", "loader", ".", "cache", ";", "}", ";", "}" ]

[ "Create", "a", "Loader", "instance", "with", "a", "loaderfn", "bound", "to", "the", "app", "or", "collection", "instance", "." ]

[ "function", "load", "(", "method", ",", "config", ")", "{", "return", "function", "(", "patterns", ",", "options", ")", "{", "var", "opts", "=", "mergeOptions", "(", "this", ",", "config", ",", "options", ")", ";", "var", "loader", "=", "createLoader", "(", "opts", ",", "this", "[", "method", "]", ")", ";", "return", "loader", ".", "apply", "(", "this", ",", "arguments", ")", ";", "}", ";", "}" ]

[ "Create", "a", "function", "for", "loading", "views", "using", "the", "given", "method", "on", "the", "collection", "or", "app", "." ]

[ "function", "(", ")", "{", "waitForServers", "--", ";", "if", "(", "waitForServers", ")", "return", ";", "if", "(", "seminarjs", ".", "get", "(", "'logger'", ")", ")", "{", "console", ".", "log", "(", "dashes", "+", "startupMessages", ".", "join", "(", "'\\n'", ")", "+", "dashes", ")", ";", "}", "events", ".", "onStart", "&&", "events", ".", "onStart", "(", ")", ";", "}" ]

[ "Log", "the", "startup", "messages", "and", "calls", "the", "onStart", "method" ]

[ "function", "randstr", "(", "options", ")", "{", "var", "opt", "=", "_validateOptions", "(", "options", ")", ";", "var", "from", ",", "to", ";", "if", "(", "Array", ".", "isArray", "(", "opt", ".", "length", ")", ")", "{", "_a", "=", "opt", ".", "length", ",", "from", "=", "_a", "[", "0", "]", ",", "to", "=", "_a", "[", "1", "]", ";", "}", "else", "{", "from", "=", "to", "=", "opt", ".", "length", ";", "}", "var", "str", "=", "''", ";", "if", "(", "0", "===", "to", ")", "{", "return", "str", ";", "}", "var", "charsIsString", "=", "'string'", "===", "typeof", "opt", ".", "chars", ";", "var", "charsLastIndex", "=", "charsIsString", "?", "opt", ".", "chars", ".", "length", "-", "1", ":", "0", ";", "var", "includeControlChars", "=", "true", "===", "opt", ".", "includeControlChars", ";", "var", "hasAcceptableFunc", "=", "'function'", "===", "typeof", "opt", ".", "acceptable", ";", "var", "hasReplacer", "=", "'function'", "===", "typeof", "opt", ".", "replacer", ";", "var", "max", "=", "_randomIntBetween", "(", "opt", ".", "random", ",", "from", ",", "to", ")", ";", "// console.log( 'max', max, 'from', from, 'to', to );", "for", "(", "var", "i", "=", "0", ",", "len", "=", "0", ",", "charCode", "=", "void", "0", ",", "chr", "=", "void", "0", ";", "i", "<", "max", "&&", "len", "<", "max", ";", "++", "i", ")", "{", "if", "(", "charsIsString", ")", "{", "var", "index", "=", "_randomIntBetween", "(", "opt", ".", "random", ",", "0", ",", "charsLastIndex", ")", ";", "charCode", "=", "opt", ".", "chars", ".", "charCodeAt", "(", "index", ")", ";", "}", "else", "{", "charCode", "=", "_randomIntBetween", "(", "opt", ".", "random", ",", "opt", ".", "chars", "[", "0", "]", ",", "opt", ".", "chars", "[", "1", "]", ")", ";", "}", "// Non printable?", "if", "(", "!", "includeControlChars", "&&", "_isControlChar", "(", "charCode", ")", ")", "{", "// console.log( 'NOT PRINTABLE!');", "--", "i", ";", "// back to try again", "continue", ";", "}", "chr", "=", "String", ".", "fromCharCode", "(", "charCode", ")", ";", "// console.log( 'charCode', charCode, 'char', chr );", "if", "(", "hasAcceptableFunc", "&&", "!", "opt", ".", "acceptable", ".", "call", "(", "null", ",", "chr", ")", ")", "{", "--", "i", ";", "// back to try again", "continue", ";", "}", "if", "(", "hasReplacer", ")", "{", "chr", "=", "opt", ".", "replacer", ".", "call", "(", "null", ",", "chr", ")", ";", "// console.log( 'char after', chr );", "// Their combined length pass the limit?", "if", "(", "(", "len", "+", "chr", ".", "length", ")", ">", "max", ")", "{", "// console.log( 'greater than max!', 'i', i, 'max', max, 'str', len, 'chr', chr.length );", "--", "i", ";", "// back to try again", "continue", ";", "}", "}", "str", "+=", "chr", ";", "len", "=", "str", ".", "length", ";", "}", "return", "str", ";", "var", "_a", ";", "}" ]

[ "Generates", "a", "random", "string", "according", "to", "the", "given", "options", "." ]

[ "function", "updateStatus", "(", "evType", ",", "opts", ")", "{", "var", "t2", "=", "new", "Date", "(", ")", "var", "elapsed", "=", "(", "t2", ".", "getTime", "(", ")", "-", "t1", ".", "getTime", "(", ")", ")", "/", "1000", "var", "msg", "=", "{", "timeElapsed", ":", "elapsed", ",", "stdout", ":", "opts", ".", "stdout", "||", "\"\"", ",", "stderr", ":", "opts", ".", "stderr", "||", "\"\"", ",", "stdmerged", ":", "opts", ".", "stdmerged", "||", "\"\"", ",", "info", ":", "opts", ".", "info", ",", "step", ":", "opts", ".", "step", ",", "deployExitCode", ":", "null", ",", "url", ":", "null", "||", "opts", ".", "url", ",", "}", "if", "(", "opts", ".", "deployExitCode", "!==", "undefined", ")", "{", "msg", ".", "deployExitCode", "=", "opts", ".", "deployExitCode", "}", "emitter", ".", "emit", "(", "evType", ",", "msg", ")", "}" ]

[ "Emit", "a", "status", "update", "event", ".", "This", "can", "result", "in", "data", "being", "sent", "to", "the", "user", "s", "browser", "in", "realtime", "via", "socket", ".", "io", "." ]

[ "function", "(", "s_thing", ")", "{", "if", "(", "H_SPARQL_CHARS", "[", "s_thing", "[", "0", "]", "]", ")", "return", "s_thing", ";", "else", "if", "(", "s_thing", ".", "indexOf", "(", "':'", ")", "!=", "-", "1", ")", "return", "s_thing", ";", "else", "if", "(", "s_thing", "==", "'a'", ")", "return", "s_thing", ";", "else", "return", "':'", "+", "s_thing", ";", "}" ]

[ "converts", "thing", "alias", "to", "proper", "identifier", "if", "not", "already", "specified" ]

[ "function", "(", "s_str", ")", "{", "if", "(", "H_SPARQL_CHARS", "[", "s_str", "[", "0", "]", "]", ")", "return", "s_str", ";", "else", "if", "(", "s_str", ".", "indexOf", "(", "':'", ")", "!=", "-", "1", ")", "return", "s_str", ";", "else", "if", "(", "/", "^(?:[0-9]|(?:\\-|\\.|\\-\\.)[0-9])", "/", ".", "test", "(", "s_str", ")", ")", "return", "s_str", ";", "else", "return", "JSON", ".", "stringify", "(", "s_str", ")", ";", "}" ]

[ "converts", "string", "to", "proper", "identifier", "if", "not", "already", "specified" ]

[ "function", "(", "sq_prefixes", ")", "{", "var", "s_select", "=", "this", ".", "select", "||", "'*'", ";", "var", "sq_select", "=", "'SELECT '", "+", "s_select", "+", "' WHERE {'", ";", "var", "sq_where", "=", "this", ".", "where", ";", "var", "sq_tail", "=", "this", ".", "tail", ";", "var", "sq_group", "=", "this", ".", "group", "?", "' GROUP BY '", "+", "this", ".", "group", ":", "''", ";", "var", "sq_order", "=", "this", ".", "order", "?", "' ORDER BY '", "+", "this", ".", "order", ":", "''", ";", "var", "sq_limit_offset", "=", "this", ".", "limit", ";", "var", "sq_close", "=", "'\\n}'", ";", "return", "''", "+", "sq_prefixes", "+", "sq_select", "+", "sq_where", "+", "sq_tail", "+", "sq_close", "+", "sq_group", "+", "sq_order", "+", "sq_limit_offset", ";", "}" ]

[ "converts", "query", "hash", "to", "sparql", "string" ]

[ "function", "(", "s_query", ",", "f_okay", ")", "{", "$", ".", "ajax", "(", "{", "url", ":", "s_endpoint_url", "+", "'query'", ",", "method", ":", "'GET'", ",", "data", ":", "{", "query", ":", "s_query", ",", "}", ",", "dataType", ":", "'json'", ",", "success", ":", "function", "(", "h_res", ")", "{", "f_okay", "&&", "f_okay", "(", "h_res", ")", ";", "}", ",", "}", ")", ";", "}" ]

[ "submits", "a", "query" ]

[ "function", "(", "h_subjects", ",", "b_raw", ")", "{", "// initiliaze output", "var", "s_out", "=", "''", ";", "// add slot for tail", "var", "s_tail", "=", "''", ";", "// newline + indent", "var", "_", "=", "'\\n\\t'", "+", "(", "b_raw", "?", "'\\t'", ":", "''", ")", ";", "// root nodes must be subjects", "for", "(", "var", "s_rs", "in", "h_subjects", ")", "{", "//", "var", "z_predicates", "=", "h_subjects", "[", "s_rs", "]", ";", "// declaring optional block", "if", "(", "s_rs", "==", "'?'", ")", "{", "// these are subjects actually", "var", "h_write", "=", "query_hash", "(", "z_predicates", ",", "true", ")", ";", "s_out", "+=", "_", "+", "'OPTIONAL {'", "+", "h_write", ".", "where", "+", "_", "+", "'}'", ";", "s_tail", "+=", "h_write", ".", "tail", ";", "}", "// regular query hash", "else", "{", "var", "s_rsi", "=", "rdf_var", "(", "s_rs", ")", ";", "// this is subject", "s_out", "+=", "_", "+", "s_rsi", ";", "// predicates are in hash", "if", "(", "typeof", "z_predicates", "==", "'object'", ")", "{", "// recurse", "var", "a_write", "=", "build_from_ph", "(", "z_predicates", ",", "_", ")", ";", "s_out", "+=", "a_write", "[", "0", "]", "+", "' .'", ";", "s_tail", "+=", "a_write", "[", "1", "]", ";", "}", "}", "}", "var", "h_raw", "=", "{", "treated_vars", ":", "{", "subs", ":", "{", "}", ",", "lists", ":", "{", "}", "}", ",", "select", ":", "''", ",", "where", ":", "s_out", ",", "tail", ":", "s_tail", ",", "group", ":", "''", ",", "order", ":", "''", ",", "limit", ":", "''", ",", "}", ";", "return", "(", "b_raw", "?", "h_raw", ":", "qb", "(", "h_raw", ")", ")", ";", "}" ]

[ "constructs", "sparql", "query", "string", "from", "hash" ]

[ "function", "(", "s_query", ")", "{", "// execute function", "var", "f_exec", "=", "function", "(", "f_okay", ")", "{", "submit_query", "(", "s_query", ",", "f_okay", ")", ";", "}", ";", "var", "d_self", "=", "{", "exec", ":", "f_exec", ",", "results", ":", "function", "(", "f_okay", ")", "{", "f_exec", "(", "function", "(", "h_res", ")", "{", "f_okay", "&&", "f_okay", "(", "h_res", ".", "results", ".", "bindings", ")", ";", "}", ")", ";", "}", ",", "each", ":", "function", "(", "f_each", ",", "f_okay", ")", "{", "f_exec", "(", "function", "(", "h_res", ")", "{", "if", "(", "!", "f_each", ")", "return", ";", "var", "a_rows", "=", "h_res", ".", "results", ".", "bindings", ";", "for", "(", "var", "i", "=", "0", ",", "l", "=", "a_rows", ".", "length", ";", "i", "<", "l", ";", "i", "++", ")", "{", "var", "h_row", "=", "a_rows", "[", "i", "]", ";", "var", "h_this", "=", "{", "}", ";", "for", "(", "var", "e", "in", "h_row", ")", "h_this", "[", "e", "]", "=", "h_row", "[", "e", "]", ".", "value", ";", "f_each", ".", "apply", "(", "h_this", ",", "[", "i", ",", "h_row", "]", ")", ";", "}", "f_okay", "&&", "f_okay", "(", ")", ";", "}", ")", ";", "}", ",", "}", ";", "return", "d_self", ";", "}" ]

[ "executes", "raw", "sparql", "query", "from", "string" ]

[ "function", "(", "channel", ")", "{", "return", "function", "(", ")", "{", "var", "args", "=", "Array", ".", "prototype", ".", "slice", ".", "call", "(", "arguments", ")", ";", "args", ".", "unshift", "(", "__class", "+", "':'", ")", ";", "console", "[", "channel", "]", ".", "apply", "(", "console", ",", "args", ")", ";", "}", ";", "}" ]

[ "output", "a", "message", "to", "the", "console", "prefixed", "with", "this", "class", "s", "tag" ]

[ "function", "into", "(", "impl", ")", "{", "/**\n * @param {string} selector\n * @param {Document|Element} [context]\n */", "return", "function", "(", "selector", ",", "context", ")", "{", "var", "callContext", "=", "this", ",", "extra", ";", "if", "(", "typeof", "selector", "===", "\"string\"", ")", "{", "if", "(", "context", "&&", "context", ".", "querySelector", ")", "{", "extra", "=", "Array", ".", "prototype", ".", "slice", ".", "call", "(", "arguments", ",", "2", ")", ";", "}", "else", "{", "extra", "=", "Array", ".", "prototype", ".", "slice", ".", "call", "(", "arguments", ",", "1", ")", ";", "context", "=", "document", ";", "}", "select", "(", "selector", ",", "context", ",", "function", "(", "elem", ")", "{", "impl", ".", "apply", "(", "callContext", ",", "[", "elem", "]", ".", "concat", "(", "extra", ")", ")", ";", "}", ")", ";", "}", "else", "{", "impl", ".", "apply", "(", "callContext", ",", "arguments", ")", ";", "}", "}", ";", "}" ]

[ "Create", "function", "composition", "which", "passes", "each", "selected", "element", "to", "a", "base", "function", "." ]

[ "function", "select", "(", "selector", ",", "context", ",", "fn", ")", "{", "var", "nodes", ";", "if", "(", "arguments", ".", "length", "===", "2", "&&", "typeof", "context", "===", "\"function\"", ")", "{", "fn", "=", "context", ";", "context", "=", "undefined", ";", "}", "nodes", "=", "(", "context", "||", "document", ")", ".", "querySelectorAll", "(", "selector", ")", ";", "nodes", "=", "Array", ".", "prototype", ".", "slice", ".", "call", "(", "nodes", ")", ";", "if", "(", "fn", ")", "nodes", ".", "forEach", "(", "fn", ")", ";", "else", "return", "nodes", ";", "}" ]

[ "Return", "selected", "elements", "or", "iterate", "and", "apply", "a", "function", "." ]

[ "function", "LooseInterval", "(", "fn", ",", "interval", ",", "callback", ")", "{", "if", "(", "!", "(", "this", "instanceof", "LooseInterval", ")", ")", "return", "new", "LooseInterval", "(", "fn", ",", "interval", ",", "callback", ")", "if", "(", "typeof", "fn", "!=", "\"function\"", ")", "throw", "new", "Error", "(", "\"LooseInterval requires a function\"", ")", "if", "(", "typeof", "interval", "==", "\"function\"", ")", "{", "callback", "=", "interval", "interval", "=", "null", "}", "this", ".", "fn", "=", "fn", "this", ".", "interval", "=", "interval", "this", ".", "callback", "=", "callback", "EventEmitter", ".", "call", "(", "this", ")", "this", ".", "_running", "=", "false", "if", "(", "interval", "!=", "null", ")", "this", ".", "start", "(", "interval", ")", "}" ]

[ "Create", "a", "loose", "-", "interval", "repeated", "task", ".", "Like", "setInterval", "but", "will", "reschedule", "when", "the", "task", "finishes", "to", "avoid", "overlapping", "tasks", ".", "Your", "function", "must", "provide", "a", "callback", "to", "alert", "its", "completion", "." ]

[ "function", "process", "(", ")", "{", "if", "(", "!", "conf", ".", "configured", ")", "that", ".", "configure", "(", ")", ";", "var", "args", "=", "command", ".", "args", ".", "slice", "(", "0", ")", ";", "for", "(", "var", "i", "in", "args", ")", "{", "var", "arg", "=", "args", "[", "i", "]", ";", "if", "(", "conf", ".", "regexp", ".", "test", "(", "arg", ")", ")", "{", "var", "catchWord", "=", "RegExp", ".", "$2", ";", "switch", "(", "RegExp", ".", "$1", ")", "{", "case", "'-'", ":", "processShortKey", "(", "catchWord", ",", "i", ",", "args", ")", ";", "break", ";", "case", "'--'", ":", "processKey", "(", "catchWord", ",", "i", ",", "args", ")", ";", "break", ";", "}", "}", "else", "{", "addArgument", "(", "arg", ")", ";", "}", "}", "conf", ".", "processed", "=", "true", "}" ]

[ "Fire", "the", "command", "line", "analyse" ]

[ "function", "getPlatforms", "(", "options", ")", "{", "return", "request", "(", "'GET'", ",", "'https://saucelabs.com/rest/v1/info/platforms/webdriver'", ")", ".", "getBody", "(", "'utf8'", ")", ".", "then", "(", "JSON", ".", "parse", ")", ".", "then", "(", "function", "(", "platforms", ")", "{", "var", "obj", "=", "{", "}", ";", "platforms", ".", "map", "(", "function", "(", "platform", ")", "{", "return", "{", "browserName", ":", "platform", ".", "api_name", ",", "version", ":", "platform", ".", "short_version", ",", "platform", ":", "platform", ".", "os", "}", ";", "}", ")", ".", "forEach", "(", "function", "(", "platform", ")", "{", "if", "(", "platform", ".", "browserName", "===", "'lynx'", ")", "return", ";", "if", "(", "!", "(", "options", ".", "filterPlatforms", "||", "defaultFilters", ".", "filterPlatforms", ")", "(", "platform", ",", "defaultFilters", ".", "filterPlatforms", ")", ")", "return", ";", "obj", "[", "platform", ".", "browserName", "]", "=", "obj", "[", "platform", ".", "browserName", "]", "||", "{", "}", ";", "obj", "[", "platform", ".", "browserName", "]", "[", "platform", ".", "version", "]", "=", "obj", "[", "platform", ".", "browserName", "]", "[", "platform", ".", "version", "]", "||", "[", "]", ";", "obj", "[", "platform", ".", "browserName", "]", "[", "platform", ".", "version", "]", ".", "push", "(", "platform", ")", ";", "}", ")", ";", "var", "result", "=", "{", "}", ";", "Object", ".", "keys", "(", "obj", ")", ".", "forEach", "(", "function", "(", "browser", ")", "{", "result", "[", "browser", "]", "=", "[", "]", ";", "Object", ".", "keys", "(", "obj", "[", "browser", "]", ")", ".", "sort", "(", "function", "(", "versionA", ",", "versionB", ")", "{", "if", "(", "isNaN", "(", "versionA", ")", "&&", "isNaN", "(", "versionB", ")", ")", "return", "versionA", "<", "versionB", "?", "-", "1", ":", "1", ";", "if", "(", "isNaN", "(", "versionA", ")", ")", "return", "-", "1", ";", "if", "(", "isNaN", "(", "versionB", ")", ")", "return", "1", ";", "return", "(", "+", "versionB", ")", "-", "(", "+", "versionA", ")", ";", "}", ")", ".", "forEach", "(", "function", "(", "version", ",", "index", ")", "{", "var", "platforms", "=", "obj", "[", "browser", "]", "[", "version", "]", ";", "result", "[", "browser", "]", "=", "result", "[", "browser", "]", ".", "concat", "(", "(", "options", ".", "choosePlatforms", "||", "defaultFilters", ".", "choosePlatforms", ")", "(", "platforms", ")", ")", ";", "}", ")", ";", "}", ")", ";", "return", "result", ";", "}", ")", ";", "}" ]

[ "Get", "an", "object", "containing", "the", "platforms", "supported", "by", "sauce", "labs" ]

[ "function", "Blob", "(", "source", ",", "parent", ",", "githubClient", ")", "{", "this", ".", "gh", "=", "githubClient", ";", "this", ".", "parent", "=", "parent", ";", "this", ".", "sha", "=", "source", ".", "sha", ";", "this", ".", "rawContent", "=", "source", ".", "content", ";", "this", ".", "size", "=", "source", ".", "size", ";", "this", ".", "contents", "=", "new", "Buffer", "(", "this", ".", "rawContent", ",", "'base64'", ")", ".", "toString", "(", "'utf-8'", ")", ";", "}" ]

[ "A", "git", "blob", "object", "." ]

[ "function", "pJson", "(", "events", ",", "top", "=", "''", ")", "{", "Object", ".", "keys", "(", "events", ")", ".", "forEach", "(", "(", "i", ")", "=>", "{", "if", "(", "typeof", "events", "[", "i", "]", "===", "'object'", "&&", "events", "[", "i", "]", "!=", "null", ")", "{", "let", "rtn", ";", "if", "(", "Object", ".", "prototype", ".", "toString", ".", "call", "(", "events", ")", "===", "'[object Array]'", ")", "{", "rtn", "=", "(", "`", "${", "top", "}", "${", "i", "}", "`", ")", ";", "}", "else", "{", "rtn", "=", "(", "`", "${", "top", "}", "${", "i", "}", "`", ")", ";", "}", "pJson", "(", "events", "[", "i", "]", ",", "rtn", ")", ";", "}", "else", "if", "(", "Object", ".", "prototype", ".", "toString", ".", "call", "(", "events", ")", "===", "'[object Array]'", ")", "{", "tmp", "+=", "`", "${", "top", "}", "${", "i", "}", "${", "events", "[", "i", "]", "}", "\\n", "`", ";", "}", "else", "{", "tmp", "+=", "`", "${", "top", "}", "${", "i", "}", "${", "events", "[", "i", "]", "}", "\\n", "`", ";", "}", "}", ")", ";", "}" ]

[ "json", "needs", "to", "arrive", "stringified" ]

[ "function", "jPretty", "(", "obj", ")", "{", "// make sure data is a json obj", "if", "(", "typeof", "obj", "===", "\"string\"", ")", "{", "obj", "=", "obj", ".", "replace", "(", "/", "\\s", "/", "g", ",", "\"\"", ")", ";", "obj", "=", "obj", ".", "replace", "(", "/", "'", "/", "g", ",", "'\"'", ")", ";", "}", "let", "gl", ";", "try", "{", "const", "p", "=", "JSON", ".", "parse", "(", "obj", ")", ";", "gl", "=", "obj", ";", "// already stringified", "}", "catch", "(", "e", ")", "{", "// not stringified", "if", "(", "typeof", "obj", "===", "\"string\"", ")", "{", "obj", "=", "obj", ".", "replace", "(", "/", "([,|{|\\s|])([a-zA-Z0-9]*?)([\\s|]*\\:)", "/", "g", ",", "'$1\"$2\"$3'", ")", ";", "}", "const", "s", "=", "JSON", ".", "stringify", "(", "obj", ")", ";", "const", "k", "=", "JSON", ".", "parse", "(", "JSON", ".", "stringify", "(", "obj", ")", ")", ";", "if", "(", "k", "&&", "typeof", "k", "===", "'object'", ")", "{", "gl", "=", "s", ";", "}", "else", "{", "if", "(", "typeof", "obj", "===", "\"string\"", ")", "{", "//console.log(\"ERROR: \" + );", "obj", "=", "obj", ".", "replace", "(", "/", "\"", "/", "g", ",", "\"'\"", ")", ";", "obj", "=", "obj", ".", "replace", "(", "/", "'", "/", "g", ",", "'\"'", ")", ";", "gl", "=", "(", "(", "obj", ")", ")", ";", "}", "else", "{", "return", "new", "Error", "(", "`", "${", "typeof", "obj", "}", "${", "JSON", ".", "stringify", "(", "obj", ")", "}", "`", ")", ";", "}", "}", "}", "return", "(", "(", ")", "=>", "{", "let", "jp", "=", "prettyJson", "(", "gl", ")", ";", "if", "(", "typeof", "window", "!==", "'undefined'", ")", "{", "console", ".", "log", "(", "\"jPretty loaded in browser\"", ")", ";", "jp", "=", "jp", ".", "replace", "(", "/", "\\{\\}", "/", "g", ",", "\"<br/>{}\"", ")", ";", "}", "return", "jp", ";", "}", ")", "(", ")", "}" ]

[ "Tidies", "up", "the", "json", "into", "a", "correct", "javascript", "object", "notation", "." ]

[ "function", "Client", "(", "options", ")", "{", "options", "=", "options", "||", "{", "}", ";", "this", ".", "_key", "=", "options", ".", "key", "||", "null", ";", "this", ".", "_secret", "=", "options", ".", "secret", "||", "null", ";", "this", ".", "_proxy", "=", "options", ".", "proxy", "||", "null", ";", "return", "this", ";", "}" ]

[ "An", "API", "client", ".", "All", "the", "module", "functions", "can", "be", "accessed", "using", "a", "client" ]

[ "async", "function", "parallel", "(", "resolvers", ",", "limit", "=", "-", "1", ")", "{", "// set default limit", "if", "(", "limit", "<", "1", ")", "{", "limit", "=", "1000", ";", "}", "// buffer", "const", "results", "=", "[", "]", ";", "// calculate chunk size", "// limit step size to input array size", "const", "chunkSize", "=", "Math", ".", "min", "(", "limit", ",", "resolvers", ".", "length", ")", ";", "// process resolvers in chunks", "for", "(", "let", "i", "=", "0", ";", "i", "<", "resolvers", ".", "length", ";", "i", "=", "i", "+", "chunkSize", ")", "{", "// extract current chunk", "const", "chunk", "=", "resolvers", ".", "slice", "(", "i", ",", "Math", ".", "min", "(", "i", "+", "chunkSize", ",", "resolvers", ".", "length", ")", ")", ";", "// resolve current chunk", "const", "intermediateResults", "=", "await", "Promise", ".", "all", "(", "chunk", ".", "map", "(", "(", "r", ")", "=>", "r", ".", "resolve", "(", ")", ")", ")", ";", "// push results into buffer", "results", ".", "push", "(", "...", "intermediateResults", ")", ";", "}", "// return results", "return", "results", ";", "}" ]

[ "resolves", "multiple", "promises", "in", "parallel" ]

[ "function", "(", "error", ",", "newIndex", ")", "{", "if", "(", "error", ")", "{", "console", ".", "log", "(", "'Data error for '", "+", "dataurl", "+", "'\\n'", "+", "error", ")", "}", "if", "(", "!", "error", ")", "{", "index", "=", "newIndex", "var", "timeStart", "=", "Date", ".", "now", "(", ")", "request", "(", "dataurl", ")", ".", "pipe", "(", "JSONStream", ".", "parse", "(", ")", ")", ".", "pipe", "(", "index", ".", "defaultPipeline", "(", ")", ")", ".", "pipe", "(", "index", ".", "add", "(", ")", ")", ".", "on", "(", "'data'", ",", "function", "(", "data", ")", "{", "//console.dir(data) // What's going on in the indexing process", "}", ")", ".", "on", "(", "'end'", ",", "(", ")", "=>", "{", "var", "timeEnd", "=", "Date", ".", "now", "(", ")", "var", "timeUsed", "=", "Math", ".", "trunc", "(", "(", "timeEnd", "-", "timeStart", ")", "/", "1000", ")", "console", ".", "log", "(", "'Indexed in '", "+", "timeUsed", "+", "' seconds'", ")", "}", ")", "}", "}" ]

[ "indexData", "const", "with", "pipeline", "pipeline" ]

[ "function", "(", "str", ",", "len", ",", "padChar", ")", "{", "str", "=", "stringIt", "(", "str", ")", ";", "if", "(", "str", ".", "length", ">=", "len", ")", "{", "return", "str", ";", "}", "var", "padStr", "=", "getPadding", "(", "padChar", ",", "len", ")", ";", "return", "str", "+", "padStr", ".", "substr", "(", "str", ".", "length", "-", "len", ")", ";", "}" ]

[ "Pad", "string", "on", "right" ]

[ "function", "(", "str", ",", "start", ")", "{", "return", "(", "str", ".", "length", ">=", "start", ".", "length", "&&", "str", ".", "substr", "(", "0", ",", "start", ".", "length", ")", "===", "start", ")", ";", "}" ]

[ "True", "if", "string", "starts", "with", "prefix" ]

[ "function", "(", "str", ",", "end", ")", "{", "return", "(", "str", ".", "length", ">=", "end", ".", "length", "&&", "str", ".", "substring", "(", "str", ".", "length", "-", "end", ".", "length", ")", "===", "end", ")", ";", "}" ]

[ "True", "if", "string", "ends", "with", "suffix" ]

[ "function", "set", "(", "key", ",", "module", ",", "global", ")", "{", "var", "m", "=", "null", ";", "var", "isGlobal", "=", "global", "&&", "typeof", "global", "!==", "'undefined'", ";", "// check to make sure the module has been assigned only once", "if", "(", "isGlobal", ")", "{", "if", "(", "global", ".", "hasOwnProperty", "(", "key", ")", ")", "{", "throw", "'[define-shim] Module '", "+", "key", "+", "' already exists'", ";", "}", "}", "else", "if", "(", "_map", ".", "hasOwnProperty", "(", "key", ")", ")", "{", "throw", "'[define-shim] Module '", "+", "key", "+", "' already exists'", ";", "return", ";", "}", "// construct the module if needed", "if", "(", "typeof", "module", "===", "'function'", ")", "m", "=", "module", "(", "get", ")", ";", "else", "m", "=", "module", ";", "// assign the module to whichever object is preferred", "if", "(", "isGlobal", ")", "global", "[", "key", "]", "=", "m", ";", "else", "_map", "[", "key", "]", "=", "m", ";", "}" ]

[ "global", "is", "an", "optional", "object", "and", "will", "attach", "the", "constructed", "module", "to", "it", "if", "present" ]

[ "function", "insert", "(", "i", ",", "val", ",", "array", ")", "{", "array", "=", "copy", "(", "array", ")", "array", ".", "splice", "(", "i", ",", "0", ",", "val", ")", "return", "array", "}" ]

[ "Returns", "a", "new", "array", "with", "the", "supplied", "element", "inserted", "at", "index", "i", "." ]

[ "function", "generateFakeDataForSchema", "(", "schemaName", ")", "{", "return", "new", "RSVP", ".", "Promise", "(", "function", "(", "resolve", ",", "reject", ")", "{", "agolSchemas", ".", "getSchema", "(", "schemaName", ")", ".", "then", "(", "function", "(", "schema", ")", "{", "// Generate fake data", "var", "fakeData", "=", "jsf", "(", "schema", ")", ";", "// return fake data", "resolve", "(", "fakeData", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Generate", "fake", "data", "for", "a", "certain", "schema" ]

[ "function", "FullyTyped", "(", "configuration", ")", "{", "if", "(", "arguments", ".", "length", "===", "0", "||", "configuration", "===", "null", ")", "configuration", "=", "{", "}", ";", "// validate input parameter", "if", "(", "!", "util", ".", "isPlainObject", "(", "configuration", ")", ")", "{", "throw", "Error", "(", "'If provided, the schema configuration must be a plain object. Received: '", "+", "configuration", ")", ";", "}", "// get a copy of the configuration", "const", "config", "=", "util", ".", "copy", "(", "configuration", ")", ";", "// if type is not specified then use the default", "if", "(", "!", "config", ".", "type", ")", "config", ".", "type", "=", "'typed'", ";", "// get the controller data", "const", "data", "=", "FullyTyped", ".", "controllers", ".", "get", "(", "config", ".", "type", ")", ";", "// type is invalid", "if", "(", "!", "data", ")", "throw", "Error", "(", "'Unknown type: '", "+", "config", ".", "type", ")", ";", "// return a schema object", "return", "new", "Schema", "(", "config", ",", "data", ")", ";", "}" ]

[ "Validate", "a", "value", "against", "the", "schema", "and", "throw", "an", "error", "if", "encountered", "." ]

[ "function", "validate", "(", "task", ",", "options", ")", "{", "if", "(", "!", "task", ")", "{", "if", "(", "options", ".", "verbose", ")", "{", "console", ".", "log", "(", "' -'", ",", "chalk", ".", "bold", ".", "yellow", "(", "'[WARNING]:'", ")", ",", "'Task does not exist'", ")", ";", "}", "return", "Promise", ".", "resolve", "(", "false", ")", ";", "}", "return", "new", "Promise", "(", "function", "(", "resolve", ",", "reject", ")", "{", "var", "hooks", "=", "task", ".", "hooks", "(", "options", ")", "||", "{", "}", ";", "if", "(", "hooks", ".", "validate", ")", "{", "var", "result", "=", "hooks", ".", "validate", "(", ")", ";", "if", "(", "isPromise", "(", "result", ")", ")", "{", "result", ".", "then", "(", "function", "(", "result", ")", "{", "resolve", "(", "result", "!==", "false", ")", ";", "// undefined should represent truthy", "}", ")", ";", "}", "else", "{", "resolve", "(", "result", ")", ";", "}", "}", "else", "{", "resolve", "(", "true", ")", ";", "}", "}", ")", ";", "}" ]

[ "Hook", "executed", "before", "task", "is", "run", "." ]

[ "function", "log", "(", "out", ",", "desc", ")", "{", "logger", ".", "log", "(", "header", "(", ")", ")", "if", "(", "desc", ")", "{", "logger", ".", "log", "(", "desc", ")", "}", "logger", ".", "log", "(", "out", ")", "logger", ".", "log", "(", ")", "}" ]

[ "function", "to", "substitute", "console", ".", "log" ]

[ "function", "error", "(", "out", ",", "desc", ")", "{", "logger", ".", "error", "(", "header", "(", ")", ")", "if", "(", "desc", ")", "{", "logger", ".", "error", "(", "desc", ")", "}", "logger", ".", "error", "(", "out", ")", "logger", ".", "error", "(", ")", "}" ]

[ "function", "to", "substitute", "console", ".", "error" ]

[ "function", "watch", "(", "glob", ",", "taskName", ")", "{", "var", "watcher", "=", "chokidar", ".", "watch", "(", "glob", ",", "{", "persistent", ":", "true", ",", "}", ")", ";", "watcher", ".", "on", "(", "'ready'", ",", "(", ")", "=>", "{", "watcher", ".", "on", "(", "'all'", ",", "(", "event", ",", "path", ")", "=>", "{", "invokeTask", "(", "taskName", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Watch", "files", "and", "then", "invoke", "a", "task" ]

[ "function", "invokeTask", "(", "taskName", ")", "{", "const", "tc", "=", "TASKS", ".", "globals", ".", "globalTaskCollection", ";", "const", "t", "=", "tc", ".", "getByName", "(", "taskName", ")", ";", "if", "(", "t", "===", "undefined", ")", "{", "YERROR", ".", "raiseError", "(", "`", "${", "taskName", "}", "`", ")", ";", "}", "TASKS", ".", "invokeTask", "(", "tc", ",", "t", ")", ";", "}" ]

[ "Invoke", "a", "task", "by", "name" ]

[ "function", "create", "(", ")", "{", "var", "sha1sum", "=", "crypto", ".", "createHash", "(", "'sha1'", ")", ";", "return", "{", "update", ":", "update", ",", "digest", ":", "digest", "}", ";", "function", "update", "(", "data", ")", "{", "sha1sum", ".", "update", "(", "data", ")", ";", "}", "function", "digest", "(", ")", "{", "return", "sha1sum", ".", "digest", "(", "'hex'", ")", ";", "}", "}" ]

[ "A", "streaming", "interface", "for", "when", "nothing", "is", "passed", "in", "." ]

[ "function", "(", "obj", ",", "maxNumProperties", ")", "{", "var", "result", "=", "\"\"", ";", "maxNumProperties", "=", "maxNumProperties", "===", "undefined", "?", "Number", ".", "MAX_VALUE", ":", "maxNumProperties", ";", "if", "(", "obj", "!==", "undefined", "&&", "obj", "!==", "null", ")", "{", "var", "separator", "=", "\"\"", ";", "var", "propCount", "=", "0", ";", "for", "(", "var", "propertyName", "in", "obj", ")", "{", "var", "objValue", ";", "if", "(", "(", "obj", "[", "propertyName", "]", ")", "===", "undefined", ")", "{", "objValue", "=", "\"*** undefined ***\"", ";", "}", "else", "{", "objValue", "=", "obj", "[", "propertyName", "]", ";", "}", "result", "+=", "separator", "+", "propertyName", "+", "\" = \"", "+", "objValue", ";", "separator", "=", "\",\\n\"", ";", "propCount", "++", ";", "if", "(", "propCount", ">=", "maxNumProperties", ")", "{", "break", ";", "}", "}", "}", "return", "result", ";", "}" ]

[ "Return", "a", "String", "of", "the", "form", "propertyName", "=", "propertyValue", "\\", "n", "for", "every", "property", "of", "the", "given", "obj", "or", "until", "maxNumProperties", "has", "been", "reached", "." ]

[ "function", "(", "argumentName", ",", "defaultValue", ")", "{", "var", "result", "=", "argMap", "[", "argumentName", "]", ";", "if", "(", "this", ".", "isEmpty", "(", "result", ")", "&&", "this", ".", "isNotEmpty", "(", "defaultValue", ")", ")", "{", "if", "(", "typeof", "defaultValue", "===", "'object'", ")", "{", "result", "=", "defaultValue", "[", "argumentName", "]", ";", "}", "else", "{", "result", "=", "defaultValue", ";", "}", "}", "return", "result", ";", "}" ]

[ "Return", "the", "commandline", "argument", "specified", "by", "argumentName", ".", "If", "not", "found", "then", "return", "the", "specified", "defaultValue", "." ]

[ "function", "bundle", "(", ")", "{", "return", "bundler", ".", "bundle", "(", ")", "// log errors if they happen", ".", "on", "(", "'error'", ",", "gutil", ".", "log", ".", "bind", "(", "gutil", ",", "'Browserify Error'", ")", ")", ".", "pipe", "(", "source", "(", "'nutella_lib.js'", ")", ")", ".", "pipe", "(", "gulp", ".", "dest", "(", "'./dist'", ")", ")", ";", "}" ]

[ "output", "build", "logs", "to", "terminal" ]

[ "function", "JFP_Error", "(", "message", ")", "{", "Error", ".", "call", "(", "this", ",", "message", ")", ";", "Object", ".", "defineProperty", "(", "this", ",", "\"name\"", ",", "{", "value", ":", "this", ".", "constructor", ".", "name", "}", ")", ";", "Object", ".", "defineProperty", "(", "this", ",", "\"message\"", ",", "{", "value", ":", "message", "}", ")", ";", "if", "(", "Error", ".", "captureStackTrace", ")", "{", "Error", ".", "captureStackTrace", "(", "this", ",", "this", ".", "constructor", ")", ";", "}", "else", "{", "Object", ".", "defineProperty", "(", "this", ",", "\"stack\"", ",", "{", "value", ":", "(", "new", "Error", "(", ")", ")", ".", "stack", "}", ")", ";", "}", "}" ]

[ "JFP_Error", "-", "base", "error", "class" ]

[ "function", "type", "(", "input", ")", "{", "//If the input value is null, undefined or NaN the toStringTypes object shouldn't be used", "if", "(", "input", "===", "null", "||", "input", "===", "undefined", "||", "(", "input", "!==", "input", "&&", "String", "(", "input", ")", "===", "\"NaN\"", ")", ")", "{", "return", "String", "(", "input", ")", ";", "}", "// use the typeMap to detect the type and fallback to object if the type wasn't found", "return", "typeMap", "[", "Object", ".", "prototype", ".", "toString", ".", "call", "(", "input", ")", "]", "||", "\"object\"", ";", "}" ]

[ "detect", "type", "using", "typeMap" ]

[ "function", "inherits", "(", "constructor", ",", "superConstructor", ")", "{", "constructor", ".", "super_", "=", "superConstructor", ";", "constructor", ".", "prototype", "=", "Object", ".", "create", "(", "superConstructor", ".", "prototype", ",", "{", "'constructor'", ":", "{", "'value'", ":", "constructor", ",", "'enumerable'", ":", "false", ",", "'writable'", ":", "true", ",", "'configurable'", ":", "true", "}", "}", ")", ";", "}" ]

[ "Inherit", "the", "prototype", "methods", "from", "one", "constructor", "into", "another" ]

[ "function", "Confectioner", "(", ")", "{", "if", "(", "!", "(", "this", "instanceof", "Confectioner", ")", ")", "{", "var", "instance", "=", "Object", ".", "create", "(", "clazz", ")", ";", "Confectioner", ".", "apply", "(", "instance", ",", "arguments", ")", ";", "return", "instance", ";", "}", "this", ".", "keys", "=", "[", "]", ";", "this", ".", "addKey", ".", "apply", "(", "this", ",", "Array", ".", "prototype", ".", "slice", ".", "call", "(", "arguments", ")", ")", ";", "}" ]

[ "Initialize", "a", "new", "Confectioner", "." ]

[ "function", "floatFromBuffer", "(", "buf", ")", "{", "if", "(", "buf", ".", "length", "<", "FLOAT_ENTROPY_BYTES", ")", "{", "throw", "new", "Error", "(", "'buffer must contain at least '", "+", "FLOAT_ENTROPY_BYTES", "+", "' bytes of entropy'", ")", "}", "var", "position", "=", "0", "// http://stackoverflow.com/questions/15753019/floating-point-number-from-crypto-randombytes-in-javascript", "return", "(", "(", "(", "(", "(", "(", "(", "buf", "[", "position", "++", "]", "%", "32", ")", "/", "32", "+", "buf", "[", "position", "++", "]", ")", "/", "256", "+", "buf", "[", "position", "++", "]", ")", "/", "256", "+", "buf", "[", "position", "++", "]", ")", "/", "256", "+", "buf", "[", "position", "++", "]", ")", "/", "256", "+", "buf", "[", "position", "++", "]", ")", "/", "256", "+", "buf", "[", "position", "]", ")", "/", "256", "}" ]

[ "Given", "a", "buffer", "containing", "bytes", "of", "entropy", "generate", "a", "double", "-", "precision", "64", "-", "bit", "float", "." ]

[ "function", "applyNSync", "(", ")", "{", "var", "args", "=", "Array", ".", "prototype", ".", "slice", ".", "call", "(", "arguments", ")", "var", "fn", "=", "args", ".", "shift", "(", ")", "var", "num", "=", "args", ".", "shift", "(", ")", "var", "arr", "=", "[", "]", "for", "(", "var", "i", "=", "0", ";", "i", "<", "num", ";", "++", "i", ")", "{", "arr", ".", "push", "(", "fn", ".", "apply", "(", "null", ",", "args", ")", ")", "}", "return", "arr", "}" ]

[ "Apply", "a", "function", "a", "number", "of", "times", "returning", "an", "array", "of", "the", "results", "." ]

[ "function", "applyN", "(", "fn", ",", "opts", ",", "ready", ")", "{", "var", "num", "=", "opts", ".", "num", "||", "0", "var", "unique", "=", "opts", ".", "unique", "var", "arr", "=", "[", "]", "fn", "(", "opts", ",", "onValue", ")", "function", "onValue", "(", "err", ",", "value", ")", "{", "if", "(", "err", ")", "{", "return", "ready", "(", "err", ")", "}", "if", "(", "!", "unique", "||", "arr", ".", "indexOf", "(", "value", ")", "===", "-", "1", ")", "{", "arr", ".", "push", "(", "value", ")", "}", "if", "(", "arr", ".", "length", ">=", "num", ")", "{", "return", "ready", "(", "null", ",", "arr", ")", "}", "process", ".", "nextTick", "(", "function", "(", ")", "{", "fn", "(", "opts", ",", "onValue", ")", "}", ")", "}", "}" ]

[ "Creates", "an", "array", "of", "items", "whose", "contents", "are", "the", "result", "of", "calling", "asynchronous", "function", "fn", "once", "for", "each", "item", "in", "the", "array", ".", "The", "function", "is", "called", "in", "series", "until", "the", "array", "is", "filled", "." ]

[ "function", "restifyCORSSimple", "(", "req", ",", "res", ",", "next", ")", "{", "var", "origin", ";", "if", "(", "!", "(", "origin", "=", "matchOrigin", "(", "req", ",", "origins", ")", ")", ")", "{", "next", "(", ")", ";", "return", ";", "}", "function", "corsOnHeader", "(", ")", "{", "origin", "=", "req", ".", "headers", ".", "origin", ";", "if", "(", "opts", ".", "credentials", ")", "{", "res", ".", "setHeader", "(", "AC_ALLOW_CREDS", ",", "'true'", ")", ";", "}", "res", ".", "setHeader", "(", "AC_ALLOW_ORIGIN", ",", "origin", ")", ";", "res", ".", "setHeader", "(", "AC_EXPOSE_HEADERS", ",", "headers", ".", "join", "(", "', '", ")", ")", ";", "res", ".", "setHeader", "(", "AC_ALLOW_METHODS", ",", "ALLOW_METHODS", ".", "join", "(", "', '", ")", ")", ";", "res", ".", "setHeader", "(", "AC_ALLOW_HEADERS", ",", "ALLOW_HEADERS", ".", "join", "(", "', '", ")", ")", ";", "res", ".", "setHeader", "(", "AC_REQUEST_HEADERS", ",", "REQUEST_HEADERS", ".", "join", "(", "', '", ")", ")", ";", "}", "res", ".", "once", "(", "'header'", ",", "corsOnHeader", ")", ";", "next", "(", ")", ";", "}" ]

[ "Handler", "for", "simple", "requests" ]

[ "function", "processErrorAndData", "(", "error", ",", "data", ")", "{", "if", "(", "_cb", ".", "beforeReturnErrorAndData", ")", "{", "_cb", ".", "beforeReturnErrorAndData", "(", "error", ",", "data", ")", ";", "}", "if", "(", "_cb", ".", "returnErrorAndData", ")", "{", "_cb", ".", "returnErrorAndData", "(", "error", ",", "data", ",", "response", ")", ";", "}", "if", "(", "_cb", ".", "afterReturnErrorAndData", ")", "{", "_cb", ".", "afterReturnErrorAndData", "(", "error", ",", "data", ")", ";", "}", "}" ]

[ "Call", "provided", "callback", "for", "error", "and", "data", "case", "." ]

[ "function", "processError", "(", "error", ")", "{", "if", "(", "_cb", ".", "beforeReturnError", ")", "{", "_cb", ".", "beforeReturnError", "(", "error", ")", ";", "}", "if", "(", "_cb", ".", "returnError", ")", "{", "_cb", ".", "returnError", "(", "error", ",", "response", ")", ";", "}", "if", "(", "_cb", ".", "afterReturnError", ")", "{", "_cb", ".", "afterReturnError", "(", "error", ")", ";", "}", "}" ]

[ "Call", "provided", "callback", "for", "error", "case", "." ]

[ "function", "processData", "(", "data", ")", "{", "if", "(", "_cb", ".", "beforeReturnData", ")", "{", "_cb", ".", "beforeReturnData", "(", "data", ")", ";", "}", "if", "(", "_cb", ".", "returnData", ")", "{", "_cb", ".", "returnData", "(", "data", ",", "response", ")", ";", "}", "if", "(", "_cb", ".", "afterReturnData", ")", "{", "_cb", ".", "afterReturnData", "(", "data", ")", ";", "}", "}" ]

[ "Call", "provided", "callback", "for", "data", "case", "." ]

[ "function", "processNotFound", "(", ")", "{", "if", "(", "_cb", ".", "beforeReturnNotFound", ")", "{", "_cb", ".", "beforeReturnNotFound", "(", ")", ";", "}", "if", "(", "_cb", ".", "returnNotFound", ")", "{", "_cb", ".", "returnNotFound", "(", "response", ")", ";", "}", "if", "(", "_cb", ".", "afterReturnNotFound", ")", "{", "_cb", ".", "afterReturnNotFound", "(", ")", ";", "}", "}" ]

[ "Call", "provided", "callback", "for", "not", "found", "data", "case", "." ]

[ "function", "(", "token", ")", "{", "this", ".", "oauthClient", ".", "setCredentials", "(", "token", ")", ";", "this", ".", "brain", ".", "set", "(", "this", ".", "TOKEN_KEY", ",", "token", ".", "access_token", ")", ";", "if", "(", "token", ".", "refresh_token", ")", "{", "this", ".", "brain", ".", "set", "(", "this", ".", "REFRESH_KEY", ",", "token", ".", "refresh_token", ")", ";", "}", "this", ".", "brain", ".", "set", "(", "this", ".", "EXPIRY_KEY", ",", "+", "token", ".", "expiry_date", ")", ";", "this", ".", "brain", ".", "save", "(", ")", ";", "this", ".", "brain", ".", "resetSaveInterval", "(", "60", ")", ";", "}" ]

[ "Stores", "the", "token", "and", "expire", "time", "into", "the", "robot", "brain", "and", "Sets", "it", "in", "the", "oauthClient" ]

[ "function", "(", "code", ",", "cb", ")", "{", "var", "self", "=", "this", ";", "this", ".", "oauthClient", ".", "getToken", "(", "code", ",", "function", "(", "err", ",", "token", ")", "{", "if", "(", "err", ")", "{", "cb", "(", "{", "err", ":", "err", ",", "msg", ":", "'Error while trying to retrieve access token'", "}", ")", ";", "return", ";", "}", "self", ".", "storeToken", "(", "token", ")", ";", "cb", "(", "null", ",", "{", "resp", ":", "token", ",", "msg", ":", "\"Google auth code successfully set\"", "}", ")", ";", "}", ")", ";", "}" ]

[ "Used", "to", "set", "the", "code", "provided", "by", "the", "generated", "auth", "url", ".", "This", "code", "is", "generated", "for", "a", "user", "and", "is", "needed", "to", "initiate", "the", "oauth2", "handshake" ]

[ "function", "(", "cb", ")", "{", "var", "at", "=", "this", ".", "brain", ".", "get", "(", "this", ".", "TOKEN_KEY", ")", ",", "rt", "=", "this", ".", "brain", ".", "get", "(", "this", ".", "REFRESH_KEY", ")", ";", "if", "(", "at", "==", "null", "||", "rt", "==", "null", ")", "{", "cb", "(", "{", "err", ":", "null", ",", "msg", ":", "'Error: No tokens found. Please authorize this app and store a refresh token'", "}", ")", ";", "return", ";", "}", "var", "expirTime", "=", "this", ".", "brain", ".", "get", "(", "this", ".", "EXPIRY_KEY", ")", ",", "curTime", "=", "(", "new", "Date", "(", ")", ")", "/", "1", ";", "var", "self", "=", "this", ";", "if", "(", "expirTime", "<", "curTime", ")", "{", "this", ".", "oauthClient", ".", "refreshAccessToken", "(", "function", "(", "err", ",", "token", ")", "{", "if", "(", "err", "!=", "null", ")", "{", "cb", "(", "{", "err", ":", "err", ",", "msg", ":", "'Google Authentication Error: error refreshing token'", "}", ",", "null", ")", ";", "return", ";", "}", "self", ".", "storeToken", "(", "token", ")", ";", "cb", "(", "null", ",", "{", "resp", ":", "token", ",", "msg", ":", "'Token refreshed'", "}", ")", ";", "}", ")", ";", "}", "else", "{", "cb", "(", "null", ")", ";", "}", "}" ]

[ "Checks", "the", "current", "expire", "time", "and", "determines", "if", "the", "token", "is", "valid", ".", "Refreshes", "the", "token", "if", "it", "is", "not", "valid", "." ]

[ "function", "(", ")", "{", "return", "{", "token", ":", "this", ".", "brain", ".", "get", "(", "this", ".", "TOKEN_KEY", ")", ",", "refresh_token", ":", "this", ".", "brain", ".", "get", "(", "this", ".", "REFRESH_KEY", ")", ",", "expire_date", ":", "this", ".", "brain", ".", "get", "(", "this", ".", "EXPIRY_KEY", ")", "}", "}" ]

[ "Returns", "the", "current", "set", "of", "tokens" ]

[ "function", "findValueByPath", "(", "jsonData", ",", "path", ")", "{", "var", "errorParts", "=", "false", ";", "path", ".", "split", "(", "'.'", ")", ".", "forEach", "(", "function", "(", "part", ")", "{", "if", "(", "!", "errorParts", ")", "{", "jsonData", "=", "jsonData", "[", "part", "]", ";", "if", "(", "!", "jsonData", ")", "errorParts", "=", "true", ";", "}", "}", ")", ";", "return", "errorParts", "?", "0", ":", "parseFloat", "(", "jsonData", ")", ";", "}" ]

[ "FIND", "VALUE", "BY", "PATH" ]

[ "function", "requestPrice", "(", "urlAPI", ",", "callback", ")", "{", "request", "(", "{", "method", ":", "'GET'", ",", "url", ":", "urlAPI", ",", "timeout", ":", "TIMEOUT", ",", "maxRedirects", ":", "2", "}", ",", "function", "(", "error", ",", "res", ",", "body", ")", "{", "if", "(", "!", "error", ")", "{", "try", "{", "var", "current", "=", "JSON", ".", "parse", "(", "body", ")", ";", "callback", "(", "current", ")", ";", "}", "catch", "(", "e", ")", "{", "}", "}", "if", "(", "!", "current", ")", "{", "callback", "(", "{", "}", ")", ";", "}", "}", ")", ";", "}" ]

[ "GET", "PRICE", "FROM", "API", "SERVICE" ]

[ "function", "(", "buildPath", ",", "manifest", ")", "{", "fs", ".", "stat", "(", "manifest", ",", "function", "(", "err", ",", "stat", ")", "{", "if", "(", "!", "err", ")", "{", "manifest", "=", "JSON", ".", "parse", "(", "fs", ".", "readFileSync", "(", "manifest", ")", ")", ";", "for", "(", "var", "key", "in", "manifest", ")", "{", "del", ".", "sync", "(", "buildPath", "+", "'/'", "+", "manifest", "[", "key", "]", ",", "{", "force", ":", "true", "}", ")", ";", "}", "}", "}", ")", ";", "}" ]

[ "Empty", "all", "relevant", "files", "from", "the", "build", "directory", "." ]

[ "function", "(", ")", "{", "var", "children", "=", "this", ".", "parent", ".", "children", ",", "index", "=", "CKEDITOR", ".", "tools", ".", "indexOf", "(", "children", ",", "this", ")", ",", "previous", "=", "this", ".", "previous", ",", "next", "=", "this", ".", "next", ";", "previous", "&&", "(", "previous", ".", "next", "=", "next", ")", ";", "next", "&&", "(", "next", ".", "previous", "=", "previous", ")", ";", "children", ".", "splice", "(", "index", ",", "1", ")", ";", "this", ".", "parent", "=", "null", ";", "}" ]

[ "Remove", "this", "node", "from", "a", "tree", "." ]

[ "function", "(", "condition", ")", "{", "var", "checkFn", "=", "typeof", "condition", "==", "'function'", "?", "condition", ":", "typeof", "condition", "==", "'string'", "?", "function", "(", "el", ")", "{", "return", "el", ".", "name", "==", "condition", ";", "}", ":", "function", "(", "el", ")", "{", "return", "el", ".", "name", "in", "condition", ";", "}", ";", "var", "parent", "=", "this", ".", "parent", ";", "// Parent has to be an element - don't check doc fragment.", "while", "(", "parent", "&&", "parent", ".", "type", "==", "CKEDITOR", ".", "NODE_ELEMENT", ")", "{", "if", "(", "checkFn", "(", "parent", ")", ")", "return", "parent", ";", "parent", "=", "parent", ".", "parent", ";", "}", "return", "null", ";", "}" ]

[ "Gets", "the", "closest", "ancestor", "element", "of", "this", "element", "which", "satisfies", "given", "condition" ]

[ "function", "(", "d", ")", "{", "var", "self", "=", "this", ";", "$", "(", "'#circle-info'", ")", ".", "html", "(", "d", ".", "name", ")", ";", "console", ".", "log", "(", "d", ")", ";", "var", "focus0", "=", "self", ".", "focus", ";", "self", ".", "focus", "=", "d", ";", "var", "transition", "=", "d3", ".", "transition", "(", ")", ".", "duration", "(", "d3", ".", "event", ".", "altKey", "?", "7500", ":", "750", ")", ".", "tween", "(", "\"zoom\"", ",", "function", "(", "d", ")", "{", "var", "i", "=", "d3", ".", "interpolateZoom", "(", "self", ".", "view", ",", "[", "self", ".", "focus", ".", "x", ",", "self", ".", "focus", ".", "y", ",", "self", ".", "focus", ".", "r", "*", "2", "+", "self", ".", "options", ".", "margin", "]", ")", ";", "return", "function", "(", "t", ")", "{", "self", ".", "zoomTo", "(", "i", "(", "t", ")", ")", ";", "}", ";", "}", ")", ";", "transition", ".", "selectAll", "(", "\"text\"", ")", ".", "filter", "(", "function", "(", "d", ")", "{", "return", "d", ".", "parent", "===", "self", ".", "focus", "||", "this", ".", "style", ".", "display", "===", "\"inline\"", "||", "d", ".", "parent", "===", "focus0", ";", "}", ")", ".", "style", "(", "\"fill-opacity\"", ",", "function", "(", "d", ")", "{", "return", "d", ".", "parent", "===", "self", ".", "focus", "?", "1", ":", "0.5", ";", "}", ")", ".", "each", "(", "\"start\"", ",", "function", "(", "d", ")", "{", "if", "(", "d", ".", "parent", "===", "self", ".", "focus", ")", "this", ".", "style", ".", "display", "=", "\"inline\"", ";", "}", ")", ".", "each", "(", "\"end\"", ",", "function", "(", "d", ")", "{", "if", "(", "d", ".", "parent", "!==", "self", ".", "focus", ")", "this", ".", "style", ".", "display", "=", "\"none\"", ";", "}", ")", ";", "// logos are opaque at root level only", "transition", ".", "selectAll", "(", "\"use\"", ")", ".", "style", "(", "\"opacity\"", ",", "function", "(", "d", ")", "{", "return", "self", ".", "focus", ".", "depth", "===", "0", "?", "1", ":", "0.8", ";", "}", ")", ";", "}" ]

[ "a", "function", "responsible", "for", "zooming", "in", "on", "circles" ]

[ "function", "discoverServicesAndCharacteristics", "(", "error", ")", "{", "if", "(", "error", ")", "{", "return", "reject", "(", "error", ")", ";", "}", "peripheral", ".", "discoverSomeServicesAndCharacteristics", "(", "ALL_SERVICES", ",", "ALL_CHARACTERISTICS", ",", "setupEmitter", ")", ";", "}" ]

[ "discovers", "the", "sensor", "service", "and", "it", "s", "characteristics" ]

[ "function", "setupEmitter", "(", "error", ")", "{", "if", "(", "error", ")", "{", "return", "reject", "(", "error", ")", ";", "}", "const", "sensorService", "=", "getService", "(", "SERVICE_SENSOR_UUID", ",", "peripheral", ")", ";", "const", "notifiable", "=", "sensorService", ".", "characteristics", ";", "const", "withNotified", "=", "Promise", ".", "all", "(", "notifiable", ".", "map", "(", "characteristic", "=>", "new", "Promise", "(", "(", "resolve", ",", "reject", ")", "=>", "void", "characteristic", ".", "notify", "(", "[", "]", ",", "error", "=>", "void", "(", "!", "!", "error", "?", "reject", "(", "error", ")", ":", "resolve", "(", "characteristic", ")", ")", ")", ")", ")", ")", ";", "withNotified", ".", "then", "(", "characteristics", "=>", "{", "const", "emitter", "=", "new", "EventEmitter", "(", ")", ";", "const", "onData", "=", "uuid", "=>", "buffer", "=>", "void", "emitter", ".", "emit", "(", "\"data\"", ",", "{", "characteristic", ":", "uuid", ",", "buffer", "}", ")", ";", "characteristics", ".", "forEach", "(", "characteristic", "=>", "void", "characteristic", ".", "on", "(", "'data'", ",", "onData", "(", "characteristic", ".", "uuid", ")", ")", ")", ";", "const", "matrixCharacteristic", "=", "getCharacteristic", "(", "CHARACTERISTIC_MATRIX_UUID", ",", "getService", "(", "SERVICE_MATRIX_UUID", ",", "peripheral", ")", ")", ";", "resolve", "(", "new", "client", ".", "NuimoClient", "(", "emitter", ",", "matrixCharacteristic", ",", "peripheral", ")", ")", ";", "}", ")", ".", "catch", "(", "reject", ")", ";", "}" ]

[ "setup", "each", "service", "characteristic", "of", "the", "sensor", "to", "emit", "data", "on", "new", "data", "when", "all", "have", "been", "setup", "with", "characteristic", ".", "notify", "then", "resolve", "the", "promise" ]

[ "function", "(", "config", ")", "{", "this", ".", "globals", "=", "config", ".", "globals", "||", "{", "}", ";", "this", ".", "templates", "=", "{", "}", ";", "this", ".", "config", "=", "_", ".", "extend", "(", "{", "}", ",", "defaults", ",", "config", ")", ";", "this", ".", "config", ".", "optionsRegex", "=", "new", "RegExp", "(", "\"^\"", "+", "this", ".", "config", ".", "optionsDelimiter", "+", "\"([\\\\S\\\\s]+)\"", "+", "this", ".", "config", ".", "optionsDelimiter", "+", "\"([\\\\S\\\\s]+)\"", ")", ";", "}" ]

[ "Constructor", "for", "the", "Pagemaki", "class" ]

[ "function", "(", "z_real", ",", "w_copy", ",", "s_property", ")", "{", "// property is a function (ie: instance method)", "if", "(", "'function'", "===", "typeof", "z_real", "[", "s_property", "]", ")", "{", "// implement same method name in virtual object", "w_copy", "[", "s_property", "]", "=", "function", "(", ")", "{", "// forward to real class", "return", "z_real", "[", "s_property", "]", ".", "apply", "(", "z_real", ",", "arguments", ")", ";", "}", ";", "}", "// read/write property", "else", "{", "// try to override object property", "try", "{", "Object", ".", "defineProperty", "(", "w_copy", ",", "s_property", ",", "{", "// grant user full capability to modify this property", "configurable", ":", "true", ",", "// give enumerability setting same value as original", "enumerable", ":", "z_real", ".", "propertyIsEnumerable", "(", "s_property", ")", ",", "// fetch property from real object", "get", ":", "(", ")", "=>", "{", "return", "z_real", "[", "s_property", "]", ";", "}", ",", "// set property on real object", "set", ":", "(", "z_value", ")", "=>", "{", "z_real", "[", "s_property", "]", "=", "z_value", ";", "}", ",", "}", ")", ";", "}", "// cannot redefine property", "catch", "(", "d_redef_err", ")", "{", "// try again, this time only set the value and enumerability", "try", "{", "Object", ".", "defineProperty", "(", "w_copy", ",", "s_property", ",", "{", "// give enumerability setting same value as original", "enumerable", ":", "z_real", ".", "propertyIsEnumerable", "(", "s_property", ")", ",", "// mask w undef", "value", ":", "undefined", ",", "}", ")", ";", "// was not exepecting this property to give us trouble", "if", "(", "!", "A_TROUBLE_PROPERTIES", ".", "includes", "(", "s_property", ")", ")", "{", "console", ".", "warn", "(", "'was not expecting \"'", "+", "s_property", "+", "'\" to prohibit redefinition on '", "+", "arginfo", "(", "w_copy", ")", ")", ";", "}", "}", "// cannot even do that?!", "catch", "(", "d_enum_err", ")", "{", "// last try, this time only set the value", "try", "{", "Object", ".", "defineProperty", "(", "w_copy", ",", "s_property", ",", "{", "// mask w undef", "value", ":", "undefined", ",", "}", ")", ";", "// was not exepecting this property to give us trouble", "if", "(", "!", "A_TROUBLE_PROPERTIES", ".", "includes", "(", "s_property", ")", ")", "{", "console", ".", "warn", "(", "'was not expecting \"'", "+", "s_property", "+", "'\" to prohibit redefinition on '", "+", "arginfo", "(", "w_copy", ")", ")", ";", "}", "}", "// fail", "catch", "(", "d_value_err", ")", "{", "throw", "'cannot override property \"'", "+", "s_property", "+", "'\" on '", "+", "arginfo", "(", "w_copy", ")", ";", "}", "}", "}", "}", "}" ]

[ "creates", "a", "transparent", "property", "on", "w_copy", "using", "z_real" ]

[ "function", "logFn", "(", "level", ")", "{", "return", "function", "(", "msg", ")", "{", "var", "args", "=", "Array", ".", "prototype", ".", "slice", ".", "call", "(", "arguments", ")", ";", "if", "(", "level", "===", "'hr'", ")", "{", "args", "=", "[", "'------------------------------------------------------------'", "]", ";", "args", ".", "push", "(", "{", "_hr", ":", "true", "}", ")", ";", "level", "=", "'debug'", ";", "}", "var", "logFn", "=", "logger", "[", "level", "]", "||", "console", "[", "level", "]", ".", "bind", "(", "console", ")", ";", "if", "(", "enabled", ".", "enabled", ")", "logFn", ".", "apply", "(", "logger", ",", "args", ")", ";", "}", ";", "}" ]

[ "Wrap", "winston", "logger", "to", "be", "somewhat", "api", "compatible", "with", "debug" ]

[ "function", "disable", "(", "namespaces", ")", "{", "var", "split", "=", "(", "namespaces", "||", "''", ")", ".", "split", "(", "/", "[\\s,]+", "/", ")", ";", "var", "len", "=", "split", ".", "length", ";", "function", "removeNamespaceFromNames", "(", "namespaces", ")", "{", "_", ".", "remove", "(", "exports", ".", "names", ",", "function", "(", "name", ")", "{", "return", "name", ".", "toString", "(", ")", "===", "'/^'", "+", "namespaces", "+", "'$/'", ";", "}", ")", ";", "}", "for", "(", "var", "i", "=", "0", ";", "i", "<", "len", ";", "i", "++", ")", "{", "if", "(", "!", "split", "[", "i", "]", ")", "continue", ";", "// ignore empty strings", "namespaces", "=", "split", "[", "i", "]", ".", "replace", "(", "/", "\\*", "/", "g", ",", "'.*?'", ")", ";", "if", "(", "namespaces", "[", "0", "]", "===", "'-'", ")", "{", "exports", ".", "skips", ".", "push", "(", "new", "RegExp", "(", "'^'", "+", "namespaces", ".", "substr", "(", "1", ")", "+", "'$'", ")", ")", ";", "}", "else", "{", "removeNamespaceFromNames", "(", "namespaces", ")", ";", "exports", ".", "skips", ".", "push", "(", "new", "RegExp", "(", "'^'", "+", "namespaces", "+", "'$'", ")", ")", ";", "loggerEventBus", ".", "emit", "(", "'disable'", ",", "split", "[", "i", "]", ")", ";", "}", "}", "exports", ".", "save", "(", "namespaces", ")", ";", "}" ]

[ "Disables", "a", "debug", "mode", "by", "namespaces", ".", "This", "can", "include", "modes", "separated", "by", "a", "colon", "and", "wildcards", "." ]

[ "function", "XUnitZH", "(", "runner", ")", "{", "var", "tests", "=", "[", "]", ",", "passes", "=", "0", ",", "failures", "=", "0", ";", "runner", ".", "on", "(", "'pass'", ",", "function", "(", "test", ")", "{", "test", ".", "state", "=", "'passed'", ";", "passes", "++", ";", "tests", ".", "push", "(", "test", ")", ";", "test", ".", "number", "=", "tests", ".", "length", ";", "}", ")", ";", "runner", ".", "on", "(", "'fail'", ",", "function", "(", "test", ")", "{", "test", ".", "state", "=", "'failed'", ";", "failures", "++", ";", "tests", ".", "push", "(", "test", ")", ";", "test", ".", "number", "=", "tests", ".", "length", ";", "}", ")", ";", "runner", ".", "on", "(", "'end'", ",", "function", "(", ")", "{", "console", ".", "log", "(", ")", ";", "console", ".", "log", "(", "'testsuite: Mocha Tests'", "+", "', tests: '", "+", "tests", ".", "length", "+", "', failures: '", "+", "failures", "+", "', errors: '", "+", "failures", "+", "', skipped: '", "+", "(", "tests", ".", "length", "-", "failures", "-", "passes", ")", "+", "', time: '", "+", "0", ")", ";", "appendLine", "(", "tag", "(", "'testsuite'", ",", "{", "name", ":", "'Mocha Tests'", ",", "tests", ":", "tests", ".", "length", ",", "failures", ":", "failures", ",", "errors", ":", "failures", ",", "skipped", ":", "tests", ".", "length", "-", "failures", "-", "passes", ",", "timestamp", ":", "(", "new", "Date", ")", ".", "toUTCString", "(", ")", ",", "time", ":", "0", "}", ",", "false", ")", ")", ";", "tests", ".", "forEach", "(", "test", ")", ";", "appendLine", "(", "'</testsuite>'", ")", ";", "fs", ".", "closeSync", "(", "fd", ")", ";", "process", ".", "exit", "(", "failures", ")", ";", "}", ")", ";", "}" ]

[ "Initialize", "a", "new", "XUnitZH", "reporter", "." ]

[ "function", "toConsole", "(", "number", ",", "name", ",", "state", ",", "content", ")", "{", "console", ".", "log", "(", "number", "+", "') '", "+", "state", "+", "' '", "+", "name", ")", ";", "if", "(", "content", ")", "{", "console", ".", "log", "(", "'\\t'", "+", "content", ")", ";", "}", "}" ]

[ "Output", "to", "console" ]

[ "function", "checkIceComponentState", "(", "key", ",", "value", ")", "{", "if", "(", "typeof", "value", "!=", "'string'", ")", "throw", "SyntaxError", "(", "key", "+", "' param should be a String, not '", "+", "typeof", "value", ")", ";", "if", "(", "!", "value", ".", "match", "(", "'DISCONNECTED|GATHERING|CONNECTING|CONNECTED|READY|FAILED'", ")", ")", "throw", "SyntaxError", "(", "key", "+", "' param is not one of [DISCONNECTED|GATHERING|CONNECTING|CONNECTED|READY|FAILED] ('", "+", "value", "+", "')'", ")", ";", "}" ]

[ "States", "of", "an", "ICE", "component", "." ]

[ "function", "applyStyles", "(", "css", ")", "{", "return", "flattenDeep", "(", "css", ")", ".", "reduce", "(", "(", "classNames", ",", "declarations", ")", "=>", "{", "if", "(", "!", "declarations", ")", "{", "return", "classNames", "}", "classNames", ".", "push", "(", "glamor", "(", "declarations", ")", ")", "return", "classNames", "}", ",", "[", "]", ")", ".", "join", "(", "' '", ")", "}" ]

[ "Generate", "CSS", "classnames", "from", "CSS", "props" ]

[ "function", "centericMap", "(", "array", ",", "callback", ")", "{", "var", "retArray", "=", "[", "]", ",", "length", ",", "left", ",", "right", ";", "if", "(", "array", ")", "{", "length", "=", "array", ".", "length", "-", "1", ";", "left", "=", "length", ">>", "1", ";", "while", "(", "left", ">=", "0", ")", "{", "retArray", "[", "left", "]", "=", "callback", "(", "array", "[", "left", "]", ")", ";", "right", "=", "length", "-", "left", ";", "if", "(", "right", "!==", "left", ")", "{", "retArray", "[", "right", "]", "=", "callback", "(", "array", "[", "right", "]", ")", ";", "}", "left", "--", ";", "}", "}", "return", "retArray", ";", "}" ]

[ "Iterates", "the", "array", "in", "a", "symmetric", "order", "from", "middle", "to", "outwards" ]

[ "function", "(", "children", ")", "{", "var", "allChildren", "=", "this", ".", "get", "(", "'allChildren'", ")", ";", "if", "(", "allChildren", ")", "{", "this", ".", "_setChildren", "(", "allChildren", ".", "filter", "(", "function", "(", "child", ")", "{", "return", "children", ".", "indexOf", "(", "child", ")", "!==", "-", "1", ";", "// true if child is in children", "}", ")", ")", ";", "}", "}" ]

[ "Public", "function", ".", "Set", "the", "child", "array", "after", "filtering" ]

[ "function", "(", "childrenToRemove", ")", "{", "var", "children", "=", "this", ".", "get", "(", "'children'", ")", ";", "if", "(", "children", ")", "{", "children", "=", "children", ".", "filter", "(", "function", "(", "child", ")", "{", "return", "childrenToRemove", ".", "indexOf", "(", "child", ")", "===", "-", "1", ";", "// false if child is in children", "}", ")", ";", "this", ".", "_setChildren", "(", "children", ")", ";", "}", "}" ]

[ "Filter", "out", "the", "given", "children", "from", "the", "children", "array", "." ]

[ "function", "(", "property", ",", "callback", ",", "thisArg", ")", "{", "if", "(", "this", ".", "get", "(", "property", ")", ")", "{", "this", ".", "get", "(", "property", ")", ".", "forEach", "(", "callback", ",", "thisArg", ")", ";", "}", "}" ]

[ "If", "the", "property", "is", "available", "expects", "it", "to", "be", "an", "array", "and", "iterate", "over", "its", "elements", "using", "the", "callback", "." ]

[ "function", "(", "depth", ")", "{", "this", ".", "set", "(", "'depth'", ",", "depth", ")", ";", "depth", "++", ";", "this", ".", "get", "(", "'inputs'", ")", ".", "forEach", "(", "function", "(", "input", ")", "{", "input", ".", "set", "(", "'depth'", ",", "depth", ")", ";", "}", ")", ";", "}" ]

[ "Sets", "depth", "of", "the", "vertex", "and", "all", "its", "input", "children" ]

[ "function", "(", ")", "{", "this", ".", "setChildren", "(", "this", ".", "get", "(", "'inputs'", ")", ".", "concat", "(", "this", ".", "get", "(", "'children'", ")", "||", "[", "]", ")", ")", ";", "var", "ancestor", "=", "this", ".", "get", "(", "'parent.parent'", ")", ";", "if", "(", "ancestor", ")", "{", "ancestor", ".", "setChildren", "(", "this", ".", "get", "(", "'outputs'", ")", ".", "concat", "(", "ancestor", ".", "get", "(", "'children'", ")", "||", "[", "]", ")", ")", ";", "}", "this", ".", "set", "(", "'_additionalsIncluded'", ",", "true", ")", ";", "}" ]

[ "Include", "sources", "and", "sinks", "in", "the", "children", "list", "so", "that", "they", "are", "displayed" ]

[ "function", "(", ")", "{", "this", ".", "removeChildren", "(", "this", ".", "get", "(", "'inputs'", ")", ")", ";", "var", "ancestor", "=", "this", ".", "get", "(", "'parent.parent'", ")", ";", "if", "(", "ancestor", ")", "{", "ancestor", ".", "removeChildren", "(", "this", ".", "get", "(", "'outputs'", ")", ")", ";", "}", "this", ".", "set", "(", "'_additionalsIncluded'", ",", "false", ")", ";", "}" ]

[ "Exclude", "sources", "and", "sinks", "in", "the", "children", "list", "so", "that", "they", "are", "hidden" ]

[ "function", "(", ")", "{", "var", "vertex", "=", "this", ".", "get", "(", "'vertex'", ")", ";", "this", ".", "_super", "(", ")", ";", "// Initialize data members", "this", ".", "setProperties", "(", "{", "id", ":", "vertex", ".", "get", "(", "'vertexName'", ")", "+", "this", ".", "get", "(", "'name'", ")", ",", "depth", ":", "vertex", ".", "get", "(", "'depth'", ")", "+", "1", "}", ")", ";", "}" ]

[ "The", "vertex", "DataNode", "to", "which", "this", "node", "is", "linked" ]

[ "function", "(", "vertex", ",", "data", ")", "{", "return", "InputDataNode", ".", "create", "(", "Ember", ".", "$", ".", "extend", "(", "data", ",", "{", "treeParent", ":", "vertex", ",", "vertex", ":", "vertex", "}", ")", ")", ";", "}" ]

[ "Initiate", "an", "InputDataNode" ]

[ "function", "_normalizeVertexTree", "(", "vertex", ")", "{", "var", "children", "=", "vertex", ".", "get", "(", "'children'", ")", ";", "if", "(", "children", ")", "{", "children", "=", "children", ".", "filter", "(", "function", "(", "child", ")", "{", "_normalizeVertexTree", "(", "child", ")", ";", "return", "child", ".", "get", "(", "'type'", ")", "!==", "'vertex'", "||", "child", ".", "get", "(", "'treeParent'", ")", "===", "vertex", ";", "}", ")", ";", "vertex", ".", "_setChildren", "(", "children", ")", ";", "}", "return", "vertex", ";", "}" ]

[ "Part", "of", "step", "1", "To", "remove", "recurring", "vertices", "in", "the", "tree" ]