Datasets:

---

CM

/

codexglue_code2text_javascript

like 12

[ "function", "(", "emit", ")", "{", "ipc", ".", "send", "(", "{", "cmd", ":", "'setup'", ",", "emit", ":", "emit", ",", "daemon", ":", "process", ".", "pid", ",", "message", ":", "errorBuffer", "===", "\"\"", "?", "null", ":", "errorBuffer", "}", ")", ";", "}" ]

[ "this", "function", "will", "setup", "a", "new", "pump", "as", "a", "daemon" ]

[ "function", "resolveObjectName", "(", "view", ")", "{", "return", "cache", "[", "view", "]", "||", "(", "cache", "[", "view", "]", "=", "view", ".", "split", "(", "'/'", ")", ".", "slice", "(", "-", "1", ")", "[", "0", "]", ".", "split", "(", "'.'", ")", "[", "0", "]", ".", "replace", "(", "/", "^_", "/", ",", "''", ")", ".", "replace", "(", "/", "[^a-zA-Z0-9 ]+", "/", "g", ",", "' '", ")", ".", "split", "(", "/", " +", "/", ")", ".", "map", "(", "function", "(", "word", ",", "i", ")", "{", "return", "i", "?", "word", "[", "0", "]", ".", "toUpperCase", "(", ")", "+", "word", ".", "substr", "(", "1", ")", ":", "word", ";", "}", ")", ".", "join", "(", "''", ")", ")", ";", "}" ]

[ "Resolve", "partial", "object", "name", "from", "the", "view", "path", "." ]

[ "function", "block", "(", "name", ",", "html", ")", "{", "// bound to the blocks object in renderFile", "var", "blk", "=", "this", "[", "name", "]", ";", "if", "(", "!", "blk", ")", "{", "// always create, so if we request a", "// non-existent block we'll get a new one", "blk", "=", "this", "[", "name", "]", "=", "new", "Block", "(", ")", ";", "}", "if", "(", "html", ")", "{", "blk", ".", "append", "(", "html", ")", ";", "}", "return", "blk", ";", "}" ]

[ "Return", "the", "block", "with", "the", "given", "name", "create", "it", "if", "necessary", ".", "Optionally", "append", "the", "given", "html", "to", "the", "block", "." ]

[ "function", "script", "(", "path", ",", "type", ")", "{", "if", "(", "path", ")", "{", "var", "html", "=", "'<script src=\"'", "+", "path", "+", "'\"'", "+", "(", "type", "?", "'type=\"'", "+", "type", "+", "'\"'", ":", "''", ")", "+", "'></script>'", ";", "if", "(", "this", ".", "html", ".", "indexOf", "(", "html", ")", "==", "-", "1", ")", "this", ".", "append", "(", "html", ")", ";", "}", "return", "this", ";", "}" ]

[ "bound", "to", "scripts", "Block", "in", "renderFile" ]

[ "function", "stylesheet", "(", "path", ",", "media", ")", "{", "if", "(", "path", ")", "{", "var", "html", "=", "'<link rel=\"stylesheet\" href=\"'", "+", "path", "+", "'\"'", "+", "(", "media", "?", "'media=\"'", "+", "media", "+", "'\"'", ":", "''", ")", "+", "' />'", ";", "if", "(", "this", ".", "html", ".", "indexOf", "(", "html", ")", "==", "-", "1", ")", "this", ".", "append", "(", "html", ")", ";", "}", "return", "this", ";", "}" ]

[ "bound", "to", "stylesheets", "Block", "in", "renderFile" ]

[ "function", "insertAds", "(", "adUnit", ",", "ads", ",", "adLoadedCallback", ")", "{", "var", "adContainers", "=", "page", ".", "getAdContainers", "(", "adUnit", ")", ";", "if", "(", "!", "adContainers", ".", "length", ")", "{", "logger", ".", "error", "(", "\"No ad containers could be found. stopping insertion for adUnit \"", "+", "adUnit", ".", "name", ")", ";", "return", "[", "]", ";", "//Ad can't be inserted", "}", "var", "adBuilder", "=", "new", "AdBuilder", "(", "ads", ")", ";", "var", "beforeElement", ";", "var", "insertedAdElements", "=", "[", "]", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "adContainers", ".", "length", ";", "i", "++", ")", "{", "var", "adContainer", "=", "adContainers", "[", "i", "]", ";", "while", "(", "(", "beforeElement", "=", "adContainer", ".", "getNextElement", "(", ")", ")", "!==", "null", ")", "{", "var", "adToInsert", "=", "adBuilder", ".", "createAdUnit", "(", "adUnit", ",", "adContainer", ".", "containerElement", ")", ";", "if", "(", "adToInsert", "===", "null", ")", "{", "//we ran out of ads.", "break", ";", "}", "insertedAdElements", ".", "push", "(", "adToInsert", ")", ";", "beforeElement", ".", "parentNode", ".", "insertBefore", "(", "adToInsert", ",", "beforeElement", ".", "nextSibling", ")", ";", "// var elementDisplay = adToInsert.style.display || \"block\";", "//TODO: Why are we defaulting to block here?", "// adToInsert.style.display = elementDisplay;", "handleImageLoad", "(", "adToInsert", ",", "adLoadedCallback", ")", ";", "}", "}", "return", "insertedAdElements", ";", "}" ]

[ "Insert", "advertisements", "for", "the", "given", "ad", "unit", "on", "the", "page" ]

[ "function", "handleImageLoad", "(", "adElement", ",", "adLoadedCallback", ")", "{", "var", "adImage", "=", "adElement", ".", "querySelector", "(", "\"img\"", ")", ";", "if", "(", "adImage", ")", "{", "(", "function", "(", "adToInsert", ",", "adImage", ")", "{", "adImage", ".", "onload", "=", "function", "(", ")", "{", "adLoadedCallback", "(", "adToInsert", ",", "true", ")", ";", "}", ";", "}", ")", "(", "adElement", ",", "adImage", ")", ";", "}", "else", "{", "adLoadedCallback", "(", "adElement", ",", "false", ")", ";", "}", "}" ]

[ "Add", "an", "event", "handler", "to", "the", "onload", "of", "ad", "images", "." ]

[ "function", "(", "powder", ")", "{", "var", "callback", "=", "function", "(", "err", ")", "{", "shooting", "--", ";", "if", "(", "err", ")", "{", "// Only emit error if a listener exists\r", "// This is mainly to prevent silent errors in promises\r", "if", "(", "machinegun", ".", "listenerCount", "(", "'error'", ")", ")", "machinegun", ".", "emit", "(", "'error'", ",", "err", ")", ";", "if", "(", "opt", ".", "giveUpOnError", ")", "machinegun", ".", "giveUp", "(", "err", ")", ";", "}", "trigger", "(", ")", ";", "}", ";", "var", "primer", "=", "function", "(", ")", "{", "var", "maybeThenable", "=", "powder", "(", "callback", ")", ";", "if", "(", "maybeThenable", "&&", "(", "typeof", "maybeThenable", ".", "then", "==", "'function'", ")", ")", "{", "maybeThenable", ".", "then", "(", "callback", ".", "bind", "(", "null", ",", "null", ")", ",", "function", "(", "err", ")", "{", "callback", "(", "err", "||", "new", "Error", "(", ")", ")", ";", "}", ")", ";", "}", "}", ";", "this", ".", "shoot", "=", "function", "(", ")", "{", "shooting", "++", ";", "process", ".", "nextTick", "(", "primer", ")", ";", "}", ";", "}" ]

[ "Primer", "function", "wrapper", "class", "Used", "mainly", "to", "contextualise", "callback" ]

[ "function", "callPromise", "(", "fn", ",", "args", ")", "{", "return", "new", "Promise", "(", "(", "resolve", ",", "reject", ")", "=>", "{", "// promisified callback", "function", "callback", "(", "err", ",", "other", ")", "{", "// check if the 'err' is boolean, if so then this is a 'exists' callback special case", "if", "(", "err", "&&", "(", "typeof", "err", "!==", "'boolean'", ")", ")", "return", "reject", "(", "err", ")", ";", "// convert arguments to proper array, ignoring error argument", "let", "args", "=", "Array", ".", "prototype", ".", "slice", ".", "call", "(", "arguments", ",", "1", ")", ";", "// if arguments length is one or more resolve arguments as array,", "// otherwise resolve the argument as is.", "return", "resolve", "(", "args", ".", "length", "<", "2", "?", "args", "[", "0", "]", ":", "args", ")", ";", "}", "fn", ".", "apply", "(", "null", ",", "args", ".", "concat", "(", "[", "callback", "]", ")", ")", ";", "}", ")", ";", "}" ]

[ "Call", "method", "with", "promises" ]

[ "function", "makePromise", "(", "fn", ")", "{", "return", "function", "(", ")", "{", "var", "args", "=", "Array", ".", "prototype", ".", "slice", ".", "call", "(", "arguments", ")", ";", "if", "(", "hasCallback", "(", "args", ")", ")", "{", "// argument list has callback, so call method with callback", "return", "callCallback", "(", "fn", ",", "args", ")", ";", "}", "else", "{", "// no callback, call method with promises", "return", "callPromise", "(", "fn", ",", "args", ")", ";", "}", "}", "}" ]

[ "Wrap", "method", "to", "handle", "both", "callbacks", "and", "promises" ]

[ "function", "standardizeAddress", "(", "address", ",", "callback", ")", "{", "var", "url", "=", "address_url", "+", "encodeURIComponent", "(", "address", ")", "+", "'?format=json'", ";", "request", "(", "url", ",", "function", "(", "err", ",", "resp", ",", "body", ")", "{", "var", "error", "=", "resp", ".", "statusCode", "!=", "200", "?", "new", "Error", "(", "'Unable to standardize address'", ")", ":", "err", ";", "callback", "(", "error", ",", "body", ")", ";", "}", ")", ";", "}" ]

[ "Standardize", "address", "and", "location", "information", "for", "a", "property", "." ]

[ "function", "getAddressDetails", "(", "body", ",", "callback", ")", "{", "var", "addresses", "=", "JSON", ".", "parse", "(", "body", ")", ".", "addresses", "if", "(", "addresses", ".", "length", "==", "0", ")", "{", "callback", "(", "new", "Error", "(", "'No property information for that address'", ")", ",", "null", ")", ";", "}", "else", "{", "var", "url", "=", "property_url", "+", "encodeURIComponent", "(", "addresses", "[", "0", "]", ".", "standardizedAddress", ")", ";", "request", "(", "url", ",", "function", "(", "err", ",", "resp", ",", "body", ")", "{", "callback", "(", "err", ",", "body", ")", ";", "}", ")", ";", "}", "}" ]

[ "Get", "property", "details", "for", "an", "address", "." ]

[ "function", "isValidPackageName", "(", "name", ")", "{", "const", "stats", "=", "validateName", "(", "name", ")", ";", "return", "stats", ".", "validForNewPackages", "===", "true", "&&", "stats", ".", "validForOldPackages", "===", "true", ";", "}" ]

[ "Returns", "true", "if", "the", "given", "name", "is", "a", "valid", "npm", "package", "name" ]

[ "function", "isValidPlatform", "(", ")", "{", "if", "(", "appSettings", ".", "overrides", "&&", "appSettings", ".", "overrides", ".", "platform", ")", "{", "return", "true", ";", "//If a platform override is set, it's always valid", "}", "return", "/", "iPhone|iPad|iPod|Android", "/", "i", ".", "test", "(", "navigator", ".", "userAgent", ")", ";", "}" ]

[ "Check", "if", "the", "platform", "the", "user", "is", "currently", "visiting", "the", "page", "with", "is", "valid", "for", "the", "ad", "library", "to", "run" ]

[ "function", "detectFormFactor", "(", ")", "{", "var", "viewPortWidth", "=", "Math", ".", "max", "(", "document", ".", "documentElement", ".", "clientWidth", ",", "window", ".", "innerWidth", "||", "0", ")", ";", "var", "displaySettings", "=", "appSettings", ".", "displaySettings", ";", "//convenience variable", "var", "formFactor", ";", "if", "(", "viewPortWidth", ">=", "displaySettings", ".", "mobile", ".", "minWidth", "&&", "viewPortWidth", "<=", "displaySettings", ".", "mobile", ".", "maxWidth", ")", "{", "formFactor", "=", "DeviceEnumerations", ".", "formFactor", ".", "smartPhone", ";", "}", "else", "if", "(", "viewPortWidth", ">=", "displaySettings", ".", "tablet", ".", "minWidth", "&&", "viewPortWidth", "<=", "displaySettings", ".", "tablet", ".", "maxWidth", ")", "{", "formFactor", "=", "DeviceEnumerations", ".", "formFactor", ".", "tablet", ";", "}", "else", "{", "formFactor", "=", "DeviceEnumerations", ".", "formFactor", ".", "desktop", ";", "}", "return", "formFactor", ";", "}" ]

[ "Detects", "the", "device", "form", "factor", "based", "on", "the", "ViewPort", "and", "the", "deviceWidths", "in", "AppSettings", "The", "test_old", "is", "done", "based", "on", "the", "viewport", "because", "it", "is", "already", "validated", "that", "a", "device", "is", "Android", "or", "iOS" ]

[ "function", "(", ")", "{", "var", "pkgJson", "=", "grunt", ".", "file", ".", "readJSON", "(", "\"package.json\"", ")", ";", "if", "(", "pkgJson", ".", "jspm", "&&", "pkgJson", ".", "jspm", ".", "directories", "&&", "pkgJson", ".", "jspm", ".", "directories", ".", "baseURL", ")", "{", "return", "pkgJson", ".", "jspm", ".", "directories", ".", "baseURL", ";", "}", "return", "\"\"", ";", "}" ]

[ "Geth", "the", "JSPM", "baseURL", "from", "package", ".", "json" ]

[ "function", "(", "treeRoot", ")", "{", "var", "stat", "=", "fs", ".", "statSync", "(", "treeRoot", ")", ";", "if", "(", "stat", ".", "isDirectory", "(", ")", ")", "{", "return", "buildTree", "(", "treeRoot", ")", ";", "}", "else", "{", "throw", "new", "Error", "(", "\"path: \"", "+", "treeRoot", "+", "\" is not a directory\"", ")", ";", "}", "}" ]

[ "Crawl", "the", "given", "directory", "and", "build", "the", "tree", "object", "model", "for", "further", "use" ]

[ "function", "(", "tree", ",", "options", ")", "{", "if", "(", "!", "options", ")", "{", "options", "=", "{", "ext", ":", "'.css'", ",", "importFormat", ":", "null", ",", "// to be initialized just bellow", "encoding", ":", "'utf-8'", "}", ";", "}", "if", "(", "!", "options", ".", "ext", ")", "{", "options", ".", "ext", "=", "'.css'", ";", "}", "if", "(", "!", "options", ".", "importFormat", ")", "{", "if", "(", "options", ".", "ext", "===", "'.css'", ")", "{", "options", ".", "importFormat", "=", "function", "(", "path", ")", "{", "return", "'@import \"'", "+", "path", "+", "'\";'", ";", "}", ";", "}", "else", "if", "(", "options", ".", "ext", "===", "'.less'", ")", "{", "options", ".", "importFormat", "=", "function", "(", "path", ")", "{", "return", "'@import (less) \"'", "+", "path", "+", "'\";'", ";", "}", ";", "}", "}", "if", "(", "!", "options", ".", "encoding", ")", "{", "options", ".", "encoding", "=", "'utf-8'", ";", "}", "generate", "(", "tree", ",", "null", ",", "options", ")", ";", "}" ]

[ "Generate", "the", "files", "that", "contains" ]

[ "function", "validateBemDecl", "(", "bemDecl", ",", "fileName", ")", "{", "let", "errors", "=", "[", "]", ";", "bemDecl", ".", "forEach", "(", "(", "decl", ")", "=>", "{", "errors", "=", "errors", ".", "concat", "(", "validateBemDeclItem", "(", "decl", ",", "fileName", ")", ")", ";", "}", ")", ";", "return", "errors", ";", "}" ]

[ "Validate", "BEM", "declarations" ]

[ "function", "validateBemDeclItem", "(", "decl", ",", "fileName", ")", "{", "let", "errors", "=", "[", "]", ";", "Object", ".", "keys", "(", "decl", ")", ".", "forEach", "(", "(", "key", ")", "=>", "{", "const", "val", "=", "decl", "[", "key", "]", ";", "if", "(", "val", "===", "'[object Object]'", ")", "{", "errors", ".", "push", "(", "new", "Error", "(", "'Error in BemJson '", "+", "fileName", "+", "' produced wrong BemDecl '", "+", "JSON", ".", "stringify", "(", "decl", ",", "null", ",", "2", ")", ")", ")", ";", "}", "}", ")", ";", "return", "errors", ";", "}" ]

[ "Validate", "single", "BEM", "declaration" ]

[ "function", "_getToken", "(", "/*klass, klass1, klass2*/", ")", "{", "if", "(", "!", "tokens", ")", "{", "throw", "new", "Error", "(", "'no tokens found'", ")", ";", "}", "var", "_args", "=", "[", "]", ".", "slice", ".", "call", "(", "arguments", ")", ".", "join", "(", "' '", ")", ".", "split", "(", "' '", ")", ";", "var", "_result", "=", "_args", ".", "map", "(", "function", "(", "klass", ")", "{", "var", "token", "=", "tokens", "[", "klass", "]", ";", "if", "(", "!", "token", ")", "{", "throw", "new", "Error", "(", "'no token found for '", "+", "klass", ")", ";", "}", "return", "token", ";", "}", ")", ".", "join", "(", "' '", ")", ";", "return", "_result", ";", "}" ]

[ "be", "careful", "here", "this", "function", "is", "defined", "like", "this", "for", "ease", "of", "use", "but", "this", "is", "going", "to", "actually", "be", "serialized", "inside", "the", "output", "of", "the", "transform", "so", "tokens", "inside", "this", "function", "refer", "to", "the", "tokens", "variable", "declared", "in", "the", "transformed", "code" ]

[ "function", "handleBuffer", "(", "file", ",", "encoding", ",", "cb", ")", "{", "const", "config", "=", "configParser", "(", "String", "(", "file", ".", "contents", ")", ")", ";", "holograph", ".", "holograph", "(", "config", ")", ";", "return", "cb", "(", "null", ",", "file", ")", ";", "}" ]

[ "Run", "Hologram", "when", "given", "a", "buffer", "." ]

[ "function", "handleStream", "(", "file", ",", "encoding", ",", "cb", ")", "{", "let", "config", "=", "''", ";", "file", ".", "contents", ".", "on", "(", "'data'", ",", "chunk", "=>", "{", "config", "+=", "chunk", ";", "}", ")", ";", "file", ".", "contents", ".", "on", "(", "'end'", ",", "(", ")", "=>", "{", "config", "=", "configParser", "(", "config", ")", ";", "holograph", ".", "holograph", "(", "config", ")", ";", "return", "cb", "(", "null", ",", "file", ")", ";", "}", ")", ";", "}" ]

[ "Run", "Hologram", "when", "given", "a", "stream", "." ]

[ "function", "gulpHolograph", "(", ")", "{", "return", "through", ".", "obj", "(", "function", "(", "file", ",", "encoding", ",", "cb", ")", "{", "// Handle any non-supported types.", "// This covers directories and symlinks as well, as they have to be null.", "if", "(", "file", ".", "isNull", "(", ")", ")", "{", "this", ".", "emit", "(", "'error'", ",", "new", "PluginError", "(", "PLUGIN_NAME", ",", "'No file contents.'", ")", ")", ";", "}", "// Handle buffers.", "if", "(", "file", ".", "isBuffer", "(", ")", ")", "{", "handleBuffer", "(", "file", ",", "encoding", ",", "cb", ")", ";", "}", "// Handle streams.", "if", "(", "file", ".", "isStream", "(", ")", ")", "{", "handleStream", "(", "file", ",", "encoding", ",", "cb", ")", ";", "}", "}", ")", ";", "}" ]

[ "The", "actual", "plugin", ".", "Runs", "Holograph", "with", "a", "provided", "config", "file", "." ]

[ "function", "JModelError", "(", "obj", ")", "{", "this", ".", "message", "=", "obj", "[", "'message'", "]", ";", "this", ".", "propertyName", "=", "obj", "[", "'propertyName'", "]", ";", "Error", ".", "call", "(", "this", ")", ";", "Error", ".", "captureStackTrace", "(", "this", ",", "this", ".", "constructor", ")", ";", "}" ]

[ "JModel", "Error", "Class" ]

[ "function", "normalize", "(", "filepath", ")", "{", "// resolve to an absolute ppath", "if", "(", "!", "path", ".", "isAbsolute", "||", "!", "path", ".", "isAbsolute", "(", "filepath", ")", ")", "filepath", "=", "path", ".", "resolve", "(", "path", ".", "dirname", "(", "module", ".", "parent", ".", "filename", ")", ",", "filepath", ")", ";", "// tack .json on the end if need be", "if", "(", "!", "/", "\\.json$", "/", ".", "test", "(", "filepath", ")", ")", "filepath", "=", "filepath", "+", "'.json'", ";", "return", "filepath", ";", "}" ]

[ "clean", "up", "paths", "for", "convenient", "loading" ]

[ "function", "parse", "(", "contents", ",", "retained", ",", "parser", ")", "{", "var", "errors", "=", "[", "]", ",", "data", "=", "[", "]", ",", "lines", "=", "0", ";", "// optional parser", "if", "(", "!", "parser", ")", "parser", "=", "JSON", ";", "// process each line of the file", "contents", ".", "toString", "(", ")", ".", "split", "(", "'\\n'", ")", ".", "forEach", "(", "function", "(", "line", ")", "{", "if", "(", "!", "line", ")", "return", ";", "lines", "++", ";", "try", "{", "data", ".", "push", "(", "parser", ".", "parse", "(", "line", ")", ")", ";", "}", "catch", "(", "e", ")", "{", "e", ".", "line", "=", "line", ";", "errors", ".", "push", "(", "e", ")", ";", "}", "}", ")", ";", "// if no errors/data, don't return an empty array", "var", "ret", "=", "{", "}", ";", "if", "(", "errors", ".", "length", ")", "ret", ".", "errors", "=", "errors", ";", "if", "(", "data", ".", "length", ")", "ret", ".", "data", "=", "data", ";", "// if every line failed, probably not line-delimited", "if", "(", "errors", ".", "length", "==", "lines", ")", "ret", ".", "errors", "=", "retained", ";", "return", "ret", ";", "}" ]

[ "process", "line", "-", "delimited", "files" ]

[ "function", "createTranspiler", "(", "{", "mappers", "=", "{", "}", ",", "initialScopeData", "}", "=", "{", "}", ")", "{", "const", "config", "=", "{", "scope", ":", "createScope", "(", "initialScopeData", ")", ",", "mappers", "}", ";", "return", "(", "config", ".", "decoratedTranspile", "=", "transpile", ".", "bind", "(", "null", ",", "config", ")", ")", ";", "}" ]

[ "eslint", "-", "disable", "-", "line", "no", "-", "use", "-", "before", "-", "define" ]

[ "function", "MatchPath", "(", ")", "{", "var", "defaultAction", "=", "'welcome'", ",", "defaultMethod", "=", "'index'", ";", "/**\n * Resolve uri\n * @param request\n * @returns {*}\n */", "this", ".", "resolve", "=", "function", "(", "request", ")", "{", "var", "action", "=", "defaultAction", ";", "var", "method", "=", "defaultMethod", ";", "if", "(", "'/'", "!=", "request", ".", "url", ")", "{", "var", "uriComponents", "=", "request", ".", "url", ".", "split", "(", "'?'", ")", "[", "0", "]", ".", "substr", "(", "1", ")", ".", "split", "(", "'/'", ")", ";", "if", "(", "uriComponents", ".", "length", ">", "1", ")", "{", "method", "=", "uriComponents", ".", "pop", "(", ")", ";", "action", "=", "uriComponents", ".", "join", "(", "'/'", ")", ";", "}", "else", "if", "(", "uriComponents", ".", "length", "==", "1", ")", "{", "action", "=", "uriComponents", "[", "0", "]", ";", "}", "}", "return", "{", "action", ":", "action", ",", "method", ":", "method", ",", "arguments", ":", "[", "]", "}", ";", "}", ";", "/**\n * Set default action\n * @param action\n * @returns {MatchPath}\n */", "this", ".", "setDefaultAction", "=", "function", "(", "action", ")", "{", "defaultAction", "=", "action", ";", "return", "this", ";", "}", ";", "/**\n * Set default method\n * @param method\n * @returns {MatchPath}\n */", "this", ".", "setDefaultMethod", "=", "function", "(", "method", ")", "{", "defaultMethod", "=", "method", ";", "return", "this", ";", "}", ";", "return", "this", ";", "}" ]

[ "Simple", "router", "which", "will", "match", "url", "pathname", "with", "an", "action" ]

[ "function", "resolveTemplateFiles", "(", "name", ")", "{", "// Create paths for resolving", "var", "customFile", "=", "customDir", "+", "'/'", "+", "name", "+", "'.js'", ",", "customTemplateDir", "=", "customDir", "+", "'/'", "+", "name", "+", "'/**/*'", ",", "stdFile", "=", "stdDir", "+", "'/'", "+", "name", "+", "'.js'", ",", "stdTemplateDir", "=", "stdDir", "+", "'/'", "+", "name", "+", "'/**/*'", ";", "// Grab any and all files", "var", "customFiles", "=", "expandFiles", "(", "customFile", ")", ".", "concat", "(", "expandFiles", "(", "customTemplateDir", ")", ")", ",", "stdFiles", "=", "expandFiles", "(", "stdFile", ")", ".", "concat", "(", "expandFiles", "(", "stdTemplateDir", ")", ")", ";", "// Generate a hash of files", "var", "fileMap", "=", "{", "}", ";", "// Iterate over the customFiles", "customFiles", ".", "forEach", "(", "function", "(", "file", ")", "{", "// Extract the relative path of the file", "var", "relPath", "=", "path", ".", "relative", "(", "customDir", ",", "file", ")", ";", "// Save the relative path", "fileMap", "[", "relPath", "]", "=", "file", ";", "}", ")", ";", "// Iterate over the stdFiles", "stdFiles", ".", "forEach", "(", "function", "(", "file", ")", "{", "// Extract the relative path of the file", "var", "relPath", "=", "path", ".", "relative", "(", "stdDir", ",", "file", ")", ",", "overrideExists", "=", "fileMap", "[", "relPath", "]", ";", "// If it does not exist, save it", "if", "(", "!", "overrideExists", ")", "{", "fileMap", "[", "relPath", "]", "=", "file", ";", "}", "}", ")", ";", "// Return the fileMap", "return", "fileMap", ";", "}" ]

[ "Define", "a", "helper", "to", "find", "custom", "and", "standard", "template", "files" ]

[ "function", "rotate", "(", "angle", ",", "cx", ",", "cy", ")", "{", "var", "cosAngle", "=", "cos", "(", "angle", ")", ";", "var", "sinAngle", "=", "sin", "(", "angle", ")", ";", "var", "rotationMatrix", "=", "{", "a", ":", "cosAngle", ",", "c", ":", "-", "sinAngle", ",", "e", ":", "0", ",", "b", ":", "sinAngle", ",", "d", ":", "cosAngle", ",", "f", ":", "0", "}", ";", "if", "(", "(", "0", ",", "_utils", ".", "isUndefined", ")", "(", "cx", ")", "||", "(", "0", ",", "_utils", ".", "isUndefined", ")", "(", "cy", ")", ")", "{", "return", "rotationMatrix", ";", "}", "return", "(", "0", ",", "_transform", ".", "transform", ")", "(", "[", "(", "0", ",", "_translate", ".", "translate", ")", "(", "cx", ",", "cy", ")", ",", "rotationMatrix", ",", "(", "0", ",", "_translate", ".", "translate", ")", "(", "-", "cx", ",", "-", "cy", ")", "]", ")", ";", "}" ]

[ "Calculate", "a", "rotation", "matrix" ]

[ "function", "rotateDEG", "(", "angle", ")", "{", "var", "cx", "=", "arguments", ".", "length", ">", "1", "&&", "arguments", "[", "1", "]", "!==", "undefined", "?", "arguments", "[", "1", "]", ":", "undefined", ";", "var", "cy", "=", "arguments", ".", "length", ">", "2", "&&", "arguments", "[", "2", "]", "!==", "undefined", "?", "arguments", "[", "2", "]", ":", "undefined", ";", "return", "rotate", "(", "angle", "*", "PI", "/", "180", ",", "cx", ",", "cy", ")", ";", "}" ]

[ "Calculate", "a", "rotation", "matrix", "with", "a", "DEG", "angle" ]

[ "function", "reload", "(", "args", ")", "{", "if", "(", "args", "!==", "undefined", ")", "{", "if", "(", "args", ".", "l", "!==", "undefined", ")", "{", "fs", ".", "closeSync", "(", "1", ")", ";", "fs", ".", "openSync", "(", "args", ".", "l", ",", "'a+'", ")", ";", "}", "if", "(", "args", ".", "e", "!==", "undefined", ")", "{", "fs", ".", "closeSync", "(", "2", ")", ";", "fs", ".", "openSync", "(", "args", ".", "e", ",", "'a+'", ")", ";", "}", "}", "}" ]

[ "Close", "the", "standard", "output", "and", "error", "descriptors", "and", "redirect", "them", "to", "the", "specified", "files", "provided", "in", "the", "argument" ]

[ "function", "setupHandlers", "(", ")", "{", "function", "terminate", "(", "err", ")", "{", "util", ".", "log", "(", "'Uncaught Error: '", "+", "err", ".", "message", ")", ";", "console", ".", "log", "(", "err", ".", "stack", ")", ";", "if", "(", "proc", ".", "shutdownHook", ")", "{", "proc", ".", "shutdownHook", "(", "err", ",", "gracefulShutdown", ")", ";", "}", "}", "process", ".", "on", "(", "'uncaughtException'", ",", "terminate", ")", ";", "process", ".", "addListener", "(", "'SIGINT'", ",", "gracefulShutdown", ")", ";", "process", ".", "addListener", "(", "'SIGHUP'", ",", "function", "(", ")", "{", "util", ".", "log", "(", "'RECIEVED SIGHUP signal, reloading log files...'", ")", ";", "reload", "(", "argv", ")", ";", "}", ")", ";", "}" ]

[ "Reopen", "logfiles", "on", "SIGHUP", "Exit", "on", "uncaught", "exceptions" ]

[ "function", "enableCommand", "(", "consoleService", ",", "moduleId", ",", "msg", ",", "cb", ")", "{", "if", "(", "!", "moduleId", ")", "{", "logger", ".", "error", "(", "`", "${", "moduleId", "}", "`", ")", ";", "cb", "(", "'empty moduleId'", ")", ";", "return", ";", "}", "const", "modules", "=", "consoleService", ".", "modules", ";", "if", "(", "!", "modules", "[", "moduleId", "]", ")", "{", "cb", "(", "null", ",", "protocol", ".", "PRO_FAIL", ")", ";", "return", ";", "}", "if", "(", "consoleService", ".", "master", ")", "{", "consoleService", ".", "enable", "(", "moduleId", ")", ";", "consoleService", ".", "agent", ".", "notifyCommand", "(", "'enable'", ",", "moduleId", ",", "msg", ")", ";", "cb", "(", "null", ",", "protocol", ".", "PRO_OK", ")", ";", "}", "else", "{", "consoleService", ".", "enable", "(", "moduleId", ")", ";", "cb", "(", "null", ",", "protocol", ".", "PRO_OK", ")", ";", "}", "}" ]

[ "enable", "module", "in", "current", "server" ]

[ "function", "registerRecord", "(", "service", ",", "moduleId", ",", "module", ")", "{", "const", "record", "=", "{", "moduleId", ":", "moduleId", ",", "module", ":", "module", ",", "enable", ":", "false", "}", ";", "if", "(", "module", ".", "type", "&&", "module", ".", "interval", ")", "{", "if", "(", "!", "service", ".", "master", "&&", "record", ".", "module", ".", "type", "===", "'push'", "||", "service", ".", "master", "&&", "record", ".", "module", ".", "type", "!==", "'push'", ")", "{", "// eslint-disable-line", "// push for monitor or pull for master(default)", "record", ".", "delay", "=", "module", ".", "delay", "||", "0", ";", "record", ".", "interval", "=", "module", ".", "interval", "||", "1", ";", "// normalize the arguments", "if", "(", "record", ".", "delay", "<", "0", ")", "{", "record", ".", "delay", "=", "0", ";", "}", "if", "(", "record", ".", "interval", "<", "0", ")", "{", "record", ".", "interval", "=", "1", ";", "}", "record", ".", "interval", "=", "Math", ".", "ceil", "(", "record", ".", "interval", ")", ";", "record", ".", "delay", "*=", "MS_OF_SECOND", ";", "record", ".", "interval", "*=", "MS_OF_SECOND", ";", "record", ".", "schedule", "=", "true", ";", "}", "}", "return", "record", ";", "}" ]

[ "register", "a", "module", "service" ]

[ "function", "addToSchedule", "(", "service", ",", "record", ")", "{", "if", "(", "record", "&&", "record", ".", "schedule", ")", "{", "record", ".", "jobId", "=", "schedule", ".", "scheduleJob", "(", "{", "start", ":", "Date", ".", "now", "(", ")", "+", "record", ".", "delay", ",", "period", ":", "record", ".", "interval", "}", ",", "doScheduleJob", ",", "{", "service", ":", "service", ",", "record", ":", "record", "}", ")", ";", "}", "}" ]

[ "schedule", "console", "module" ]

[ "function", "exportEvent", "(", "outer", ",", "inner", ",", "event", ")", "{", "inner", ".", "on", "(", "event", ",", "(", "...", "args", ")", "=>", "{", "args", ".", "unshift", "(", "event", ")", ";", "outer", ".", "emit", "(", "...", "args", ")", ";", "}", ")", ";", "}" ]

[ "export", "closure", "function", "out" ]

[ "function", "add_group", "(", ")", "{", "server", ".", "EntryGroupNew", "(", "function", "(", "err", ",", "path", ")", "{", "if", "(", "err", ")", "{", "sails", ".", "log", ".", "error", "(", "'DBus: Could not call org.freedesktop.Avahi.Server.EntryGroupNew'", ")", ";", "return", ";", "}", "service", ".", "getInterface", "(", "path", ",", "avahi", ".", "DBUS_INTERFACE_ENTRY_GROUP", ".", "value", ",", "function", "(", "err", ",", "newGroup", ")", "{", "group", "=", "newGroup", ";", "add_service", "(", ")", ";", "}", ")", "}", ")", ";", "}" ]

[ "Add", "a", "new", "EntryGroup", "for", "our", "service", "." ]

[ "function", "add_service", "(", ")", "{", "// Default configuration. Overrides can be defined in `config/avahi.js`.", "sails", ".", "log", ".", "info", "(", "'Publishing service '", "+", "config", ".", "name", "+", "' ('", "+", "config", ".", "type", "+", "') on port '", "+", "config", ".", "port", ")", ";", "group", ".", "AddService", "(", "avahi", ".", "IF_UNSPEC", ".", "value", ",", "avahi", ".", "PROTO_INET", ".", "value", ",", "0", ",", "config", ".", "name", ",", "config", ".", "type", ",", "config", ".", "domain", ",", "config", ".", "host", ",", "config", ".", "port", ",", "''", ",", "function", "(", "err", ")", "{", "if", "(", "err", ")", "{", "sails", ".", "log", ".", "error", "(", "'DBus: Could not call org.freedesktop.Avahi.EntryGroup.AddService'", ")", ";", "return", ";", "}", "group", ".", "Commit", "(", ")", ";", "}", ")", ";", "}" ]

[ "Add", "our", "service", "definition", "." ]

[ "function", "triggerEvent", "(", "eventType", ",", "options", ")", "{", "var", "event", ",", "key", ";", "options", "=", "options", "||", "{", "}", ";", "eventType", "=", "'opbeat'", "+", "eventType", ".", "substr", "(", "0", ",", "1", ")", ".", "toUpperCase", "(", ")", "+", "eventType", ".", "substr", "(", "1", ")", ";", "if", "(", "document", ".", "createEvent", ")", "{", "event", "=", "document", ".", "createEvent", "(", "'HTMLEvents'", ")", ";", "event", ".", "initEvent", "(", "eventType", ",", "true", ",", "true", ")", ";", "}", "else", "{", "event", "=", "document", ".", "createEventObject", "(", ")", ";", "event", ".", "eventType", "=", "eventType", ";", "}", "for", "(", "key", "in", "options", ")", "if", "(", "hasKey", "(", "options", ",", "key", ")", ")", "{", "event", "[", "key", "]", "=", "options", "[", "key", "]", ";", "}", "if", "(", "document", ".", "createEvent", ")", "{", "// IE9 if standards", "document", ".", "dispatchEvent", "(", "event", ")", ";", "}", "else", "{", "// IE8 regardless of Quirks or Standards", "// IE9 if quirks", "try", "{", "document", ".", "fireEvent", "(", "'on'", "+", "event", ".", "eventType", ".", "toLowerCase", "(", ")", ",", "event", ")", ";", "}", "catch", "(", "e", ")", "{", "}", "}", "}" ]

[ "To", "be", "deprecated" ]

[ "function", "(", "url", ",", "method", "=", "'get'", ",", "body", "=", "undefined", ")", "{", "var", "deferred", "=", "Q", ".", "defer", "(", ")", ";", "this", ".", "extendedRequest", "(", "url", ",", "method", ",", "body", ")", ".", "then", "(", "(", "res", ")", "=>", "{", "deferred", ".", "resolve", "(", "res", ".", "body", ")", ";", "}", ")", ".", "catch", "(", "(", "err", ")", "=>", "{", "deferred", ".", "reject", "(", "err", ")", ";", "}", ")", ";", "return", "deferred", ".", "promise", ";", "}" ]

[ "Returns", "only", "the", "response", "body" ]

[ "function", "bowerPackageURL", "(", "packageName", ",", "cb", ")", "{", "if", "(", "typeof", "cb", "!==", "'function'", ")", "{", "throw", "new", "TypeError", "(", "'cb must be a function'", ")", ";", "}", "if", "(", "typeof", "packageName", "!==", "'string'", ")", "{", "cb", "(", "new", "TypeError", "(", "'packageName must be a string'", ")", ")", ";", "return", ";", "}", "http", ".", "get", "(", "'https://bower.herokuapp.com/packages/'", "+", "packageName", ")", ".", "end", "(", "function", "(", "err", ",", "res", ")", "{", "if", "(", "err", "&&", "err", ".", "status", "===", "404", ")", "{", "err", "=", "new", "Error", "(", "'Package '", "+", "packageName", "+", "' not found on Bower'", ")", ";", "}", "cb", "(", "err", ",", "res", ".", "body", ".", "url", ")", ";", "}", ")", ";", "}" ]

[ "The", "bowerPackageURL", "callback" ]

[ "function", "addPoints", "(", "x1", ",", "y1", ",", "x2", ",", "y2", ",", "cb", ")", "{", "var", "xFinal", "=", "x1", "+", "x2", ";", "var", "yFinal", "=", "y1", "+", "y2", ";", "cb", "(", "xFinal", ",", "yFinal", ")", ";", "}" ]

[ "this", "function", "takes", "the", "sum", "of", "two", "points", "and", "returns", "the", "sum", "of", "x", "s", "and", "the", "sum", "of", "y", "s", "in", "a", "callback" ]

[ "function", "emitObject", "(", ")", "{", "var", "item", "=", "{", "type", ":", "types", "[", "type", "]", ",", "size", ":", "length", ",", "body", ":", "bops", ".", "join", "(", "parts", ")", ",", "offset", ":", "start", "}", ";", "if", "(", "ref", ")", "item", ".", "ref", "=", "ref", ";", "parts", ".", "length", "=", "0", ";", "start", "=", "0", ";", "offset", "=", "0", ";", "type", "=", "0", ";", "length", "=", "0", ";", "ref", "=", "null", ";", "emit", "(", "item", ")", ";", "}" ]

[ "Common", "helper", "for", "emitting", "all", "three", "object", "shapes" ]

[ "function", "$body", "(", "byte", ",", "i", ",", "chunk", ")", "{", "if", "(", "inf", ".", "write", "(", "byte", ")", ")", "return", "$body", ";", "var", "buf", "=", "inf", ".", "flush", "(", ")", ";", "inf", ".", "recycle", "(", ")", ";", "if", "(", "buf", ".", "length", ")", "{", "parts", ".", "push", "(", "buf", ")", ";", "}", "emitObject", "(", ")", ";", "// If this was all the objects, start calculating the sha1sum", "if", "(", "--", "num", ")", "return", "$header", ";", "sha1sum", ".", "update", "(", "bops", ".", "subarray", "(", "chunk", ",", "0", ",", "i", "+", "1", ")", ")", ";", "return", "$checksum", ";", "}" ]

[ "Feed", "the", "deflated", "code", "to", "the", "inflate", "engine" ]

[ "function", "typeOf", "(", "rule", ")", "{", "var", "ruleType", "=", "typeof", "rule", "return", "ruleType", "===", "'function'", "?", "ruleType", ":", "ruleType", "!==", "'object'", "?", "(", "rule", ".", "length", "===", "0", "?", "'noop'", ":", "(", "rule", "===", "0", "?", "'zero'", ":", "ruleType", ")", ")", ":", "Buffer", ".", "isBuffer", "(", "rule", ")", "?", "'buffer'", ":", "!", "isArray", "(", "rule", ")", "?", "(", "(", "has", "(", "rule", ",", "'start'", ")", "&&", "has", "(", "rule", ",", "'end'", ")", "?", "'range'", ":", "has", "(", "rule", ",", "'start'", ")", "?", "'rangestart'", ":", "has", "(", "rule", ",", "'end'", ")", "?", "'rangeend'", ":", "has", "(", "rule", ",", "'firstOf'", ")", "?", "(", "(", "(", "isArray", "(", "rule", ".", "firstOf", ")", "&&", "sameTypeArray", "(", "rule", ".", "firstOf", ")", ")", "||", "typeof", "rule", ".", "firstOf", "===", "'string'", ")", "&&", "rule", ".", "firstOf", ".", "length", ">", "1", ")", "?", "'firstof'", ":", "'invalid firstof'", ":", "'invalid'", ")", "+", "'_object'", ")", ":", "!", "sameTypeArray", "(", "rule", ")", "?", "'multi types array'", ":", "(", "(", "Buffer", ".", "isBuffer", "(", "rule", "[", "0", "]", ")", "?", "'buffer'", ":", "typeof", "rule", "[", "0", "]", ")", "+", "'_array'", ")", "}" ]

[ "Return", "the", "type", "of", "an", "item" ]

[ "function", "encounter", "(", "mood", ")", "{", "//Sentence 1: The meeting", "const", "familiar_people", "=", "wordLib", ".", "getWords", "(", "\"familiar_people\"", ")", ";", "const", "strange_people", "=", "wordLib", ".", "getWords", "(", "\"strange_people\"", ")", ";", "const", "locations", "=", "wordLib", ".", "getWords", "(", "\"locations\"", ")", ";", "const", "person", "=", "nu", ".", "chooseFrom", "(", "familiar_people", ".", "concat", "(", "strange_people", ")", ")", ";", "let", "location", "=", "nu", ".", "chooseFrom", "(", "wordLib", ".", "getWords", "(", "\"locations\"", ")", ")", ";", "const", "preposition", "=", "location", "[", "0", "]", ";", "location", "=", "location", "[", "1", "]", ";", "const", "s1", "=", "`", "${", "person", "}", "${", "preposition", "}", "${", "location", "}", "`", ";", "// Sentence 2: The discussion", "let", "discussions", "=", "wordLib", ".", "getWords", "(", "\"neutral_discussions\"", ")", ";", "discussions", ".", "concat", "(", "wordLib", ".", "getWords", "(", "mood", "+", "\"_discussions\"", ")", ")", ";", "const", "feeling_nouns", "=", "wordLib", ".", "getWords", "(", "mood", "+", "\"_feeling_nouns\"", ")", ";", "const", "emotive_nouns", "=", "wordLib", ".", "getWords", "(", "mood", "+", "\"_emotive_nouns\"", ")", ";", "const", "conversation_topics", "=", "wordLib", ".", "getWords", "(", "\"conversation_topics\"", ")", ";", "const", "discussion", "=", "nu", ".", "chooseFrom", "(", "discussions", ")", ";", "const", "rnum", "=", "Math", ".", "floor", "(", "Math", ".", "random", "(", ")", "*", "10", ")", ";", "let", "feeling", ";", "if", "(", "rnum", "<", "-", "5", ")", "{", "feeling", "=", "nu", ".", "chooseFrom", "(", "feeling_nouns", ")", ";", "feeling", "=", "\"feelings of \"", "+", "feeling", ";", "}", "else", "{", "feeling", "=", "nu", ".", "chooseFrom", "(", "emotive_nouns", ")", ";", "}", "const", "topic", "=", "nu", ".", "chooseFrom", "(", "conversation_topics", ")", ";", "let", "s2", "=", "`", "${", "nu", ".", "an", "(", "discussion", ")", "}", "${", "topic", "}", "${", "feeling", "}", "`", ";", "s2", "=", "nu", ".", "sentenceCase", "(", "s2", ")", ";", "return", "`", "${", "s1", "}", "${", "s2", "}", "`", ";", "}" ]

[ "Generate", "a", "few", "sentences", "about", "a", "meeting", "with", "another", "person", "." ]

[ "function", "feeling", "(", "mood", ")", "{", "const", "rnum", "=", "Math", ".", "floor", "(", "Math", ".", "random", "(", ")", "*", "10", ")", ";", "const", "adjectives", "=", "wordLib", ".", "getWords", "(", "mood", "+", "\"_feeling_adjs\"", ")", ";", "//var degrees = getWords(\"neutral_degrees\") + getWords(mood + \"_degrees\");", "const", "degrees", "=", "wordLib", ".", "getWords", "(", "\"neutral_degrees\"", ")", ".", "concat", "(", "wordLib", ".", "getWords", "(", "mood", "+", "\"_degrees\"", ")", ")", ";", "const", "adj", "=", "nu", ".", "ingToEd", "(", "nu", ".", "chooseFrom", "(", "adjectives", ")", ")", ";", "const", "degree", "=", "nu", ".", "chooseFrom", "(", "degrees", ")", ";", "let", "ending", ";", "if", "(", "mood", "===", "\"good\"", ")", "{", "ending", "=", "wordLib", ".", "positiveIntensify", "(", ")", ";", "}", "else", "{", "ending", "=", "wordLib", ".", "consolation", "(", ")", ";", "}", "const", "exciting", "=", "(", "mood", "===", "\"GOOD\"", "&&", "rnum", "<=", "5", ")", ";", "const", "are", "=", "nu", ".", "chooseFrom", "(", "[", "\" are\"", ",", "\"'re\"", "]", ")", ";", "const", "sentence", "=", "`", "${", "are", "}", "${", "degree", "}", "${", "adj", "}", "${", "ending", "}", "`", ";", "return", "nu", ".", "sentenceCase", "(", "sentence", ",", "exciting", ")", ";", "}" ]

[ "A", "mood", "-", "based", "feeling" ]

[ "function", "getGameAfterMove", "(", "game", ",", "move", ",", "backMove", "=", "false", ")", "{", "if", "(", "!", "backMove", "&&", "canNotMove", "(", "game", ",", "move", ")", ")", "return", "game", ";", "const", "board", "=", "getBoardAfterMove", "(", "game", ".", "board", ",", "move", ")", ";", "return", "{", "players", ":", "game", ".", "players", ",", "board", ",", "score", ":", "Score", ".", "getScore", "(", "game", ".", "board", ")", ",", "moves", ":", "backMove", "?", "game", ".", "moves", ":", "game", ".", "moves", ".", "concat", "(", "getMoveXAndY", "(", "move", ")", ")", "}", ";", "}" ]

[ "Takes", "game", "and", "move", "then", "returns", "new", "game", "after", "move", "." ]

[ "function", "getGameBeforeLastMove", "(", "game", ")", "{", "// $Fix I do NOT know if it is the best way to make game immutable.", "game", "=", "Object", ".", "assign", "(", "{", "}", ",", "game", ")", ";", "let", "lastMove", "=", "game", ".", "moves", ".", "pop", "(", ")", ";", "if", "(", "lastMove", ")", "game", "=", "getGameAfterMove", "(", "game", ",", "getBackMove", "(", "lastMove", ")", ",", "true", ")", ";", "if", "(", "Game", ".", "getPlayerTurn", "(", "game", ")", ".", "isAi", ")", "{", "lastMove", "=", "game", ".", "moves", ".", "pop", "(", ")", ";", "if", "(", "lastMove", ")", "{", "game", "=", "getGameAfterMove", "(", "game", ",", "getBackMove", "(", "lastMove", ")", ",", "true", ")", ";", "}", "}", "return", "game", ";", "}" ]

[ "Get", "game", "before", "last", "move", "if", "playing", "vs", "Ai", "rollback", "Ai", "move", "too", "." ]

[ "function", "(", "config", ")", "{", "/**\n * The iterator function, which is called on each component.\n *\n * @param {string} version the version of the component\n * @param {string} component the name of the component\n * @return {undefined}\n */", "return", "function", "(", "version", ",", "component", ")", "{", "var", "dep", "=", "config", ".", "get", "(", "'global-dependencies'", ")", ".", "get", "(", "component", ")", "||", "{", "main", ":", "''", ",", "type", ":", "''", ",", "name", ":", "''", ",", "dependencies", ":", "{", "}", "}", ";", "console", ".", "log", "(", "version", ",", "component", ")", ";", "var", "componentConfigFile", "=", "findComponentConfigFile", "(", "config", ",", "component", ")", ";", "var", "warnings", "=", "config", ".", "get", "(", "'warnings'", ")", ";", "var", "overrides", "=", "config", ".", "get", "(", "'overrides'", ")", ";", "if", "(", "overrides", "&&", "overrides", "[", "component", "]", ")", "{", "if", "(", "overrides", "[", "component", "]", ".", "dependencies", ")", "{", "componentConfigFile", ".", "dependencies", "=", "overrides", "[", "component", "]", ".", "dependencies", ";", "}", "if", "(", "overrides", "[", "component", "]", ".", "main", ")", "{", "componentConfigFile", ".", "main", "=", "overrides", "[", "component", "]", ".", "main", ";", "}", "}", "var", "mains", "=", "findMainFiles", "(", "config", ",", "component", ",", "componentConfigFile", ")", ";", "var", "fileTypes", "=", "_", ".", "chain", "(", "mains", ")", ".", "map", "(", "path", ".", "extname", ")", ".", "unique", "(", ")", ".", "value", "(", ")", ";", "dep", ".", "main", "=", "mains", ";", "dep", ".", "type", "=", "fileTypes", ";", "dep", ".", "name", "=", "componentConfigFile", ".", "name", ";", "var", "depIsExcluded", "=", "_", ".", "find", "(", "config", ".", "get", "(", "'exclude'", ")", ",", "function", "(", "pattern", ")", "{", "return", "path", ".", "join", "(", "config", ".", "get", "(", "'bower-directory'", ")", ",", "component", ")", ".", "match", "(", "pattern", ")", ";", "}", ")", ";", "if", "(", "dep", ".", "main", ".", "length", "===", "0", "&&", "!", "depIsExcluded", ")", "{", "// can't find the main file. this config file is useless!", "warnings", ".", "push", "(", "component", "+", "' was not injected in your file.'", ")", ";", "warnings", ".", "push", "(", "'Please go take a look in \"'", "+", "path", ".", "join", "(", "config", ".", "get", "(", "'bower-directory'", ")", ",", "component", ")", "+", "'\" for the file you need, then manually include it in your file.'", ")", ";", "config", ".", "set", "(", "'warnings'", ",", "warnings", ")", ";", "return", ";", "}", "if", "(", "componentConfigFile", ".", "dependencies", ")", "{", "dep", ".", "dependencies", "=", "componentConfigFile", ".", "dependencies", ";", "_", ".", "each", "(", "componentConfigFile", ".", "dependencies", ",", "gatherInfo", "(", "config", ")", ")", ";", "}", "config", ".", "get", "(", "'global-dependencies'", ")", ".", "set", "(", "component", ",", "dep", ")", ";", "}", ";", "}" ]

[ "Store", "the", "information", "our", "prioritizer", "will", "need", "to", "determine", "rank", "." ]

[ "function", "(", "a", ",", "b", ")", "{", "var", "aNeedsB", "=", "false", ";", "var", "bNeedsA", "=", "false", ";", "aNeedsB", "=", "Object", ".", "keys", "(", "a", ".", "dependencies", ")", ".", "some", "(", "function", "(", "dependency", ")", "{", "return", "dependency", "===", "b", ".", "name", ";", "}", ")", ";", "if", "(", "aNeedsB", ")", "{", "return", "1", ";", "}", "bNeedsA", "=", "Object", ".", "keys", "(", "b", ".", "dependencies", ")", ".", "some", "(", "function", "(", "dependency", ")", "{", "return", "dependency", "===", "a", ".", "name", ";", "}", ")", ";", "if", "(", "bNeedsA", ")", "{", "return", "-", "1", ";", "}", "return", "0", ";", "}" ]

[ "Compare", "two", "dependencies", "to", "determine", "priority", "." ]

[ "function", "(", "left", ",", "right", ")", "{", "var", "result", "=", "[", "]", ";", "var", "leftIndex", "=", "0", ";", "var", "rightIndex", "=", "0", ";", "while", "(", "leftIndex", "<", "left", ".", "length", "&&", "rightIndex", "<", "right", ".", "length", ")", "{", "if", "(", "dependencyComparator", "(", "left", "[", "leftIndex", "]", ",", "right", "[", "rightIndex", "]", ")", "<", "1", ")", "{", "result", ".", "push", "(", "left", "[", "leftIndex", "++", "]", ")", ";", "}", "else", "{", "result", ".", "push", "(", "right", "[", "rightIndex", "++", "]", ")", ";", "}", "}", "return", "result", ".", "concat", "(", "left", ".", "slice", "(", "leftIndex", ")", ")", ".", "concat", "(", "right", ".", "slice", "(", "rightIndex", ")", ")", ";", "}" ]

[ "Take", "two", "arrays", "sort", "based", "on", "their", "dependency", "relationship", "then", "merge", "them", "together", "." ]

[ "function", "(", "items", ")", "{", "if", "(", "items", ".", "length", "<", "2", ")", "{", "return", "items", ";", "}", "var", "middle", "=", "Math", ".", "floor", "(", "items", ".", "length", "/", "2", ")", ";", "return", "merge", "(", "mergeSort", "(", "items", ".", "slice", "(", "0", ",", "middle", ")", ")", ",", "mergeSort", "(", "items", ".", "slice", "(", "middle", ")", ")", ")", ";", "}" ]

[ "Take", "an", "array", "and", "slice", "it", "in", "halves", "sorting", "each", "half", "along", "the", "way", "." ]

[ "function", "(", "allDependencies", ",", "patterns", ")", "{", "return", "_", ".", "transform", "(", "allDependencies", ",", "function", "(", "result", ",", "dependencies", ",", "fileType", ")", "{", "result", "[", "fileType", "]", "=", "_", ".", "reject", "(", "dependencies", ",", "function", "(", "dependency", ")", "{", "return", "_", ".", "find", "(", "patterns", ",", "function", "(", "pattern", ")", "{", "return", "dependency", ".", "match", "(", "pattern", ")", ";", "}", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Excludes", "dependencies", "that", "match", "any", "of", "the", "patterns", "." ]

[ "function", "proxy", "(", "original", ",", "routes", ")", "{", "return", "new", "Proxy", "(", "original", ",", "{", "get", "(", "target", ",", "key", ",", "receiver", ")", "{", "const", "method", "=", "target", "[", "key", "]", "if", "(", "method", ")", "return", "method", "else", "return", "function", "(", "path", ",", "...", "args", ")", "{", "const", "cb", "=", "args", "[", "0", "]", "if", "(", "typeof", "cb", "===", "'function'", ")", "{", "original", ".", "add", "(", "key", ",", "path", ",", "cb", ")", "}", "else", "{", "const", "fn", "=", "routes", "[", "key", "]", "return", "fn", "&&", "fn", ".", "exec", "(", "path", ",", "...", "args", ")", "}", "}", "}", "}", ")", "}" ]

[ "Proxy", "function", "with", "router", "." ]

[ "function", "gen", "(", "path", ")", "{", "var", "option", "=", "arguments", ".", "length", ">", "1", "&&", "arguments", "[", "1", "]", "!==", "undefined", "?", "arguments", "[", "1", "]", ":", "{", "}", ";", "var", "config", "=", "assignConfig_1", ".", "default", "(", "option", ",", "path", ")", ";", "return", "globElements_1", ".", "default", "(", "config", ")", ".", "then", "(", "readElements_1", ".", "default", "(", "config", ")", ")", ".", "then", "(", "optimize_1", ".", "default", "(", ")", ")", ".", "then", "(", "render_1", ".", "default", "(", "config", ")", ")", ";", "}" ]

[ "Generate", "guide", "page", "from", "elements" ]

[ "function", "toStriderProxy", "(", "instance", ")", "{", "debug", "(", "`", "${", "instance", ".", "constructor", ".", "name", "}", "`", ")", ";", "const", "functionsInInstance", "=", "Object", ".", "getOwnPropertyNames", "(", "Object", ".", "getPrototypeOf", "(", "instance", ")", ")", ".", "filter", "(", "propertyName", "=>", "{", "return", "typeof", "instance", "[", "propertyName", "]", "===", "'function'", "&&", "propertyName", "!==", "'constructor'", ";", "}", ")", ";", "functionsInInstance", ".", "forEach", "(", "functionInInstance", "=>", "{", "instance", "[", "`", "${", "functionInInstance", "}", "`", "]", "=", "instance", "[", "functionInInstance", "]", ";", "instance", "[", "functionInInstance", "]", "=", "function", "(", ")", "{", "const", "args", "=", "Array", ".", "from", "(", "arguments", ")", ";", "const", "done", "=", "args", ".", "pop", "(", ")", ";", "return", "instance", "[", "`", "${", "functionInInstance", "}", "`", "]", ".", "apply", "(", "instance", ",", "args", ")", ".", "then", "(", "result", "=>", "done", "(", "null", ",", "result", ")", ")", ".", "catch", "(", "errors", ".", "ExtensionConfigurationError", ",", "error", "=>", "{", "debug", "(", "`", "${", "error", ".", "message", "}", "`", "||", "error", ".", "info", ")", ";", "return", "done", "(", "error", ")", ";", "}", ")", ".", "catch", "(", "error", "=>", "done", "(", "error", ")", ")", ";", "}", ";", "Object", ".", "defineProperty", "(", "instance", "[", "functionInInstance", "]", ",", "'length'", ",", "{", "value", ":", "instance", "[", "`", "${", "functionInInstance", "}", "`", "]", ".", "length", "}", ")", ";", "}", ")", ";", "return", "instance", ";", "}" ]

[ "Given", "an", "input", "object", "replaces", "all", "functions", "on", "that", "object", "with", "node", "-", "style", "callback", "equivalents", ".", "The", "methods", "are", "expected", "to", "return", "promises", ".", "It", "s", "kind", "of", "like", "a", "reverse", "-", "promisifyAll", ".", "The", "original", "methods", "are", "available", "by", "their", "old", "name", "with", "Async", "appended", "." ]

[ "function", "(", "inShowing", ")", "{", "if", "(", "inShowing", "&&", "inShowing", "!=", "this", ".", "showing", ")", "{", "if", "(", "this", ".", "scrollBounds", "[", "this", ".", "sizeDimension", "]", ">=", "this", ".", "scrollBounds", "[", "this", ".", "dimension", "]", ")", "{", "return", ";", "}", "}", "if", "(", "this", ".", "hasNode", "(", ")", ")", "{", "this", ".", "cancelDelayHide", "(", ")", ";", "}", "if", "(", "inShowing", "!=", "this", ".", "showing", ")", "{", "var", "last", "=", "this", ".", "showing", ";", "this", ".", "showing", "=", "inShowing", ";", "this", ".", "showingChanged", "(", "last", ")", ";", "}", "}" ]

[ "implement", "set", "because", "showing", "is", "not", "changed", "while", "we", "delayHide", "but", "we", "want", "to", "cancel", "the", "hide", "." ]

[ "function", "extend", "(", "obj", ")", "{", "var", "slice", "=", "Array", ".", "prototype", ".", "slice", ";", "slice", ".", "call", "(", "arguments", ",", "1", ")", ".", "forEach", "(", "function", "(", "source", ")", "{", "var", "getter", ",", "setter", ";", "for", "(", "var", "key", "in", "source", ")", "{", "getter", "=", "source", ".", "__lookupGetter__", "(", "key", ")", ";", "setter", "=", "source", ".", "__lookupSetter__", "(", "key", ")", ";", "if", "(", "getter", "||", "setter", ")", "{", "getter", "&&", "obj", ".", "__defineGetter__", "(", "key", ",", "getter", ")", ";", "setter", "&&", "obj", ".", "__defineSetter__", "(", "key", ",", "setter", ")", ";", "}", "else", "{", "obj", "[", "key", "]", "=", "source", "[", "key", "]", ";", "}", "}", "}", ")", ";", "return", "obj", ";", "}" ]

[ "roll", "custom", "extend", "since", "underscore", "s", "doesn", "t", "play", "nice", "with", "getters", "and", "setters" ]

[ "function", "setCursorDeadAndNotified", "(", "cursor", ",", "callback", ")", "{", "cursor", ".", "s", ".", "dead", "=", "true", ";", "setCursorNotified", "(", "cursor", ",", "callback", ")", ";", "}" ]

[ "Mark", "cursor", "as", "being", "dead", "and", "notified" ]

[ "function", "RTCOutboundRTPStreamStats", "(", "rTCOutboundRTPStreamStatsDict", ")", "{", "if", "(", "!", "(", "this", "instanceof", "RTCOutboundRTPStreamStats", ")", ")", "return", "new", "RTCOutboundRTPStreamStats", "(", "rTCOutboundRTPStreamStatsDict", ")", "// Check rTCOutboundRTPStreamStatsDict has the required fields", "checkType", "(", "'int'", ",", "'rTCOutboundRTPStreamStatsDict.packetsSent'", ",", "rTCOutboundRTPStreamStatsDict", ".", "packetsSent", ",", "{", "required", ":", "true", "}", ")", ";", "checkType", "(", "'int'", ",", "'rTCOutboundRTPStreamStatsDict.bytesSent'", ",", "rTCOutboundRTPStreamStatsDict", ".", "bytesSent", ",", "{", "required", ":", "true", "}", ")", ";", "checkType", "(", "'float'", ",", "'rTCOutboundRTPStreamStatsDict.targetBitrate'", ",", "rTCOutboundRTPStreamStatsDict", ".", "targetBitrate", ",", "{", "required", ":", "true", "}", ")", ";", "checkType", "(", "'float'", ",", "'rTCOutboundRTPStreamStatsDict.roundTripTime'", ",", "rTCOutboundRTPStreamStatsDict", ".", "roundTripTime", ",", "{", "required", ":", "true", "}", ")", ";", "// Init parent class", "RTCOutboundRTPStreamStats", ".", "super_", ".", "call", "(", "this", ",", "rTCOutboundRTPStreamStatsDict", ")", "// Set object properties", "Object", ".", "defineProperties", "(", "this", ",", "{", "packetsSent", ":", "{", "writable", ":", "true", ",", "enumerable", ":", "true", ",", "value", ":", "rTCOutboundRTPStreamStatsDict", ".", "packetsSent", "}", ",", "bytesSent", ":", "{", "writable", ":", "true", ",", "enumerable", ":", "true", ",", "value", ":", "rTCOutboundRTPStreamStatsDict", ".", "bytesSent", "}", ",", "targetBitrate", ":", "{", "writable", ":", "true", ",", "enumerable", ":", "true", ",", "value", ":", "rTCOutboundRTPStreamStatsDict", ".", "targetBitrate", "}", ",", "roundTripTime", ":", "{", "writable", ":", "true", ",", "enumerable", ":", "true", ",", "value", ":", "rTCOutboundRTPStreamStatsDict", ".", "roundTripTime", "}", "}", ")", "}" ]

[ "Statistics", "that", "represents", "the", "measurement", "metrics", "for", "the", "outgoing", "media", "stream", "." ]

[ "function", "inverse", "(", "matrix", ")", "{", "//http://www.wolframalpha.com/input/?i=Inverse+%5B%7B%7Ba,c,e%7D,%7Bb,d,f%7D,%7B0,0,1%7D%7D%5D", "var", "a", "=", "matrix", ".", "a", ",", "b", "=", "matrix", ".", "b", ",", "c", "=", "matrix", ".", "c", ",", "d", "=", "matrix", ".", "d", ",", "e", "=", "matrix", ".", "e", ",", "f", "=", "matrix", ".", "f", ";", "var", "denom", "=", "a", "*", "d", "-", "b", "*", "c", ";", "return", "{", "a", ":", "d", "/", "denom", ",", "b", ":", "b", "/", "-", "denom", ",", "c", ":", "c", "/", "-", "denom", ",", "d", ":", "a", "/", "denom", ",", "e", ":", "(", "d", "*", "e", "-", "c", "*", "f", ")", "/", "-", "denom", ",", "f", ":", "(", "b", "*", "e", "-", "a", "*", "f", ")", "/", "denom", "}", ";", "}" ]

[ "Calculate", "a", "matrix", "that", "is", "the", "inverse", "of", "the", "provided", "matrix" ]

[ "function", "curry", "(", "fn", ",", "obj", ")", "{", "// create a local copy of the function. don't apply anything yet", "// optionally bind an object to the `this` of the function.", "var", "newFunction", "=", "_", ".", "bind", "(", "fn", ",", "(", "obj", "||", "null", ")", ")", ";", "// curried functions always take one argument", "return", "function", "(", ")", "{", "// create another copy of the function with the arguments applied", "var", "me", "=", "_", ".", "partial", "(", "newFunction", ",", "arguments", ")", ";", "// take advantage of the fact that bind changes the method signature:", "// if we have no arguments left, run the method", "if", "(", "!", "me", ".", "length", ")", "return", "me", "(", ")", ";", "// otherwise, curry again and return that.", "return", "curry", "(", "me", ")", ";", "}", ";", "}" ]

[ "this", "takes", "advantage", "of", "ES5", "bind", "s", "awesome", "ability", "to", "do", "partial", "application" ]

[ "function", "(", "o", ",", "path", ")", "{", "function", "iterator", "(", "m", ",", "p", ")", "{", "return", "_", ".", "getv", "(", "p", ")", "(", "m", ")", ";", "}", "return", "_", ".", "reduce", "(", "path", ",", "iterator", ",", "o", ")", ";", "}" ]

[ "perform", "a", "root", "canal", "on", "an", "object", ".", "depends", "on", "getv" ]

[ "function", "(", "a", ")", "{", "var", "elements", "=", "_", ".", "reject", "(", "_", ".", "rest", "(", "arguments", ")", ",", "_", ".", "isMissing", ")", ";", "return", "a", ".", "push", ".", "apply", "(", "a", ",", "elements", ")", ";", "}" ]

[ "push", "only", "defined", "elements", "to", "the", "array" ]

[ "function", "(", "opts", ")", "{", "var", "opts", "=", "opts", "||", "{", "}", ";", "var", "shouldHash", "=", "typeof", "opts", ".", "hash", "!=", "'undefined'", "?", "opts", ".", "hash", ":", "defaults", ".", "hash", ";", "var", "prefix", "=", "_", ".", "flatten", "(", "[", "defaults", ".", "prefix", "]", ")", ";", "var", "shouldPrefix", "=", "typeof", "opts", ".", "shouldPrefix", "!=", "'undefined'", "?", "opts", ".", "shouldPrefix", ":", "true", ";", "return", "through", ".", "obj", "(", "function", "(", "file", ",", "enc", ",", "cb", ")", "{", "var", "originalPath", "=", "file", ".", "path", ";", "// Get hash of contents", "var", "hash", "=", "md5", "(", "opts", ",", "file", ".", "contents", ".", "toString", "(", ")", ")", ";", "// Construct new filename", "var", "ext", "=", "path", ".", "extname", "(", "file", ".", "path", ")", ";", "var", "basePath", "=", "path", ".", "basename", "(", "file", ".", "path", ",", "ext", ")", ";", "var", "filename", "=", "typeof", "hash", "!==", "'undefined'", "?", "basePath", "+", "'-'", "+", "hash", "+", "ext", ":", "basePath", "+", "ext", ";", "file", ".", "path", "=", "path", ".", "join", "(", "path", ".", "dirname", "(", "file", ".", "path", ")", ",", "filename", ")", ";", "// Add to manifest", "var", "base", "=", "path", ".", "join", "(", "file", ".", "cwd", ",", "defaults", ".", "src", ")", ";", "var", "key", "=", "originalPath", ".", "replace", "(", "base", ",", "''", ")", ";", "// @TODO: Instead of this it could use \"glob\" module to regex delete files", "// Check for existing value and whether cleanup is set", "var", "existing", "=", "manifest", "[", "key", "]", ";", "if", "(", "existing", "&&", "existing", ".", "src", "&&", "defaults", ".", "cleanup", ")", "{", "// Delete the file", "fs", ".", "unlink", "(", "path", ".", "join", "(", "file", ".", "cwd", ",", "defaults", ".", "dest", ",", "existing", ".", "src", ")", ")", ";", "}", "else", "if", "(", "defaults", ".", "cleanup", "&&", "shouldHash", ")", "{", "// Check if cleanup and hash enabled then we can remove any non hashed version from dest directory", "var", "nonHashPath", "=", "path", ".", "join", "(", "path", ".", "dirname", "(", "originalPath", ")", ",", "basePath", "+", "ext", ")", ".", "replace", "(", "base", ",", "''", ")", ";", "var", "absPath", "=", "path", ".", "join", "(", "file", ".", "cwd", ",", "defaults", ".", "dest", ",", "nonHashPath", ")", ";", "fs", ".", "exists", "(", "absPath", ",", "function", "(", "exists", ")", "{", "if", "(", "!", "exists", ")", "return", ";", "fs", ".", "unlink", "(", "absPath", ")", ";", "}", ")", ";", "}", "var", "filePrefix", "=", "shouldPrefix", "?", "prefix", "[", "index", "%", "prefix", ".", "length", "]", ":", "''", ";", "// Finally add new value to manifest", "var", "src", "=", "file", ".", "path", ".", "replace", "(", "base", ",", "''", ")", ";", "manifest", "[", "key", "]", "=", "{", "index", ":", "index", "++", ",", "src", ":", "src", ",", "dest", ":", "filePrefix", "+", "src", "}", ";", "// Write manifest file", "writeManifest", "(", ")", ";", "// Return and continue", "this", ".", "push", "(", "file", ")", ";", "cb", "(", ")", ";", "}", ")", ";", "}" ]

[ "Gets", "md5", "from", "file", "contents", "and", "writes", "new", "filename", "with", "hash", "included", "to", "destinations" ]

[ "function", "validateValue", "(", "key", ",", "valObj", ",", "list", ")", "{", "let", "type", ";", "let", "valid", ";", "let", "range", ";", "let", "regex", ";", "const", "object", "=", "list", "[", "key", "]", ";", "const", "val", "=", "hasKey", "(", "valObj", ",", "key", ")", "?", "valObj", "[", "key", "]", ":", "'value_not_defined'", ";", "let", "defaultValue", "=", "object", ";", "if", "(", "object", ")", "{", "type", "=", "object", ".", "type", ";", "valid", "=", "object", ".", "valid", ";", "range", "=", "object", ".", "range", ";", "regex", "=", "object", ".", "regex", ";", "defaultValue", "=", "hasKey", "(", "object", ",", "'default'", ")", "?", "object", ".", "default", ":", "object", ";", "}", "if", "(", "isDeclared", "(", "val", ")", ")", "{", "return", "defaultValue", ";", "}", "if", "(", "isMatch", "(", "key", ",", "val", ",", "regex", ")", ")", "{", "return", "val", ";", "}", "if", "(", "isValid", "(", "key", ",", "val", ",", "valid", ",", "type", ")", ")", "{", "return", "val", ";", "}", "isType", "(", "key", ",", "val", ",", "type", ")", ";", "inRange", "(", "key", ",", "val", ",", "range", ")", ";", "return", "val", ";", "}" ]

[ "Checks", "if", "a", "value", "fits", "the", "restrictions", "." ]

[ "function", "classes", "(", "input", ")", "{", "if", "(", "!", "input", ")", "return", "[", "]", ";", "assert", ".", "strictEqual", "(", "typeof", "input", ",", "'string'", ",", "'expected a string for the class name'", ")", ";", "if", "(", "!", "input", ".", "trim", "(", ")", ")", "return", "[", "]", ";", "return", "input", ".", "trim", "(", ")", ".", "split", "(", "/", "\\s+", "/", "g", ")", ";", "}" ]

[ "private", "helpers", "Parse", "the", "given", "input", "into", "an", "Array", "of", "class", "names", ".", "Will", "always", "return", "an", "Array", "even", "if", "it", "s", "empty", "." ]

[ "function", "deepChild", "(", "root", ",", "path", ")", "{", "return", "path", ".", "reduce", "(", "function", "(", "node", ",", "index", ",", "x", ")", "{", "assert", "(", "index", "in", "node", ".", "children", ",", "'child does not exist at the given deep index '", "+", "path", ".", "join", "(", "'.'", ")", ")", ";", "return", "node", ".", "children", "[", "index", "]", ";", "}", ",", "root", ")", ";", "}" ]

[ "Retrieve", "a", "deep", "child", "via", "an", "input", "array", "index", "of", "indices", "to", "traverse", "." ]

[ "function", "handler", "(", "err", ",", "data", ")", "{", "if", "(", "callback", "!=", "null", ")", "{", "callback", ".", "apply", "(", "b9", ",", "arguments", ")", ";", "}", "// only emit events when there is no error", "if", "(", "err", "==", "null", ")", "{", "b9", ".", "emit", ".", "call", "(", "b9", ",", "method", ",", "data", ")", ";", "}", "}" ]

[ "wrap", "callback", "with", "an", "event", "emitter" ]

[ "function", "Service", "(", "manager", ",", "name", ",", "port", ",", "heartbeat", ")", "{", "var", "_name", "=", "name", ";", "/**\n * @property {String} name The name of the service\n */", "Object", ".", "defineProperty", "(", "this", ",", "'name'", ",", "{", "get", ":", "function", "get", "(", ")", "{", "return", "_name", ";", "}", ",", "enumerable", ":", "true", "}", ")", ";", "var", "_port", "=", "port", ";", "/**\n * @property {Number} port The port claimed by the service\n */", "Object", ".", "defineProperty", "(", "this", ",", "'port'", ",", "{", "get", ":", "function", "get", "(", ")", "{", "return", "_port", ";", "}", ",", "enumerable", ":", "true", "}", ")", ";", "var", "_heartbeatInterval", ";", "if", "(", "heartbeat", "!==", "0", ")", "{", "debug", "(", "'set heartbeat %d'", ",", "heartbeat", ")", ";", "_heartbeatInterval", "=", "setInterval", "(", "heartbeatTest", ".", "call", "(", "this", ",", "manager", ")", ",", "heartbeat", ")", ";", "}", "/**\n * @property {Number} heartbeat The heartbeat counter for the periodic port checking\n */", "Object", ".", "defineProperty", "(", "this", ",", "'heartbeat'", ",", "{", "get", ":", "function", "get", "(", ")", "{", "return", "_heartbeatInterval", ";", "}", "}", ")", ";", "}" ]

[ "The", "service", "to", "manage" ]

[ "function", "(", "docs", ",", "callback", ")", "{", "remaining", "=", "docs", ";", "console", ".", "log", "(", "'[ remove ] info: '", "+", "remaining", "+", "' to remove.'", ")", ";", "async", ".", "eachLimit", "(", "_", ".", "range", "(", "0", ",", "docs", ",", "10000", ")", ",", "1", ",", "handleOneBlock", ",", "callback", ")", ";", "}" ]

[ "fetch", "the", "removeView", "list", ";", "returns", "array", "of", "objects", "marked", "_deleted" ]

[ "function", "(", "teamId", ",", "req", ")", "{", "const", "favoritesList", "=", "req", ".", "app", ".", "locals", ".", "favoritesList", "const", "index", "=", "favoritesList", ".", "findIndex", "(", "t", "=>", "t", ".", "id", "==", "teamId", ")", "if", "(", "index", "<", "0", ")", "{", "const", "err", "=", "new", "Error", "(", "'Team is not parte of Favorites!!!'", ")", "err", ".", "status", "=", "409", "throw", "err", "}", "favoritesList", ".", "splice", "(", "index", ",", "1", ")", "}" ]

[ "This", "is", "a", "synchronous", "action", "that", "does", "not", "do", "any", "IO", ".", "Simply", "returning", "with", "NO", "exceptions", "just", "means", "success", "and", "connect", "-", "controller", "will", "send", "a", "200", "response", "status", "." ]

[ "function", "click", "(", "target", ",", "handler", ")", "{", "target", ".", "addEventListener", "(", "\"click\"", ",", "function", "(", "evt", ")", "{", "evt", ".", "stopPropagation", "(", ")", ";", "evt", ".", "preventDefault", "(", ")", ";", "handler", ".", "call", "(", "this", ")", ";", "}", ")", ";", "}" ]

[ "Attach", "click", "event", "handler", "." ]

[ "function", "(", "name", ",", "method", ")", "{", "API", ".", "prototype", "[", "name", "]", "=", "function", "(", ")", "{", "var", "api", "=", "this", ";", "var", "args", "=", "Array", ".", "prototype", ".", "slice", ".", "call", "(", "arguments", ")", ";", "this", ".", "chain", "(", "function", "(", "next", ")", "{", "var", "cargs", "=", "[", "]", ".", "slice", ".", "call", "(", "arguments", ")", ";", "cargs", "=", "args", ".", "concat", "(", "cargs", ")", ";", "// args.push(next);", "method", ".", "apply", "(", "api", ",", "cargs", ")", ";", "}", ")", ";", "return", "this", ";", "}", ";", "return", "this", ";", "}" ]

[ "add", "a", "method", "to", "the", "prototype" ]

[ "function", "(", "err", ")", "{", "if", "(", "err", ")", "this", ".", "_onError", "(", "err", ")", ";", "if", "(", "this", ".", "_continueErrors", "||", "!", "err", ")", "{", "var", "args", "=", "[", "]", ".", "slice", ".", "call", "(", "arguments", ")", ";", "if", "(", "this", ".", "_callbacks", ".", "length", ">", "0", ")", "{", "this", ".", "_isQueueRunning", "=", "true", ";", "var", "cb", "=", "this", ".", "_callbacks", ".", "shift", "(", ")", ";", "cb", "=", "cb", ".", "bind", "(", "this", ")", ";", "args", "=", "args", ".", "slice", "(", "1", ")", ";", "args", ".", "push", "(", "this", ".", "next", ")", ";", "cb", ".", "apply", "(", "this", ",", "args", ")", ";", "}", "else", "{", "this", ".", "_isQueueRunning", "=", "false", ";", "this", ".", "start", "=", "(", "function", "(", ")", "{", "this", ".", "start", "=", "null", ";", "this", ".", "next", ".", "apply", "(", "this", ",", "args", ")", ";", "}", ")", ".", "bind", "(", "this", ")", ";", "}", "}", "return", "this", ";", "}" ]

[ "advance", "to", "next", "cb" ]

[ "function", "(", "name", ",", "value", ",", "immediate", ")", "{", "if", "(", "immediate", ")", "{", "this", "[", "name", "]", "=", "value", ";", "}", "else", "this", ".", "chain", "(", "function", "(", ")", "{", "var", "args", "=", "Array", ".", "prototype", ".", "slice", ".", "call", "(", "arguments", ")", ";", "var", "next", "=", "args", ".", "pop", "(", ")", ";", "this", "[", "name", "]", "=", "value", ";", "args", ".", "unshift", "(", "null", ")", ";", "next", ".", "apply", "(", "this", ",", "args", ")", ";", "}", ")", ";", "return", "this", ";", "}" ]

[ "set", "instance", "property" ]

[ "function", "(", "cb", ")", "{", "cb", "=", "this", ".", "wrap", "(", "cb", ")", ";", "this", ".", "_callbacks", ".", "push", "(", "cb", ")", ";", "if", "(", "!", "this", ".", "_isQueueRunning", ")", "{", "if", "(", "this", ".", "start", ")", "{", "this", ".", "start", "(", ")", ";", "}", "else", "this", ".", "next", "(", ")", ";", "// this.start();", "}", "return", "this", ";", "}" ]

[ "add", "a", "callback", "to", "the", "execution", "chain" ]

[ "function", "parallel", "(", "promises", ",", "limit", ")", "{", "var", "d", "=", "Q", ".", "defer", "(", ")", ";", "var", "total", "=", "promises", ".", "length", ";", "var", "results", "=", "new", "Array", "(", "total", ")", ";", "var", "firstErr", ";", "var", "running", "=", "0", ";", "var", "finished", "=", "0", ";", "var", "next", "=", "0", ";", "limit", "=", "limit", "||", "total", ";", "function", "sched", "(", ")", "{", "while", "(", "next", "<", "total", "&&", "running", "<", "limit", ")", "{", "DEBUG", "&&", "debug", "(", "'*** sched #'", ",", "next", ",", "'***'", ",", "promises", "[", "next", "]", ".", "inspect", "(", ")", ")", ";", "exec", "(", "next", "++", ")", ";", "}", "}", "function", "exec", "(", "id", ")", "{", "running", "+=", "1", ";", "var", "promise", "=", "promises", "[", "id", "]", ";", "DEBUG", "&&", "debug", "(", "'>>> running'", ",", "running", ")", ";", "DEBUG", "&&", "debug", "(", "'*** run #'", ",", "id", ",", "'***'", ",", "promise", ".", "inspect", "(", ")", ")", ";", "promise", ".", "then", "(", "function", "(", "result", ")", "{", "DEBUG", "&&", "debug", "(", "'#'", ",", "id", ",", "'then ***'", ",", "result", ")", ";", "results", "[", "id", "]", "=", "result", ";", "// collect all result", "d", ".", "notify", "(", "promise", ".", "inspect", "(", ")", ")", ";", "}", ")", ".", "catch", "(", "function", "(", "err", ")", "{", "DEBUG", "&&", "debug", "(", "'#'", ",", "id", ",", "'catch ***'", ",", "err", ")", ";", "firstErr", "=", "firstErr", "||", "err", ";", "// keep the first error", "}", ")", ".", "finally", "(", "function", "(", ")", "{", "DEBUG", "&&", "debug", "(", "'#'", ",", "id", ",", "'finally ***'", ",", "promise", ".", "inspect", "(", ")", ")", ";", "if", "(", "++", "finished", "===", "total", ")", "{", "DEBUG", "&&", "debug", "(", "'>>> finished all ***'", ",", "firstErr", ",", "results", ")", ";", "return", "firstErr", "?", "d", ".", "reject", "(", "firstErr", ")", ":", "d", ".", "resolve", "(", "results", ")", ";", "}", "DEBUG", "&&", "debug", "(", "'>>> finished'", ",", "finished", ")", ";", "running", "-=", "1", ";", "sched", "(", ")", ";", "}", ")", ";", "}", "sched", "(", ")", ";", "return", "d", ".", "promise", ";", "}" ]

[ "!!debug", ".", "enabled", ";" ]

[ "function", "addCommand", "(", "descriptor", ")", "{", "// Check descriptor type.", "var", "err", "=", "{", "}", ";", "if", "(", "!", "checkDescriptor", "(", "descriptor", ",", "err", ")", ")", "{", "logger", ".", "error", "(", "'The command descriptor is invalid.'", ",", "new", "Error", "(", "'[command.io] Invalid command descriptor (\"'", "+", "err", ".", "key", "+", "'\": expected \"'", "+", "err", ".", "expect", "+", "'\", have \"'", "+", "err", ".", "type", "+", "'\").'", ")", ")", ";", "logger", ".", "error", "(", "'Please check this doc: https://github.com/Techniv/node-command-io/wiki/Command-descriptor-refactoring'", ")", ";", "return", "module", ".", "exports", ";", "}", "var", "name", "=", "descriptor", ".", "name", ";", "descriptor", ".", "controller", "=", "new", "CommandController", "(", "descriptor", ")", ";", "// Index the command descriptor", "commandDescriptors", "[", "name", "]", "=", "descriptor", ";", "// Chain addCommand", "return", "module", ".", "exports", ";", "}" ]

[ "Add", "a", "command" ]

[ "function", "addCommands", "(", "commands", ")", "{", "for", "(", "var", "i", "in", "commands", ")", "{", "var", "commandObj", "=", "commands", "[", "i", "]", ";", "addCommand", "(", "commandObj", ")", ";", "}", "return", "module", ".", "exports", ";", "}" ]

[ "Add", "commands", "recursively", "." ]

[ "function", "CommandController", "(", "descriptor", ")", "{", "Object", ".", "defineProperties", "(", "this", ",", "{", "name", ":", "{", "get", ":", "function", "(", ")", "{", "return", "descriptor", ".", "name", ";", "}", "}", ",", "description", ":", "{", "get", ":", "function", "(", ")", "{", "return", "descriptor", ".", "description", ";", "}", "}", ",", "CommandError", ":", "{", "get", ":", "function", "(", ")", "{", "return", "LocalCommandError", ";", "}", "}", ",", "RuntimeCommandError", ":", "{", "get", ":", "function", "(", ")", "{", "return", "LocalRuntimeCommandError", ";", "}", "}", ",", "errorLvl", ":", "{", "get", ":", "function", "(", ")", "{", "return", "Object", ".", "create", "(", "CONST", ".", "errorLvl", ")", ";", "}", "}", "}", ")", ";", "function", "LocalCommandError", "(", "message", ",", "level", ")", "{", "CommandError", ".", "call", "(", "this", ",", "message", ",", "descriptor", ".", "name", ",", "level", ")", ";", "}", "LocalCommandError", ".", "prototype", "=", "Object", ".", "create", "(", "CommandError", ".", "prototype", ")", ";", "function", "LocalRuntimeCommandError", "(", "message", ")", "{", "RuntimeCommandError", ".", "call", "(", "this", ",", "message", ",", "descriptor", ".", "name", ")", ";", "}", "LocalRuntimeCommandError", ".", "prototype", "=", "Object", ".", "create", "(", "RuntimeCommandError", ".", "prototype", ")", ";", "}" ]

[ "CommandIO", "API", "to", "command", "action", "." ]

[ "function", "checkDescriptor", "(", "descriptor", ",", "err", ")", "{", "if", "(", "typeof", "descriptor", "!=", "'object'", ")", "return", "false", ";", "for", "(", "var", "key", "in", "CONST", ".", "descriptorType", ")", "{", "if", "(", "!", "checkType", "(", "descriptor", "[", "key", "]", ",", "CONST", ".", "descriptorType", "[", "key", "]", ")", ")", "{", "err", ".", "key", "=", "key", ";", "err", ".", "expect", "=", "CONST", ".", "descriptorType", "[", "key", "]", ";", "err", ".", "type", "=", "typeof", "descriptor", "[", "key", "]", ";", "return", "false", ";", "}", "}", "for", "(", "var", "key", "in", "CONST", ".", "descriptorOptType", ")", "{", "if", "(", "typeof", "descriptor", "[", "key", "]", "!=", "'undefined'", "&&", "checkType", "(", "descriptor", "[", "key", "]", ",", "CONST", ".", "descriptorOptType", "[", "key", "]", ".", "type", ")", ")", "continue", ";", "if", "(", "typeof", "descriptor", "[", "key", "]", "==", "'undefined'", ")", "{", "if", "(", "typeof", "CONST", ".", "descriptorOptType", "[", "key", "]", ".", "value", "!=", "'undefined'", ")", "descriptor", "[", "key", "]", "=", "CONST", ".", "descriptorOptType", "[", "key", "]", ".", "value", ";", "continue", ";", "}", "err", ".", "key", "=", "key", ";", "err", ".", "expect", "=", "CONST", ".", "descriptorOptType", "[", "key", "]", ".", "type", ";", "err", ".", "type", "=", "typeof", "descriptor", "[", "key", "]", ";", "return", "false", ";", "}", "return", "true", ";", "}" ]

[ "Check", "if", "the", "command", "descriptor", "is", "valid", "." ]

[ "function", "CommandError", "(", "message", ",", "command", ",", "level", ")", "{", "var", "that", "=", "this", ",", "error", ";", "// Set the default level.", "if", "(", "isNaN", "(", "level", ")", "||", "level", "<", "1", "||", "level", ">", "3", ")", "level", "=", "CONST", ".", "errorLvl", ".", "error", ";", "// Format the message", "if", "(", "typeof", "command", "==", "'string'", ")", "message", "=", "'{'", "+", "command", "+", "'} '", "+", "message", ";", "message", "=", "'[command.io] '", "+", "message", ";", "// Create the native Error object.", "error", "=", "new", "Error", "(", "message", ")", ";", "// Create the getter for native error properties and custom properties.", "Object", ".", "defineProperties", "(", "this", ",", "{", "'stack'", ":", "{", "get", ":", "function", "(", ")", "{", "return", "error", ".", "stack", ";", "}", "}", ",", "message", ":", "{", "get", ":", "function", "(", ")", "{", "return", "error", ".", "message", ";", "}", "}", ",", "command", ":", "{", "get", ":", "function", "(", ")", "{", "return", "command", ";", "}", "}", ",", "level", ":", "{", "get", ":", "function", "(", ")", "{", "return", "level", ";", "}", "}", "}", ")", ";", "}" ]

[ "ERRORS", "Custom", "error", "object", "to", "manage", "exceptions", "on", "command", "s", "action", "." ]

[ "function", "substitute", "(", "str", ",", "variables", ")", "{", "// Based on Simple JavaScript Templating by", "// John Resig - http://ejohn.org/blog/javascript-micro-templating/ - MIT Licensed", "if", "(", "!", "cache", "[", "str", "]", ")", "{", "// Figure out if we're getting a template, or if we need to", "// load the template - and be sure to cache the result.", "try", "{", "/*jshint -W054 */", "cache", "[", "str", "]", "=", "new", "Function", "(", "\"obj\"", ",", "\"var p=[],print=function(){p.push.apply(p,arguments);};\"", "+", "// Introduce the data as local variables using with(){}", "\"with(obj){p.push('\"", "+", "// Convert the template into pure JavaScript", "str", ".", "replace", "(", "/", "[\\r\\t\\n]", "/", "g", ",", "\" \"", ")", ".", "split", "(", "\"<%\"", ")", ".", "join", "(", "\"\\t\"", ")", ".", "replace", "(", "/", "((^|%>)[^\\t]*)'", "/", "g", ",", "\"$1\\r\"", ")", ".", "replace", "(", "/", "\\t=(.*?)%>", "/", "g", ",", "\"',$1,'\"", ")", ".", "split", "(", "\"\\t\"", ")", ".", "join", "(", "\"');\"", ")", ".", "split", "(", "\"%>\"", ")", ".", "join", "(", "\"p.push('\"", ")", ".", "split", "(", "\"\\r\"", ")", ".", "join", "(", "\"\\\\'\"", ")", "+", "\"');}return p.join('');\"", ")", ";", "/*jshint +W054 */", "}", "catch", "(", "e", ")", "{", "grunt", ".", "fail", ".", "fatal", "(", "\"Failed to compile template:\\n\"", "+", "str", ")", ";", "}", "}", "return", "cache", "[", "str", "]", "(", "variables", "||", "{", "}", ")", ";", "}" ]

[ "Perform", "variable", "substitutions", "in", "the", "template", "." ]

[ "function", "generate", "(", "tmpl", ",", "src", ",", "variables", ")", "{", "variables", "=", "variables", "||", "{", "}", ";", "variables", ".", "FILES", "=", "{", "}", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "src", ".", "length", ";", "i", "++", ")", "{", "var", "content", "=", "JSON", ".", "stringify", "(", "grunt", ".", "file", ".", "read", "(", "src", "[", "i", "]", ")", ")", ";", "variables", ".", "FILES", "[", "src", "[", "i", "]", "]", "=", "content", ";", "}", "var", "template", "=", "grunt", ".", "file", ".", "read", "(", "tmpl", ")", ";", "return", "substitute", "(", "template", ",", "variables", ")", ";", "}" ]

[ "Generate", "a", "file", "based", "on", "the", "template", "and", "source", "files", "." ]

[ "function", "putStorage", "(", "host", ",", "path", ",", "data", ",", "cert", ",", "callback", ")", "{", "var", "protocol", "=", "'https://'", "var", "ldp", "=", "{", "hostname", ":", "host", ",", "rejectUnauthorized", ":", "false", ",", "port", ":", "443", ",", "method", ":", "'PUT'", ",", "headers", ":", "{", "'Content-Type'", ":", "'text/turtle'", "}", "}", "if", "(", "cert", ")", "{", "ldp", ".", "key", "=", "fs", ".", "readFileSync", "(", "cert", ")", "ldp", ".", "cert", "=", "fs", ".", "readFileSync", "(", "cert", ")", "}", "// put file to ldp", "ldp", ".", "path", "=", "path", "debug", "(", "'sending to : '", "+", "protocol", "+", "host", "+", "path", ")", "var", "put", "=", "https", ".", "request", "(", "ldp", ",", "function", "(", "res", ")", "{", "chunks", "=", "''", "debug", "(", "'STATUS: '", "+", "res", ".", "statusCode", ")", "debug", "(", "'HEADERS: '", "+", "JSON", ".", "stringify", "(", "res", ".", "headers", ")", ")", "res", ".", "on", "(", "'data'", ",", "function", "(", "chunk", ")", "{", "chunks", "+=", "chunk", "}", ")", "res", ".", "on", "(", "'end'", ",", "function", "(", "chunk", ")", "{", "callback", "(", "null", ",", "chunks", ",", "ldp", ")", "}", ")", "}", ")", "put", ".", "on", "(", "'error'", ",", "function", "(", "e", ")", "{", "callback", "(", "e", ")", "}", ")", "put", ".", "write", "(", "data", ")", "put", ".", "end", "(", ")", "}" ]

[ "putStorage", "Sends", "turtle", "data", "to", "remote", "storage", "via", "put", "request" ]

[ "function", "is", "(", "store", ",", "uri", ",", "type", ")", "{", "var", "ret", "=", "false", "var", "types", "=", "store", ".", "findTypeURIs", "(", "$rdf", ".", "sym", "(", "uri", ")", ")", "if", "(", "types", "&&", "types", "[", "type", "]", ")", "{", "ret", "=", "true", "}", "return", "ret", "}" ]

[ "See", "if", "a", "URI", "is", "a", "certain", "type" ]

[ "function", "to_rgb", "(", "obj", ")", "{", "return", "[", "obj", ".", "R", ",", "obj", ".", "G", ",", "obj", ".", "B", "]", ".", "map", "(", "format_number", ")", ".", "join", "(", "''", ")", ";", "}" ]

[ "reversed", "method", "of", "rgb_2_object" ]

[ "function", "(", "results", ")", "{", "// Only do so if `callback` is specified", "if", "(", "IODOpts", ".", "callback", ")", "{", "var", "options", "=", "{", "url", ":", "IODOpts", ".", "callback", ".", "uri", "}", "var", "res", "=", "JSON", ".", "stringify", "(", "results", ")", "// Url-encode use `form` property", "if", "(", "IODOpts", ".", "callback", ".", "method", "===", "'encoded'", ")", "{", "options", ".", "form", "=", "{", "results", ":", "res", "}", "}", "var", "r", "=", "request", ".", "post", "(", "options", ",", "function", "(", "err", ",", "res", ")", "{", "// Emits `CbError` if any error occurs while sending results to callback", "if", "(", "err", ")", "IOD", ".", "eventEmitter", ".", "emit", "(", "'CbError'", ",", "err", ")", "else", "if", "(", "res", ".", "statusCode", "!==", "200", ")", "{", "IOD", ".", "eventEmitter", ".", "emit", "(", "'CbError'", ",", "'Status Code: '", "+", "res", ".", "statusCode", ")", "}", "}", ")", "// Multipart use form object", "if", "(", "IODOpts", ".", "callback", ".", "method", "===", "'multipart'", ")", "{", "var", "form", "=", "r", ".", "form", "(", ")", "form", ".", "append", "(", "'results'", ",", "res", ")", "form", ".", "on", "(", "'error'", ",", "function", "(", "err", ")", "{", "IOD", ".", "evenEmitter", ".", "emit", "(", "'CBError'", ",", "err", ")", "}", ")", "}", "}", "}" ]

[ "Sends", "results", "of", "request", "to", "specified", "callback", "." ]

[ "function", "(", "jobId", ")", "{", "var", "isFinished", "=", "function", "(", "res", ")", "{", "return", "res", "&&", "res", ".", "status", "&&", "(", "res", ".", "status", "===", "'finished'", "||", "res", ".", "status", "===", "'failed'", ")", "}", "var", "poll", "=", "function", "(", ")", "{", "IOD", ".", "status", "(", "{", "jobId", ":", "jobId", "}", ",", "function", "(", "err", ",", "res", ")", "{", "// Emits err as first argument", "if", "(", "err", ")", "IOD", ".", "eventEmitter", ".", "emit", "(", "jobId", ",", "err", ")", "else", "if", "(", "isFinished", "(", "res", ")", ")", "{", "IOD", ".", "eventEmitter", ".", "emit", "(", "jobId", ",", "null", ",", "res", ")", "sendCallback", "(", "res", ")", "}", "else", "setTimeout", "(", "poll", ",", "IODOpts", ".", "pollInterval", ")", "}", ")", "}", "setTimeout", "(", "poll", ",", "IODOpts", ".", "pollInterval", ")", "}" ]

[ "Periodically", "get", "status", "of", "a", "job", "with", "specified", "job", "id", "jobId", ".", "Do", "so", "until", "job", "has", "finished", "or", "failed", "." ]

[ "function", "(", "asyncRes", ",", "callback", ")", "{", "var", "jobId", "=", "asyncRes", ".", "jobID", "if", "(", "!", "jobId", ")", "return", "callback", "(", "null", ",", "asyncRes", ")", "else", "if", "(", "IODOpts", ".", "getResults", ")", "{", "IOD", ".", "result", "(", "{", "jobId", ":", "jobId", ",", "majorVersion", ":", "IODOpts", ".", "majorVersion", ",", "retries", ":", "3", "}", ",", "callback", ")", "}", "else", "{", "callback", "(", "null", ",", "asyncRes", ")", "pollUntilDone", "(", "jobId", ")", "}", "}" ]

[ "If", "getResults", "is", "true", "and", "jobId", "is", "found", "send", "IOD", "result", "request", "." ]

[ "function", "list", "(", "scriptModule", ",", "agent", ",", "msg", ",", "cb", ")", "{", "const", "servers", "=", "[", "]", ";", "const", "scripts", "=", "[", "]", ";", "const", "idMap", "=", "agent", ".", "idMap", ";", "for", "(", "const", "sid", "in", "idMap", ")", "{", "if", "(", "idMap", ".", "hasOwnProperty", "(", "sid", ")", ")", "{", "servers", ".", "push", "(", "sid", ")", ";", "}", "}", "fs", ".", "readdir", "(", "scriptModule", ".", "root", ",", "(", "err", ",", "filenames", ")", "=>", "{", "if", "(", "err", ")", "{", "filenames", "=", "[", "]", ";", "}", "for", "(", "let", "i", "=", "0", ",", "l", "=", "filenames", ".", "length", ";", "i", "<", "l", ";", "i", "++", ")", "{", "scripts", ".", "push", "(", "filenames", "[", "i", "]", ")", ";", "}", "cb", "(", "null", ",", "{", "servers", ":", "servers", ",", "scripts", ":", "scripts", "}", ")", ";", "}", ")", ";", "}" ]

[ "List", "server", "id", "and", "scripts", "file", "name" ]

[ "function", "get", "(", "scriptModule", ",", "agent", ",", "msg", ",", "cb", ")", "{", "const", "filename", "=", "msg", ".", "filename", ";", "if", "(", "!", "filename", ")", "{", "cb", "(", "'empty filename'", ")", ";", "return", ";", "}", "fs", ".", "readFile", "(", "path", ".", "join", "(", "scriptModule", ".", "root", ",", "filename", ")", ",", "'utf-8'", ",", "(", "err", ",", "data", ")", "=>", "{", "if", "(", "err", ")", "{", "logger", ".", "error", "(", "`", "${", "filename", "}", "${", "err", ".", "stack", "}", "`", ")", ";", "cb", "(", "`", "${", "filename", "}", "`", ")", ";", "}", "cb", "(", "null", ",", "data", ")", ";", "}", ")", ";", "}" ]

[ "Get", "the", "content", "of", "the", "script", "file" ]

[ "function", "save", "(", "scriptModule", ",", "agent", ",", "msg", ",", "cb", ")", "{", "const", "filepath", "=", "path", ".", "join", "(", "scriptModule", ".", "root", ",", "msg", ".", "filename", ")", ";", "fs", ".", "writeFile", "(", "filepath", ",", "msg", ".", "body", ",", "(", "err", ")", "=>", "{", "if", "(", "err", ")", "{", "logger", ".", "error", "(", "`", "${", "msg", ".", "filename", "}", "${", "err", ".", "stack", "}", "`", ")", ";", "cb", "(", "`", "${", "msg", ".", "filename", "}", "`", ")", ";", "return", ";", "}", "cb", "(", ")", ";", "}", ")", ";", "}" ]

[ "Save", "a", "script", "file", "that", "posted", "from", "admin", "console" ]

[ "function", "bin", "(", "argv", ")", "{", "if", "(", "!", "argv", "[", "2", "]", ")", "{", "console", ".", "error", "(", "\"url is required\"", ")", "console", ".", "error", "(", "\"Usage : cat <url>\"", ")", "process", ".", "exit", "(", "-", "1", ")", "}", "shell", ".", "cat", "(", "argv", "[", "2", "]", ",", "function", "(", "err", ",", "res", ",", "uri", ")", "{", "if", "(", "err", ")", "{", "console", ".", "error", "(", "err", ")", "}", "else", "{", "console", ".", "log", "(", "res", ")", "}", "}", ")", "}" ]

[ "cat", "as", "a", "command" ]

[ "function", "connectUser", "(", "name", ",", "pass", ",", "cb", ")", "{", "loginUser", "(", "name", ",", "pass", ",", "function", "(", "err", ",", "user", ")", "{", "if", "(", "err", ")", "return", "cb", "(", "err", ")", "var", "nano", "=", "NANO", "(", "_ci", ".", "protocol", "+", "'//'", "+", "encodeURIComponent", "(", "name", ")", "+", "':'", "+", "encodeURIComponent", "(", "pass", ")", "+", "'@'", "+", "_ci", ".", "host", "+", "'/'", ")", ",", "db", "=", "nano", ".", "use", "(", "name", ")", ";", "function", "getObject", "(", "type", ",", "id", ",", "rev", ")", "{", "var", "ctor", "=", "registry", "[", "type", "]", ",", "obj", "=", "new", "ctor", "(", "id", ",", "rev", ")", "obj", ".", "type", "(", "type", ")", "if", "(", "ctor", ".", "dbname", ")", "{", "obj", ".", "db", "=", "nano", ".", "use", "(", "ctor", ".", "dbname", ")", "}", "else", "{", "obj", ".", "db", "=", "db", "}", "obj", ".", "getObject", "=", "getObject", "return", "obj", "}", "cb", "(", "null", ",", "user", ",", "getObject", ",", "db", ",", "nano", ")", "}", ")", "}" ]

[ "Connects", "a", "user" ]

[ "function", "createDatabase", "(", "name", ",", "cb", ")", "{", "nano", "(", ")", ".", "db", ".", "create", "(", "name", ",", "function", "(", "err", ")", "{", "if", "(", "err", "&&", "err", ".", "status_code", "!==", "412", ")", "return", "cb", "(", "err", ")", "cb", "(", "null", ",", "err", "?", "false", ":", "true", ")", "}", ")", "}" ]

[ "Creates", "a", "database", "We", "assume", "that", "every", "database", "belongs", "to", "exactly", "one", "user", ".", "Both", "share", "the", "same", "name", "." ]