Datasets:

---

CM

/

codexglue_code2text_javascript

like 12

[ "function", "sortedIndex", "(", "element", ")", "{", "/* jshint validthis:true */", "var", "index", "=", "binarySearch", "(", "toArray", "(", "this", ")", ",", "element", ",", "this", ".", "comparator", ")", ";", "if", "(", "index", "<", "0", ")", "{", "// binarySearch decreases the negative index by one because otherwise the index 0 would stand for two results", "// @see https://github.com/darkskyapp/binary-search/issues/1", "return", "Math", ".", "abs", "(", "index", ")", "-", "1", ";", "}", "else", "{", "return", "index", ";", "}", "}" ]

[ "Returns", "the", "index", "where", "the", "given", "element", "would", "be", "inserted", "." ]

[ "function", "pushSingle", "(", "arr", ",", "element", ")", "{", "var", "index", "=", "arr", ".", "sortedIndex", "(", "element", ")", ",", "_", "=", "arr", ".", "_sortedArray", ";", "// original push and unshift are faster than splice", "if", "(", "index", "===", "0", ")", "{", "_", ".", "unshift", ".", "call", "(", "arr", ",", "element", ")", ";", "}", "else", "if", "(", "index", "===", "arr", ".", "length", ")", "{", "_", ".", "push", ".", "call", "(", "arr", ",", "element", ")", ";", "}", "else", "{", "_", ".", "splice", ".", "call", "(", "arr", ",", "index", ",", "0", ",", "element", ")", ";", "}", "}" ]

[ "Performs", "a", "push", "of", "a", "single", "element", ".", "Used", "by", "push", "unshift", "splice", "." ]

[ "function", "getInversionOf", "(", "comparator", ")", "{", "function", "inversion", "(", "a", ",", "b", ")", "{", "return", "-", "comparator", "(", "a", ",", "b", ")", ";", "}", "inversion", ".", "original", "=", "comparator", ";", "return", "inversion", ";", "}" ]

[ "Inverts", "the", "given", "comparator", "so", "the", "array", "will", "be", "sorted", "reversed", ".", "The", "original", "comparator", "is", "saved", "so", "it", "can", "be", "restored", "." ]

[ "function", "multipleComparators", "(", "comparators", ")", "{", "return", "function", "applyComparators", "(", "a", ",", "b", ")", "{", "var", "i", ",", "result", ";", "for", "(", "i", "=", "0", ";", "i", "<", "comparators", ".", "length", ";", "i", "++", ")", "{", "result", "=", "comparators", "[", "i", "]", "(", "a", ",", "b", ")", ";", "if", "(", "result", "!==", "0", ")", "{", "return", "result", ";", "}", "}", "return", "defaultComparator", "(", "a", ",", "b", ")", ";", "}", ";", "}" ]

[ "Returns", "a", "single", "comparator", "which", "tries", "all", "given", "comparators", "one", "after", "another", "and", "stops", "if", "one", "of", "them", "returned", "another", "value", "than", "0", "." ]

[ "function", "(", "inName", ",", "inValue", ")", "{", "this", ".", "attributes", "[", "inName", "]", "=", "inValue", ";", "if", "(", "this", ".", "hasNode", "(", ")", ")", "{", "this", ".", "attributeToNode", "(", "inName", ",", "inValue", ")", ";", "}", "this", ".", "invalidateTags", "(", ")", ";", "}" ]

[ "Sets", "the", "value", "of", "an", "attribute", "on", "this", "object", ".", "Pass", "null", "_inValue_", "to", "remove", "an", "attribute", "." ]

[ "function", "(", "inClass", ")", "{", "if", "(", "inClass", "&&", "!", "this", ".", "hasClass", "(", "inClass", ")", ")", "{", "var", "c", "=", "this", ".", "getClassAttribute", "(", ")", ";", "this", ".", "setClassAttribute", "(", "c", "+", "(", "c", "?", "\" \"", ":", "\"\"", ")", "+", "inClass", ")", ";", "}", "}" ]

[ "Adds", "CSS", "class", "name", "_inClass_", "to", "the", "_class_", "attribute", "of", "this", "object", "." ]

[ "function", "(", "inClass", ")", "{", "if", "(", "inClass", "&&", "this", ".", "hasClass", "(", "inClass", ")", ")", "{", "var", "c", "=", "this", ".", "getClassAttribute", "(", ")", ";", "c", "=", "(", "\" \"", "+", "c", "+", "\" \"", ")", ".", "replace", "(", "\" \"", "+", "inClass", "+", "\" \"", ",", "\" \"", ")", ".", "slice", "(", "1", ",", "-", "1", ")", ";", "this", ".", "setClassAttribute", "(", "c", ")", ";", "}", "}" ]

[ "Removes", "substring", "_inClass_", "from", "the", "_class_", "attribute", "of", "this", "object", "." ]

[ "function", "(", "inParentNode", ")", "{", "// clean up render flags and memoizations", "this", ".", "teardownRender", "(", ")", ";", "// inParentNode can be a string id or a node reference", "var", "pn", "=", "enyo", ".", "dom", ".", "byId", "(", "inParentNode", ")", ";", "if", "(", "pn", "==", "document", ".", "body", ")", "{", "this", ".", "setupBodyFitting", "(", ")", ";", "}", "else", "if", "(", "this", ".", "fit", ")", "{", "this", ".", "addClass", "(", "\"enyo-fit enyo-clip\"", ")", ";", "}", "// generate our HTML", "pn", ".", "innerHTML", "=", "this", ".", "generateHtml", "(", ")", ";", "// post-rendering tasks", "this", ".", "rendered", "(", ")", ";", "// support method chaining", "return", "this", ";", "}" ]

[ "Renders", "this", "object", "into", "the", "DOM", "node", "referenced", "by", "_inParentNode_", ".", "If", "rendering", "into", "the", "document", "body", "element", "appropriate", "styles", "will", "be", "used", "to", "have", "it", "expand", "to", "fill", "the", "whole", "window", "." ]

[ "function", "(", "inBounds", ",", "inUnit", ")", "{", "var", "s", "=", "this", ".", "domStyles", ",", "unit", "=", "inUnit", "||", "\"px\"", ";", "var", "extents", "=", "[", "\"width\"", ",", "\"height\"", ",", "\"left\"", ",", "\"top\"", ",", "\"right\"", ",", "\"bottom\"", "]", ";", "for", "(", "var", "i", "=", "0", ",", "b", ",", "e", ";", "e", "=", "extents", "[", "i", "]", ";", "i", "++", ")", "{", "b", "=", "inBounds", "[", "e", "]", ";", "if", "(", "b", "||", "b", "===", "0", ")", "{", "s", "[", "e", "]", "=", "b", "+", "(", "!", "enyo", ".", "isString", "(", "b", ")", "?", "unit", ":", "''", ")", ";", "}", "}", "this", ".", "domStylesChanged", "(", ")", ";", "}" ]

[ "Sets", "any", "or", "all", "of", "geometry", "style", "properties", "_width_", "_height_", "_left_", "_top_", "_right_", "and", "_bottom_", "." ]

[ "function", "(", "inName", ",", "inValue", ")", "{", "if", "(", "inValue", "===", "null", "||", "inValue", "===", "false", "||", "inValue", "===", "\"\"", ")", "{", "this", ".", "node", ".", "removeAttribute", "(", "inName", ")", ";", "}", "else", "{", "this", ".", "node", ".", "setAttribute", "(", "inName", ",", "inValue", ")", ";", "}", "}" ]

[ "DOM", "aka", "direct", "-", "to", "-", "node", "rendering" ]

[ "function", "simpleGetStream", "(", "opts", ")", "{", "var", "stream", "=", "through2", "(", ")", "stream", ".", "req", "=", "simpleGet", ".", "call", "(", "this", ",", "opts", ",", "function", "callback", "(", "err", ",", "res", ")", "{", "stream", ".", "res", "=", "res", "if", "(", "err", ")", "return", "stream", ".", "emit", "(", "'error'", ",", "err", ")", "res", ".", "pipe", "(", "stream", ")", "}", ")", "return", "stream", "}" ]

[ ">", "Request", "a", "page", "and", "return", "a", "response", "stream" ]

[ "function", "multiDimArrayIndex", "(", "dimensions", ",", "indices", ")", "{", "// Check that indices fit inside dimensions shape.", "for", "(", "var", "i", "=", "0", ";", "i", "<", "dimensions", ".", "length", ";", "i", "++", ")", "{", "if", "(", "indices", "[", "i", "]", ">", "dimensions", "[", "i", "]", ")", "{", "throw", "new", "TypeError", "(", "error", ".", "outOfBoundIndex", ")", "}", "}", "var", "order", "=", "dimensions", ".", "length", "// Handle order 1", "if", "(", "order", "===", "1", ")", "return", "indices", "[", "0", "]", "//* index = i_n + i_(n-1) * d_n + i_(n-2) * d_n * d_(n-1) + ... + i_2 * d_n * d_(n-1) * ... * d_3 + i_1 * d_n * ... * d_2", "var", "n", "=", "order", "-", "1", "var", "factor", "=", "dimensions", "[", "n", "]", "// d_n", "var", "index", "=", "indices", "[", "n", "]", "+", "factor", "*", "indices", "[", "n", "-", "1", "]", "// i_n + i_(n-1) * d_n", "for", "(", "var", "j", "=", "2", ";", "j", "<", "order", ";", "j", "++", ")", "{", "factor", "*=", "dimensions", "[", "n", "-", "j", "]", "index", "+=", "factor", "*", "indices", "[", "n", "-", "j", "]", "}", "return", "index", "}" ]

[ "Maps", "multidimensional", "array", "indices", "to", "monodimensional", "array", "index" ]

[ "function", "hasPositionByBoardSize", "(", "boardSize", ",", "position", ")", "{", "return", "position", "&&", "position", ".", "x", ">=", "0", "&&", "position", ".", "y", ">=", "0", "&&", "boardSize", ".", "y", ">", "position", ".", "y", "&&", "boardSize", ".", "x", ">", "position", ".", "x", ";", "}" ]

[ "Checks", "if", "position", "exists", "in", "this", "board", "size" ]

[ "function", "mapBoard", "(", "board", ",", "func", ")", "{", "return", "board", ".", "map", "(", "function", "(", "col", ")", "{", "return", "col", ".", "map", "(", "function", "(", "p", ")", "{", "return", "func", "(", "p", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Map", "some", "function", "in", "all", "board", "positions", "and", "return", "a", "new", "board" ]

[ "function", "getBoardWithPieces", "(", "board", ",", "pieces", ")", "{", "return", "mapBoard", "(", "board", ",", "function", "(", "p", ")", "{", "var", "x", "=", "p", ".", "x", ",", "y", "=", "p", ".", "y", ";", "var", "piece", "=", "Position", ".", "getPositionFromPositions", "(", "pieces", ",", "p", ")", ";", "return", "piece", "?", "{", "x", ":", "x", ",", "y", ":", "y", ",", "isBlack", ":", "piece", ".", "isBlack", "}", ":", "{", "x", ":", "x", ",", "y", ":", "y", "}", ";", "}", ")", ";", "}" ]

[ "Takes", "a", "board", "and", "return", "a", "new", "board", "with", "pieces", "." ]

[ "function", "getStartWhiteBlack", "(", "x", ",", "whiteY", ")", "{", "return", "[", "{", "x", ":", "x", ",", "y", ":", "0", ",", "isBlack", ":", "true", "}", ",", "{", "x", ":", "x", ",", "y", ":", "whiteY", ",", "isBlack", ":", "false", "}", "]", ";", "}" ]

[ "Get", "start", "white", "and", "black", "pieces", "." ]

[ "function", "addStartPieces", "(", "x", ",", "whiteY", ",", "positions", ")", "{", "return", "x", "<", "0", "?", "positions", ":", "addStartPieces", "(", "x", "-", "1", ",", "whiteY", ",", "positions", ".", "concat", "(", "getStartWhiteBlack", "(", "x", ",", "whiteY", ")", ")", ")", ";", "}" ]

[ "Add", "start", "pieces", "recursively" ]

[ "function", "getPositionFromBoard", "(", "board", ",", "position", ")", "{", "try", "{", "return", "board", "[", "position", ".", "y", "]", "[", "position", ".", "x", "]", ";", "}", "catch", "(", "e", ")", "{", "throw", "new", "Error", "(", "'Error getting position'", ")", ";", "}", "}" ]

[ "Gets", "board", "position", "from", "x", "and", "y", "coordinates", "." ]

[ "function", "getAllNearPositions", "(", "position", ")", "{", "return", "[", "[", "-", "1", ",", "-", "1", "]", ",", "[", "0", ",", "-", "1", "]", ",", "[", "1", ",", "-", "1", "]", ",", "[", "-", "1", ",", "0", "]", ",", "[", "1", ",", "0", "]", ",", "[", "-", "1", ",", "1", "]", ",", "[", "0", ",", "1", "]", ",", "[", "1", ",", "1", "]", "// Below positions", "]", ".", "map", "(", "function", "(", "toAdd", ")", "{", "return", "{", "x", ":", "position", ".", "x", "+", "toAdd", "[", "0", "]", ",", "y", ":", "position", ".", "y", "+", "toAdd", "[", "1", "]", "}", ";", "}", ")", ";", "}" ]

[ "Get", "all", "valid", "and", "invalid", "near", "positions", "." ]

[ "function", "getNearPositions", "(", "board", ",", "position", ")", "{", "var", "nearPositions", "=", "_getNearPositions", "(", "getBoardSize", "(", "board", ")", ",", "Position", ".", "getXAndY", "(", "position", ")", ")", ";", "return", "getPositionsFromBoard", "(", "board", ",", "nearPositions", ")", ";", "}" ]

[ "Get", "all", "near", "positions", "from", "the", "given", "board", "instance", "." ]

[ "function", "getEmptyNearPositions", "(", "board", ",", "position", ")", "{", "return", "getNearPositions", "(", "board", ",", "position", ")", ".", "filter", "(", "function", "(", "p", ")", "{", "return", "Position", ".", "hasNoPiece", "(", "p", ")", ";", "}", ")", ";", "}" ]

[ "Get", "empty", "near", "positions" ]

[ "function", "getNotEmptyNearPositions", "(", "board", ",", "position", ")", "{", "return", "getNearPositions", "(", "board", ",", "position", ")", ".", "filter", "(", "function", "(", "p", ")", "{", "return", "Position", ".", "hasPiece", "(", "p", ")", ";", "}", ")", ";", "}" ]

[ "Get", "not", "empty", "near", "positions" ]

[ "function", "getJumpXY", "(", "from", ",", "toJump", ")", "{", "return", "{", "x", ":", "getJump", "(", "from", ".", "x", ",", "toJump", ".", "x", ")", ",", "y", ":", "getJump", "(", "from", ".", "y", ",", "toJump", ".", "y", ")", "}", ";", "}" ]

[ "Returns", "the", "target", "position", "from", "a", "jump", "." ]

[ "function", "getBoardWhereCanIGo", "(", "board", ",", "from", ")", "{", "var", "positions", "=", "getPositionsWhereCanIGo", "(", "board", ",", "from", ")", ";", "return", "mapBoard", "(", "board", ",", "function", "(", "position", ")", "{", "return", "Position", ".", "setICanGoHere", "(", "positions", ",", "position", ")", ";", "}", ")", ";", "}" ]

[ "Get", "board", "with", "checked", "where", "can", "I", "go", "positions" ]

[ "function", "getPiecesFromBoard", "(", "board", ")", "{", "var", "initialPieces", "=", "{", "white", ":", "[", "]", ",", "black", ":", "[", "]", "}", ";", "return", "board", ".", "reduce", "(", "function", "(", "piecesRow", ",", "row", ")", "{", "return", "row", ".", "reduce", "(", "function", "(", "pieces", ",", "position", ")", "{", "if", "(", "Position", ".", "hasBlackPiece", "(", "position", ")", ")", "pieces", ".", "black", "=", "pieces", ".", "black", ".", "concat", "(", "position", ")", ";", "else", "if", "(", "Position", ".", "hasWhitePiece", "(", "position", ")", ")", "pieces", ".", "white", "=", "pieces", ".", "white", ".", "concat", "(", "position", ")", ";", "return", "pieces", ";", "}", ",", "piecesRow", ")", ";", "}", ",", "initialPieces", ")", ";", "}" ]

[ "Takes", "a", "board", "and", "return", "white", "and", "black", "pieces", ".", "Used", "to", "calculate", "score", "from", "a", "board", "." ]

[ "function", "(", "sessionId", ")", "{", "if", "(", "sessionId", ")", "{", "if", "(", "sessionId", ".", "length", "<", "24", ")", "{", "throw", "new", "CError", "(", "'sid length undersized'", ")", ".", "log", "(", ")", ";", "}", "if", "(", "sessionId", ".", "length", ">", "128", ")", "{", "throw", "new", "CError", "(", "'sid length exceeded'", ")", ".", "log", "(", ")", ";", "}", "this", ".", "_sid", "=", "sessionId", ";", "}", "}" ]

[ "Set", "the", "session", "identifier" ]

[ "function", "getImageRaw", "(", "options", ",", "_onProgress", "=", "(", ")", "=>", "{", "}", ")", "{", "return", "new", "Promise", "(", "(", "resolve", ",", "reject", ")", "=>", "{", "var", "request", "=", "new", "XMLHttpRequest", "(", ")", ";", "request", ".", "open", "(", "'GET'", ",", "options", ".", "url", ",", "true", ")", ";", "request", ".", "responseType", "=", "options", ".", "responseType", "||", "'blob'", ";", "function", "transferComplete", "(", ")", "{", "var", "result", ";", "switch", "(", "options", ".", "responseType", ")", "{", "case", "'blob'", ":", "result", "=", "new", "Blob", "(", "[", "this", ".", "response", "]", ",", "{", "type", ":", "options", ".", "mimeType", "||", "'image/jpeg'", "}", ")", ";", "resolve", "(", "result", ")", ";", "break", ";", "case", "'arraybuffer'", ":", "result", "=", "this", ".", "response", ";", "resolve", "(", "result", ")", ";", "break", ";", "default", ":", "result", "=", "this", ".", "response", ";", "resolve", "(", "result", ")", ";", "break", ";", "}", "}", "var", "transferCanceled", "=", "reject", ";", "var", "transferFailed", "=", "reject", ";", "request", ".", "addEventListener", "(", "'progress'", ",", "_onProgress", ",", "false", ")", ";", "request", ".", "addEventListener", "(", "'load'", ",", "transferComplete", ",", "false", ")", ";", "request", ".", "addEventListener", "(", "'error'", ",", "transferFailed", ",", "false", ")", ";", "request", ".", "addEventListener", "(", "'abort'", ",", "transferCanceled", ",", "false", ")", ";", "request", ".", "send", "(", "null", ")", ";", "}", ")", ";", "}" ]

[ "getImageRaw", "from", "a", "specific", "url" ]

[ "function", "JSONPRequest", "(", "url", ",", "timeout", "=", "3000", ")", "{", "var", "self", "=", "this", ";", "self", ".", "timeout", "=", "timeout", ";", "self", ".", "called", "=", "false", ";", "if", "(", "window", ".", "document", ")", "{", "var", "ts", "=", "Date", ".", "now", "(", ")", ";", "self", ".", "scriptTag", "=", "window", ".", "document", ".", "createElement", "(", "'script'", ")", ";", "// url += '&callback=window.__jsonpHandler_' + ts;", "var", "_url", "=", "''", ";", "if", "(", "url", "&&", "url", "!==", "''", ")", "{", "_url", "=", "queryfy", "(", "url", ",", "{", "callback", ":", "`", "${", "ts", "}", "`", "}", ")", ";", "}", "self", ".", "scriptTag", ".", "src", "=", "_url", ";", "self", ".", "scriptTag", ".", "type", "=", "'text/javascript'", ";", "self", ".", "scriptTag", ".", "async", "=", "true", ";", "self", ".", "prom", "=", "new", "Promise", "(", "(", "resolve", ",", "reject", ")", "=>", "{", "var", "functionName", "=", "`", "${", "ts", "}", "`", ";", "window", "[", "functionName", "]", "=", "function", "(", "data", ")", "{", "self", ".", "called", "=", "true", ";", "resolve", "(", "data", ")", ";", "self", ".", "scriptTag", ".", "parentElement", ".", "removeChild", "(", "self", ".", "scriptTag", ")", ";", "delete", "window", "[", "functionName", "]", ";", "}", ";", "// reject after a timeout", "setTimeout", "(", "(", ")", "=>", "{", "if", "(", "!", "self", ".", "called", ")", "{", "reject", "(", "'Timeout jsonp request '", "+", "ts", ")", ";", "self", ".", "scriptTag", ".", "parentElement", ".", "removeChild", "(", "self", ".", "scriptTag", ")", ";", "delete", "window", "[", "functionName", "]", ";", "}", "}", ",", "self", ".", "timeout", ")", ";", "}", ")", ";", "// the append start the call", "window", ".", "document", ".", "getElementsByTagName", "(", "'head'", ")", "[", "0", "]", ".", "appendChild", "(", "self", ".", "scriptTag", ")", ";", "}", "}" ]

[ "Make", "a", "jsonp", "request", "remember", "only", "GET", "The", "function", "create", "a", "tag", "script", "and", "append", "a", "callback", "param", "in", "querystring", ".", "The", "promise", "will", "be", "reject", "after", "3s", "if", "the", "url", "fail", "to", "respond" ]

[ "function", "copy", "(", "source", ",", "target", ")", "{", "for", "(", "var", "name", "in", "source", ")", "{", "if", "(", "source", ".", "hasOwnProperty", "(", "name", ")", ")", "{", "target", "[", "name", "]", "=", "source", "[", "name", "]", ";", "}", "}", "}" ]

[ "Reset", "properties", "on", "object", "." ]

[ "function", "(", "localPath", ",", "globalPath", ")", "{", "if", "(", "!", "(", "this", "instanceof", "HAControl", ")", ")", "{", "return", "new", "HAControl", "(", "localPath", ",", "globalPath", ")", ";", "}", "this", ".", "localHa", "=", "true", ";", "this", ".", "globalHa", "=", "true", ";", "this", ".", "localPath", "=", "localPath", ";", "this", ".", "globalPath", "=", "globalPath", ";", "}" ]

[ "Simple", "service", "for", "fetching", "HAControl", "status", "." ]

[ "function", "_keySourceHintFrom", "(", "method", ",", "source", ",", "environment", ")", "{", "var", "hints", "=", "[", "]", ";", "if", "(", "method", ")", "hints", ".", "push", "(", "method", ")", ";", "if", "(", "source", ")", "hints", ".", "push", "(", "source", ")", ";", "if", "(", "environment", ")", "hints", ".", "push", "(", "\"WHEN \"", "+", "environment", ")", ";", "return", "hints", ".", "join", "(", "' '", ")", ";", "}" ]

[ "construct", "a", "source", "hint", "for", "the", "ConfigStore", "Hints", "are", "stored", "in", "the", "config", "to", "indicate", "source", "of", "applied", "changes" ]

[ "function", "isGoogCallExpression", "(", "node", ",", "name", ")", "{", "const", "callee", "=", "node", ".", "callee", ";", "return", "callee", "&&", "callee", ".", "type", "===", "'MemberExpression'", "&&", "callee", ".", "object", ".", "type", "===", "'Identifier'", "&&", "callee", ".", "object", ".", "name", "===", "'goog'", "&&", "callee", ".", "property", ".", "type", "===", "'Identifier'", "&&", "!", "callee", ".", "property", ".", "computed", "&&", "callee", ".", "property", ".", "name", "===", "name", ";", "}" ]

[ "If", "a", "node", "represents", "a", "goog", "call", "expression", "." ]

[ "function", "isGoogStatement", "(", "node", ",", "name", ")", "{", "return", "node", ".", "expression", "&&", "node", ".", "expression", ".", "type", "===", "'CallExpression'", "&&", "isGoogCallExpression", "(", "node", ".", "expression", ",", "name", ")", ";", "}" ]

[ "If", "a", "node", "represents", "a", "goog", "statement", "." ]

[ "function", "(", ")", "{", "logger", ".", "info", "(", "'Records sent to Tone Analyzer: '", "+", "amaStats", ".", "processed_record_count", ")", ";", "// these records could be fetched using other API calls", "logger", ".", "info", "(", "'Records missing (no comment text available): '", "+", "amaStats", ".", "missing_record_count", ")", ";", "logger", ".", "info", "(", "'Maximum processed comment thread depth: '", "+", "amaStats", ".", "max_processed_level", ")", ";", "if", "(", "amaStats", ".", "parser_warnings", ">", "0", ")", "{", "// Potential issue with parser logic. If a non-zero value is reported, the base tree should be reviewed.", "logger", ".", "warn", "(", "'Potential base tree parsing issues: '", "+", "amaStats", ".", "parser_warnings", ")", ";", "}", "logger", ".", "debug", "(", "'AMA thread statistics: '", "+", "util", ".", "inspect", "(", "amaStats", ".", "level_stats", ",", "3", ")", ")", ";", "}" ]

[ "local", "helper", "function", ";", "displays", "processing", "statistics" ]

[ "function", "listFiles", "(", "dir", ",", "callback", ")", "{", "return", "new", "Promise", "(", "(", "resolveThis", ",", "reject", ")", "=>", "{", "walk", ".", "walk", "(", "dir", ",", "{", "followLinks", ":", "true", "}", ")", ".", "on", "(", "'file'", ",", "(", "root", ",", "stats", ",", "next", ")", "=>", "{", "const", "destDir", "=", "relative", "(", "dir", ",", "root", ")", ";", "const", "relativePath", "=", "destDir", "?", "join", "(", "destDir", ",", "stats", ".", "name", ")", ":", "stats", ".", "name", ";", "resolve", "(", "relativePath", ")", ".", "then", "(", "callback", ")", ".", "then", "(", "next", ")", ";", "}", ")", ".", "on", "(", "'errors'", ",", "reject", ")", ".", "on", "(", "'end'", ",", "resolveThis", ")", ";", "}", ")", ";", "}" ]

[ "Lists", "files", "of", "a", "directory", "recursively", ".", "Follows", "symbolic", "links", "." ]

[ "function", "symlinkOrCopySync", "(", "dir", ",", "target", ")", "{", "try", "{", "symlinkOrCopy", ".", "sync", "(", "dir", ",", "target", ")", ";", "}", "catch", "(", "e", ")", "{", "if", "(", "existsSync", "(", "target", ")", ")", "{", "rimraf", ".", "sync", "(", "target", ")", ";", "}", "symlinkOrCopy", ".", "sync", "(", "dir", ",", "target", ")", ";", "}", "}" ]

[ "Symlink", "or", "copy", "a", "directory" ]

[ "function", "Tree", "(", "source", ",", "parent", ",", "githubClient", ")", "{", "this", ".", "gh", "=", "githubClient", ";", "this", ".", "sha", "=", "source", ".", "sha", ";", "this", ".", "parent", "=", "parent", ";", "this", ".", "truncated", "=", "source", ".", "truncated", ";", "this", ".", "objects", "=", "_", ".", "cloneDeep", "(", "source", ".", "tree", ")", ";", "this", ".", "_source", "=", "source", ";", "}" ]

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

[ "function", "task", "(", ")", "{", "// make sure the release task has been initialized", "init", ".", "apply", "(", "this", ",", "arguments", ")", ";", "var", "name", ",", "desc", ",", "deps", ",", "cb", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "arguments", ".", "length", ";", "i", "++", ")", "{", "if", "(", "typeof", "arguments", "[", "i", "]", "===", "'string'", ")", "{", "if", "(", "name", ")", "{", "desc", "=", "arguments", "[", "i", "]", ";", "}", "else", "{", "name", "=", "arguments", "[", "i", "]", ";", "}", "}", "else", "if", "(", "typeof", "arguments", "[", "i", "]", "===", "'function'", ")", "{", "cb", "=", "taskCallback", "(", "arguments", "[", "i", "]", ")", ";", "}", "else", "if", "(", "Array", ".", "isArray", "(", "arguments", "[", "i", "]", ")", ")", "{", "deps", "=", "arguments", "[", "i", "]", ";", "}", "}", "if", "(", "rbot", ".", "env", ".", "usingGrunt", ")", "{", "if", "(", "name", "&&", "desc", ")", "{", "return", "rbot", ".", "env", ".", "taskRunner", ".", "registerTask", "(", "name", ",", "desc", ",", "cb", ")", ";", "}", "else", "if", "(", "name", "&&", "deps", ")", "{", "return", "rbot", ".", "env", ".", "taskRunner", ".", "registerTask", "(", "name", ",", "deps", ")", ";", "}", "throw", "new", "Error", "(", "'Invalid grunt.registerTask() for: name = \"'", "+", "name", "+", "'\", desc = \"'", "+", "desc", "+", "'\", taskList = \"'", "+", "deps", "+", "'\", function = \"'", "+", "cb", "+", "'\"'", ")", ";", "}", "else", "{", "if", "(", "name", "&&", "deps", "&&", "cb", ")", "{", "return", "rbot", ".", "env", ".", "taskRunner", ".", "task", "(", "name", ",", "deps", ",", "cb", ")", ";", "}", "else", "if", "(", "name", "&&", "cb", ")", "{", "return", "rbot", ".", "env", ".", "taskRunner", ".", "task", "(", "name", ",", "cb", ")", ";", "}", "throw", "new", "Error", "(", "'Invalid gulp.task() for: name = \"'", "+", "name", "+", "'\", deps = \"'", "+", "deps", "+", "'\", function = \"'", "+", "cb", "+", "'\"'", ")", ";", "}", "}" ]

[ "Registers", "a", "task", "runner", "neutral", "API", "for", "a", "task", ".", "If", "using", "Grunt", "registerTask", "is", "executed", ".", "If", "using", "Gulp", "task", "is", "executed", ".", "In", "either", "case", "the", "arguments", "are", "passed", "in", "the", "expected", "order", "regardless", "of", "how", "they", "are", "passed", "into", "this", "function", "." ]

[ "function", "taskCallback", "(", "fn", ")", "{", "return", "fn", ".", "length", "?", "taskAsyncCb", ":", "taskSyncCb", ";", "function", "taskAsyncCb", "(", "cb", ")", "{", "return", "taskCb", "(", "this", "||", "{", "}", ",", "arguments", ",", "fn", ",", "cb", ",", "true", ")", ";", "}", "function", "taskSyncCb", "(", ")", "{", "return", "taskCb", "(", "this", "||", "{", "}", ",", "arguments", ",", "fn", ",", "null", ",", "false", ")", ";", "}", "function", "taskCb", "(", "cxt", ",", "args", ",", "fn", ",", "done", ",", "isAsync", ")", "{", "cxt", ".", "done", "=", "isAsync", "&&", "typeof", "done", "===", "'function'", "?", "done", ":", "isAsync", "&&", "typeof", "cxt", ".", "async", "===", "'function'", "?", "cxt", ".", "async", "(", ")", ":", "taskSyncDone", ";", "if", "(", "!", "rbot", ".", "env", ".", "usingGrunt", ")", "{", "// set options using either a configuration value or the passed", "// default value", "cxt", ".", "options", "=", "function", "setOptions", "(", "defOpts", ")", "{", "Object", ".", "keys", "(", "defOpts", ")", ".", "forEach", "(", "function", "it", "(", "k", ")", "{", "this", ".", "options", "[", "k", "]", "=", "rbot", ".", "config", "(", "k", ")", "||", "defOpts", "[", "k", "]", ";", "}", ".", "bind", "(", "this", ")", ")", ";", "return", "this", ".", "options", ";", "}", ".", "bind", "(", "cxt", ")", ";", "}", "var", "fna", "=", "args", ";", "if", "(", "cxt", ".", "done", "!==", "done", "&&", "cxt", ".", "done", "!==", "taskSyncDone", ")", "{", "// ensure that the done function still gets passed as the 1st", "// argument even when the task runner doesn't pass it", "fna", "=", "args", "?", "Array", ".", "prototype", ".", "slice", ".", "call", "(", "args", ",", "0", ")", ":", "[", "]", ";", "fna", ".", "unshift", "(", "cxt", ".", "done", ")", ";", "}", "return", "fn", ".", "apply", "(", "cxt", ",", "fna", ")", ";", "}", "function", "taskSyncDone", "(", "success", ")", "{", "rbot", ".", "log", ".", "verbose", "(", "'Synchronous task '", "+", "(", "success", "?", "'completed'", ":", "'failed'", ")", ")", ";", "}", "}" ]

[ "Creates", "a", "task", "callback", "function", "that", "will", "wrap", "the", "passed", "callback", "that", "the", "task", "runner", "requires", "to", "ensure", "consistent", "option", "behavior", "between", "different", "task", "runners", ".", "When", "the", "specified", "function", "contains", "arguments", "the", "wrapper", "will", "assume", "that", "the", "associated", "task", "will", "be", "executed", "in", "an", "asynchronous", "fashion", ".", "Relies", "on", "the", "number", "of", "arguments", "defined", "in", "the", "passed", "function", "to", "determine", "synchronicity", "." ]

[ "function", "processTemplate", "(", "val", ",", "data", ")", "{", "if", "(", "rbot", ".", "env", ".", "usingGrunt", ")", "{", "return", "rbot", ".", "env", ".", "taskRunner", ".", "template", ".", "process", "(", "val", ",", "data", ")", ";", "}", "// TODO : add gulp template processing", "if", "(", "!", "val", ")", "{", "return", "val", ";", "}", "return", "val", ";", "}" ]

[ "Processes", "a", "value", "using", "the", "passed", "data" ]

[ "function", "(", "emits", ",", "message", ",", "daemonPid", ")", "{", "var", "monitor", "=", "new", "Monitor", "(", "message", ",", "options", ",", "daemonPid", ",", "shutdown", ",", "child", ",", "function", "(", ")", "{", "// emit events before starting child", "Object", ".", "keys", "(", "emits", ")", ".", "forEach", "(", "function", "(", "name", ")", "{", "// skip the process event until the child spawns", "if", "(", "name", "===", "'process'", ")", "return", ";", "monitor", ".", "emit", ".", "apply", "(", "monitor", ",", "[", "name", "]", ".", "concat", "(", "emits", "[", "name", "]", ")", ")", ";", "}", ")", ";", "// spawn child when monitor is ready", "child", ".", "spawn", "(", ")", ";", "// start pumping streams to monitor", "child", ".", "pump", "(", "monitor", ")", ";", "}", ")", ";", "// once the child has started emit the process event", "child", ".", "once", "(", "'start'", ",", "function", "(", ")", "{", "monitor", ".", "pid", ".", "process", "=", "child", ".", "pid", ";", "monitor", ".", "emit", ".", "apply", "(", "monitor", ",", "[", "'process'", "]", ".", "concat", "(", "emits", ".", "process", ")", ")", ";", "}", ")", ";", "// relay stop and restart to process event on monitor", "child", ".", "on", "(", "'stop'", ",", "function", "(", ")", "{", "monitor", ".", "pid", ".", "process", "=", "null", ";", "// Do not emit if the deamon is in restart mode", "if", "(", "daemonInRestart", ")", "return", ";", "monitor", ".", "emit", "(", "'process'", ",", "'stop'", ")", ";", "}", ")", ";", "child", ".", "on", "(", "'restart'", ",", "function", "(", ")", "{", "monitor", ".", "pid", ".", "process", "=", "child", ".", "pid", ";", "monitor", ".", "emit", "(", "'process'", ",", "'restart'", ")", ";", "}", ")", ";", "}" ]

[ "first", "create", "monitor", "object", "the", "callback", "is", "executed", "when", "the", "monitor", "constructor", "call", "this", ".", "ready" ]

[ "function", "(", "other", ")", "{", "if", "(", "other", ".", "getSessionToken", "(", ")", ")", "{", "this", ".", "_sessionToken", "=", "other", ".", "getSessionToken", "(", ")", ";", "}", "Parse", ".", "User", ".", "__super__", ".", "_mergeFromObject", ".", "call", "(", "this", ",", "other", ")", ";", "}" ]

[ "Instance", "Methods", "Merges", "another", "object", "s", "attributes", "into", "this", "object", "." ]

[ "function", "(", "attrs", ")", "{", "if", "(", "attrs", ".", "sessionToken", ")", "{", "this", ".", "_sessionToken", "=", "attrs", ".", "sessionToken", ";", "delete", "attrs", ".", "sessionToken", ";", "}", "Parse", ".", "User", ".", "__super__", ".", "_mergeMagicFields", ".", "call", "(", "this", ",", "attrs", ")", ";", "}" ]

[ "Internal", "method", "to", "handle", "special", "fields", "in", "a", "_User", "response", "." ]

[ "function", "(", "provider", ",", "options", ")", "{", "var", "authType", ";", "if", "(", "_", ".", "isString", "(", "provider", ")", ")", "{", "authType", "=", "provider", ";", "provider", "=", "Parse", ".", "User", ".", "_authProviders", "[", "provider", "]", ";", "}", "else", "{", "authType", "=", "provider", ".", "getAuthType", "(", ")", ";", "}", "var", "newOptions", "=", "_", ".", "clone", "(", "options", ")", ";", "var", "self", "=", "this", ";", "newOptions", ".", "authData", "=", "null", ";", "newOptions", ".", "success", "=", "function", "(", "model", ")", "{", "self", ".", "_synchronizeAuthData", "(", "provider", ")", ";", "if", "(", "options", ".", "success", ")", "{", "options", ".", "success", ".", "apply", "(", "this", ",", "arguments", ")", ";", "}", "}", ";", "return", "this", ".", "_linkWith", "(", "provider", ",", "newOptions", ")", ";", "}" ]

[ "Unlinks", "a", "user", "from", "a", "service", "." ]

[ "function", "(", "email", ",", "options", ")", "{", "options", "=", "options", "||", "{", "}", ";", "var", "request", "=", "Parse", ".", "_request", "(", "{", "route", ":", "\"requestPasswordReset\"", ",", "method", ":", "\"POST\"", ",", "useMasterKey", ":", "options", ".", "useMasterKey", ",", "data", ":", "{", "email", ":", "email", "}", "}", ")", ";", "return", "request", ".", "_thenRunCallbacks", "(", "options", ")", ";", "}" ]

[ "Requests", "a", "password", "reset", "email", "to", "be", "sent", "to", "the", "specified", "email", "address", "associated", "with", "the", "user", "account", ".", "This", "email", "allows", "the", "user", "to", "securely", "reset", "their", "password", "on", "the", "Parse", "site", "." ]

[ "function", "(", ")", "{", "if", "(", "Parse", ".", "User", ".", "_currentUser", ")", "{", "return", "Parse", ".", "User", ".", "_currentUser", ";", "}", "if", "(", "Parse", ".", "User", ".", "_currentUserMatchesDisk", ")", "{", "return", "Parse", ".", "User", ".", "_currentUser", ";", "}", "// Load the user from local storage.", "Parse", ".", "User", ".", "_currentUserMatchesDisk", "=", "true", ";", "var", "userData", "=", "Parse", ".", "localStorage", ".", "getItem", "(", "Parse", ".", "_getParsePath", "(", "Parse", ".", "User", ".", "_CURRENT_USER_KEY", ")", ")", ";", "if", "(", "!", "userData", ")", "{", "return", "null", ";", "}", "Parse", ".", "User", ".", "_currentUser", "=", "Parse", ".", "Object", ".", "_create", "(", "\"_User\"", ")", ";", "Parse", ".", "User", ".", "_currentUser", ".", "_isCurrentUser", "=", "true", ";", "var", "json", "=", "JSON", ".", "parse", "(", "userData", ")", ";", "Parse", ".", "User", ".", "_currentUser", ".", "id", "=", "json", ".", "_id", ";", "delete", "json", ".", "_id", ";", "Parse", ".", "User", ".", "_currentUser", ".", "_sessionToken", "=", "json", ".", "_sessionToken", ";", "delete", "json", ".", "_sessionToken", ";", "Parse", ".", "User", ".", "_currentUser", ".", "_finishFetch", "(", "json", ")", ";", "Parse", ".", "User", ".", "_currentUser", ".", "_synchronizeAllAuthData", "(", ")", ";", "Parse", ".", "User", ".", "_currentUser", ".", "_refreshCache", "(", ")", ";", "Parse", ".", "User", ".", "_currentUser", ".", "_opSetQueue", "=", "[", "{", "}", "]", ";", "return", "Parse", ".", "User", ".", "_currentUser", ";", "}" ]

[ "Retrieves", "the", "currently", "logged", "in", "ParseUser", "with", "a", "valid", "session", "either", "from", "memory", "or", "localStorage", "if", "necessary", "." ]

[ "function", "(", ")", "{", "spy", ".", "history", "=", "[", "]", ";", "spy", ".", "args", "=", "[", "]", ";", "spy", ".", "count", "=", "0", ";", "spy", ".", "scope", "=", "null", ";", "spy", ".", "trace", "=", "null", ";", "return", "spy", ";", "}" ]

[ "Resets", "history", "and", "counters" ]

[ "function", "(", ")", "{", "if", "(", "spy", ".", "wrapped", ")", "{", "spy", ".", "_module", "[", "spy", ".", "_method", "]", "=", "spy", ".", "original", ";", "spy", ".", "wrapped", "=", "false", ";", "}", "return", "spy", ";", "}" ]

[ "Restores", "the", "original", "method", "back" ]

[ "function", "SpyCall", "(", "scope", ",", "args", ",", "spy", ")", "{", "var", "self", "=", "this", ";", "if", "(", "!", "(", "self", "instanceof", "SpyCall", ")", ")", "{", "return", "new", "SpyCall", "(", "args", ")", ";", "}", "self", ".", "scope", "=", "scope", ";", "self", ".", "args", "=", "args", ";", "self", ".", "time", "=", "new", "Date", "(", ")", ";", "self", ".", "order", "=", "spy", ".", "assert", ".", "_spyOrder", "++", ";", "self", ".", "overall", "=", "Spy", ".", "overall", "++", ";", "self", ".", "trace", "=", "(", "new", "Error", "(", "\"\"", ")", ")", ".", "stack", ";", "}" ]

[ "Call", "History", "Object" ]

[ "function", "translate", "(", "tx", ")", "{", "var", "ty", "=", "arguments", ".", "length", ">", "1", "&&", "arguments", "[", "1", "]", "!==", "undefined", "?", "arguments", "[", "1", "]", ":", "0", ";", "return", "{", "a", ":", "1", ",", "c", ":", "0", ",", "e", ":", "tx", ",", "b", ":", "0", ",", "d", ":", "1", ",", "f", ":", "ty", "}", ";", "}" ]

[ "Calculate", "a", "translate", "matrix" ]

[ "function", "log", "(", "msg", ")", "{", "process", ".", "stdout", ".", "write", "(", "time", "+", "' '", ")", ";", "console", ".", "log", "(", "colors", ".", "log", "(", "msg", ")", ")", ";", "}" ]

[ "console", "functions", "nodejs", "supports" ]

[ "function", "mixInTo", "(", "target", ")", "{", "var", "descriptor", ";", "for", "(", "var", "key", "in", "this", ")", "{", "if", "(", "(", "descriptor", "=", "Object", ".", "getOwnPropertyDescriptor", "(", "this", ",", "key", ")", ")", ")", "{", "Object", ".", "defineProperty", "(", "target", ",", "key", ",", "descriptor", ")", ";", "}", "}", "return", "target", ";", "}" ]

[ "Mix", "this", "members", "into", "target", "." ]

[ "function", "mixIn", "(", "source", ")", "{", "var", "descriptor", ";", "for", "(", "var", "key", "in", "source", ")", "{", "if", "(", "(", "descriptor", "=", "Object", ".", "getOwnPropertyDescriptor", "(", "source", ",", "key", ")", ")", ")", "{", "Object", ".", "defineProperty", "(", "this", ",", "key", ",", "descriptor", ")", ";", "}", "}", "return", "this", ";", "}" ]

[ "Mix", "source", "members", "into", "this", "." ]

[ "function", "cleanObject", "(", "obj", ")", "{", "if", "(", "obj", "instanceof", "Object", ")", "{", "Object", ".", "keys", "(", "obj", ")", ".", "forEach", "(", "(", "key", ")", "=>", "(", "obj", "[", "key", "]", "==", "null", ")", "&&", "delete", "obj", "[", "key", "]", ")", ";", "}", "return", "obj", ";", "}" ]

[ "Removes", "any", "properties", "from", "an", "object", "that", "resolve", "to", "null", "." ]

[ "function", "getDockerfileContext", "(", "context", ")", "{", "const", "fs", "=", "require", "(", "'fs'", ")", ";", "let", "files", "=", "[", "]", ";", "let", "dockerfile", "=", "exports", ".", "resolveDockerfile", "(", "context", ")", ";", "let", "file", "=", "fs", ".", "readFileSync", "(", "dockerfile", ",", "{", "encoding", ":", "'utf8'", "}", ")", ";", "for", "(", "let", "line", "of", "file", ".", "split", "(", "'\\n'", ")", ")", "{", "if", "(", "line", ".", "match", "(", "/", "^\\s*(ADD|COPY).*$", "/", ")", ")", "{", "let", "entries", "=", "line", ".", "split", "(", "' '", ")", ".", "splice", "(", "1", ")", ".", "map", "(", "val", "=>", "val", ".", "trim", "(", ")", ")", ".", "filter", "(", "val", "=>", "val", "!==", "''", ")", ".", "filter", "(", "val", "=>", "!", "val", ".", "startsWith", "(", "'http'", ")", ")", ";", "if", "(", "entries", "[", "0", "]", ".", "startsWith", "(", "'--chown'", ")", ")", "{", "entries", "=", "entries", ".", "splice", "(", "1", ")", ";", "}", "// Array mode", "if", "(", "line", ".", "indexOf", "(", "'['", ")", "!==", "-", "1", "&&", "line", ".", "indexOf", "(", "']'", ")", "!==", "-", "1", ")", "{", "let", "args", "=", "JSON", ".", "parse", "(", "entries", ".", "join", "(", "' '", ")", ")", ";", "args", ".", "splice", "(", "-", "1", ")", ";", "files", "=", "args", "}", "// Default mode", "else", "{", "entries", ".", "splice", "(", "-", "1", ")", ";", "files", "=", "entries", ";", "}", "}", "}", "let", "resolvedFiles", "=", "[", "]", ";", "for", "(", "let", "file", "of", "files", ")", "{", "resolvedFiles", "=", "resolvedFiles", ".", "concat", "(", "glob", ".", "sync", "(", "path", ".", "join", "(", "path", ".", "dirname", "(", "context", ")", ",", "file", ")", ")", ")", ";", "}", "return", "{", "context", ",", "src", ":", "[", "'Dockerfile'", ",", "...", "resolvedFiles", "]", "}", ";", "}" ]

[ "Parses", "a", "Dockerfile", "and", "looks", "for", "sources", "that", "may", "be", "needed", "to", "build", "this", "image", "." ]

[ "function", "tagOutput", "(", "descriptor", ",", "innerDescriptor", ",", "name", ")", "{", "var", "out", "=", "'<'", "+", "name", "+", "innerDescriptor", ".", "attributes", ";", "if", "(", "innerDescriptor", ".", "style", ")", "out", "+=", "' style=\"'", "+", "innerDescriptor", ".", "style", "+", "'\"'", ";", "if", "(", "innerDescriptor", ".", "classes", ")", "out", "+=", "' class=\"'", "+", "innerDescriptor", ".", "classes", "+", "'\"'", ";", "if", "(", "innerDescriptor", ".", "children", ")", "descriptor", ".", "children", "+=", "out", "+", "'>'", "+", "innerDescriptor", ".", "children", "+", "'</'", "+", "name", "+", "'>'", ";", "else", "if", "(", "openTags", ".", "test", "(", "name", ")", ")", "descriptor", ".", "children", "+=", "out", "+", "'>'", ";", "else", "if", "(", "strictTags", ".", "test", "(", "name", ")", ")", "descriptor", ".", "children", "+=", "out", "+", "'></'", "+", "name", "+", "'>'", ";", "else", "descriptor", ".", "children", "+=", "out", "+", "'/>'", ";", "}" ]

[ "produce", "final", "html", "tag", "representation" ]

[ "function", "(", "width", ",", "height", ")", "{", "var", "canvas", "=", "document", ".", "createElement", "(", "\"canvas\"", ")", ";", "canvas", ".", "width", "=", "width", ";", "canvas", ".", "height", "=", "height", ";", "var", "context", "=", "canvas", ".", "getContext", "(", "\"2d\"", ")", ";", "var", "imageData", "=", "context", ".", "getImageData", "(", "0", ",", "0", ",", "width", ",", "height", ")", ";", "var", "buffer", "=", "new", "ArrayBuffer", "(", "width", "*", "height", "*", "4", ")", ";", "var", "buffer8", "=", "new", "Uint8ClampedArray", "(", "buffer", ")", ";", "var", "buffer32", "=", "new", "Uint32Array", "(", "buffer", ")", ";", "return", "{", "canvas", ":", "canvas", ",", "context", ":", "context", ",", "width", ":", "width", ",", "height", ":", "height", ",", "imageData", ":", "imageData", ",", "buffer8", ":", "buffer8", ",", "buffer32", ":", "buffer32", "}", ";", "}" ]

[ "Uint", "Uint", "-", ">", "CanvasImage" ]

[ "function", "FileEmitter", "(", "folder", ",", "opt_options", ")", "{", "if", "(", "!", "(", "this", "instanceof", "FileEmitter", ")", ")", "{", "return", "new", "FileEmitter", "(", "folder", ",", "opt_options", ")", ";", "}", "events", ".", "EventEmitter", ".", "call", "(", "this", ")", ";", "opt_options", "=", "opt_options", "||", "{", "}", ";", "this", ".", "root", "=", "path", ".", "resolve", "(", "process", ".", "cwd", "(", ")", ",", "folder", ")", ";", "// flags & options", "this", ".", "buffer", "=", "opt_options", ".", "buffer", "||", "false", ";", "this", ".", "incremental", "=", "opt_options", ".", "incremental", "||", "false", ";", "this", ".", "followSymLinks", "=", "opt_options", ".", "followSymLinks", "||", "false", ";", "this", ".", "recursive", "=", "opt_options", ".", "recursive", "===", "false", "?", "false", ":", "true", ";", "this", ".", "maxBufferSize", "=", "opt_options", ".", "maxBufferSize", "||", "10485760", ";", "// 10 MiB", "// file constructor", "this", ".", "File", "=", "opt_options", ".", "File", "||", "File", ";", "// filters", "this", ".", "include", "=", "opt_options", ".", "include", "||", "false", ";", "this", ".", "exclude", "=", "opt_options", ".", "exclude", "||", "false", ";", "this", ".", "_minimatchOptions", "=", "opt_options", ".", "minimatchOptions", "||", "{", "matchBase", ":", "true", "}", ";", "// read, stat & readdir queues", "this", ".", "_queues", "=", "[", "[", "]", ",", "[", "]", ",", "[", "''", "]", "]", ";", "// max number of open file descriptors (used for incremental EMFILE back-off)", "this", ".", "_maxFDs", "=", "opt_options", ".", "maxFDs", "||", "Infinity", ";", "// UNDOCUMENTED OPTION", "// currently open file descriptors", "this", ".", "_numFDs", "=", "0", ";", "// incremental lock", "this", ".", "_locked", "=", "false", ";", "this", ".", "_hadError", "=", "false", ";", "var", "self", "=", "this", ";", "if", "(", "opt_options", ".", "autorun", "!==", "false", ")", "{", "setImmediate", "(", "function", "(", ")", "{", "self", ".", "run", "(", ")", ";", "}", ")", ";", "}", "}" ]

[ "file", "-", "emitter" ]

[ "function", "reportCoverage", "(", "cov", ")", "{", "// Stats", "print", "(", "'\\n [bold]{Test Coverage}\\n'", ")", ";", "var", "sep", "=", "' +------------------------------------------+----------+------+------+--------+'", ",", "lastSep", "=", "' +----------+------+------+--------+'", ";", "result", "=", "sep", "+", "'\\n'", ";", "result", "+=", "' | filename | coverage | LOC | SLOC | missed |\\n'", ";", "result", "+=", "sep", "+", "'\\n'", ";", "for", "(", "var", "name", "in", "cov", ")", "{", "var", "file", "=", "cov", "[", "name", "]", ";", "if", "(", "Array", ".", "isArray", "(", "file", ")", ")", "{", "result", "+=", "' | '", "+", "rpad", "(", "name", ",", "40", ")", ";", "result", "+=", "' | '", "+", "lpad", "(", "file", ".", "coverage", ".", "toFixed", "(", "2", ")", ",", "8", ")", ";", "result", "+=", "' | '", "+", "lpad", "(", "file", ".", "LOC", ",", "4", ")", ";", "result", "+=", "' | '", "+", "lpad", "(", "file", ".", "SLOC", ",", "4", ")", ";", "result", "+=", "' | '", "+", "lpad", "(", "file", ".", "totalMisses", ",", "6", ")", ";", "result", "+=", "' |\\n'", ";", "}", "}", "result", "+=", "sep", "+", "'\\n'", ";", "result", "+=", "' '", "+", "rpad", "(", "''", ",", "40", ")", ";", "result", "+=", "' | '", "+", "lpad", "(", "cov", ".", "coverage", ".", "toFixed", "(", "2", ")", ",", "8", ")", ";", "result", "+=", "' | '", "+", "lpad", "(", "cov", ".", "LOC", ",", "4", ")", ";", "result", "+=", "' | '", "+", "lpad", "(", "cov", ".", "SLOC", ",", "4", ")", ";", "result", "+=", "' | '", "+", "lpad", "(", "cov", ".", "totalMisses", ",", "6", ")", ";", "result", "+=", "' |\\n'", ";", "result", "+=", "lastSep", ";", "console", ".", "log", "(", "result", ")", ";", "for", "(", "var", "name", "in", "cov", ")", "{", "if", "(", "name", ".", "match", "(", "file_matcher", ")", ")", "{", "var", "file", "=", "cov", "[", "name", "]", ";", "var", "annotated", "=", "''", ";", "annotated", "+=", "colorize", "(", "'\\n [bold]{'", "+", "name", "+", "'}:'", ")", ";", "annotated", "+=", "colorize", "(", "file", ".", "source", ")", ";", "annotated", "+=", "'\\n'", ";", "fs", ".", "writeFileSync", "(", "'annotated/'", "+", "name", ",", "annotated", ")", ";", "}", "}", "}" ]

[ "Report", "test", "coverage", "." ]

[ "function", "populateCoverage", "(", "cov", ")", "{", "cov", ".", "LOC", "=", "cov", ".", "SLOC", "=", "cov", ".", "totalFiles", "=", "cov", ".", "totalHits", "=", "cov", ".", "totalMisses", "=", "cov", ".", "coverage", "=", "0", ";", "for", "(", "var", "name", "in", "cov", ")", "{", "var", "file", "=", "cov", "[", "name", "]", ";", "if", "(", "Array", ".", "isArray", "(", "file", ")", ")", "{", "// Stats", "++", "cov", ".", "totalFiles", ";", "cov", ".", "totalHits", "+=", "file", ".", "totalHits", "=", "coverage", "(", "file", ",", "true", ")", ";", "cov", ".", "totalMisses", "+=", "file", ".", "totalMisses", "=", "coverage", "(", "file", ",", "false", ")", ";", "file", ".", "totalLines", "=", "file", ".", "totalHits", "+", "file", ".", "totalMisses", ";", "cov", ".", "SLOC", "+=", "file", ".", "SLOC", "=", "file", ".", "totalLines", ";", "if", "(", "!", "file", ".", "source", ")", "file", ".", "source", "=", "[", "]", ";", "cov", ".", "LOC", "+=", "file", ".", "LOC", "=", "file", ".", "source", ".", "length", ";", "file", ".", "coverage", "=", "(", "file", ".", "totalHits", "/", "file", ".", "totalLines", ")", "*", "100", ";", "// Source", "var", "width", "=", "file", ".", "source", ".", "length", ".", "toString", "(", ")", ".", "length", ";", "file", ".", "source", "=", "file", ".", "source", ".", "map", "(", "function", "(", "line", ",", "i", ")", "{", "++", "i", ";", "var", "hits", "=", "file", "[", "i", "]", "===", "0", "?", "0", ":", "(", "file", "[", "i", "]", "||", "' '", ")", ";", "if", "(", "hits", "===", "0", ")", "{", "hits", "=", "'\\x1b[31m'", "+", "hits", "+", "'\\x1b[0m'", ";", "line", "=", "'\\x1b[41m'", "+", "line", "+", "'\\x1b[0m'", ";", "}", "else", "{", "hits", "=", "'\\x1b[32m'", "+", "hits", "+", "'\\x1b[0m'", ";", "}", "return", "'\\n '", "+", "lpad", "(", "i", ",", "width", ")", "+", "' | '", "+", "hits", "+", "' | '", "+", "line", ";", "}", ")", ".", "join", "(", "''", ")", ";", "}", "}", "cov", ".", "coverage", "=", "(", "cov", ".", "totalHits", "/", "cov", ".", "SLOC", ")", "*", "100", ";", "}" ]

[ "Populate", "code", "coverage", "data", "." ]

[ "function", "hasFullCoverage", "(", "cov", ")", "{", "for", "(", "var", "name", "in", "cov", ")", "{", "var", "file", "=", "cov", "[", "name", "]", ";", "if", "(", "file", "instanceof", "Array", ")", "{", "if", "(", "file", ".", "coverage", "!==", "100", ")", "{", "return", "false", ";", "}", "}", "}", "return", "true", ";", "}" ]

[ "Test", "if", "all", "files", "have", "100%", "coverage" ]

[ "function", "send", "(", "id", ")", "{", "if", "(", "msg", ".", "ack", ")", "{", "server", ".", "_rememberAck", "(", "msg", ".", "ack", ",", "ws", ".", "broker_uuid", ")", ";", "}", "var", "destWs", "=", "server", ".", "id2ws", "[", "id", "]", ";", "if", "(", "destWs", ")", "{", "if", "(", "destWs", ".", "readyState", "===", "WebSocket", ".", "OPEN", ")", "{", "destWs", ".", "send", "(", "JSON", ".", "stringify", "(", "{", "action", ":", "'message'", ",", "message", ":", "msg", ".", "message", ",", "ack", ":", "msg", ".", "ack", ",", "from", ":", "server", ".", "ws2id", "[", "ws", ".", "broker_uuid", "]", "}", ")", ")", ";", "}", "else", "{", "err", "=", "new", "Error", "(", "'Unable to send message. Client \"'", "+", "id", "+", "'\" disconnected'", ")", ";", "server", ".", "emit", "(", "'error'", ",", "err", ")", ";", "}", "}", "else", "{", "server", ".", "emit", "(", "'warn'", ",", "new", "Error", "(", "'Unable to send message. Client \"'", "+", "id", "+", "'\" unknown'", ")", ")", ";", "}", "}" ]

[ "Re", "-", "wraps", "incoming", "send", "message", "into", "a", "message", "message", "to", "the", "specified", "destination" ]

[ "function", "load", "(", "filename", ")", "{", "return", "function", "(", "cb", ")", "{", "var", "file", "=", "path", ".", "join", "(", "process", ".", "cwd", "(", ")", ",", "filename", ")", ",", "json", "=", "require", "(", "file", ")", ",", "model", "=", "exports", "[", "json", ".", "table", "]", ",", "rows", "=", "json", ".", "rows", ";", "console", ".", "log", "(", "'Loading'", ",", "file", ")", ";", "run", "(", ")", ";", "function", "run", "(", ")", "{", "var", "row", "=", "rows", ".", "shift", "(", ")", ";", "if", "(", "row", "!==", "undefined", ")", "{", "model", ".", "create", "(", "row", ",", "function", "(", "err", ")", "{", "if", "(", "err", ")", "{", "cb", "(", "err", ")", ";", "}", "else", "{", "run", "(", ")", ";", "}", "}", ")", ";", "}", "else", "{", "cb", "(", ")", ";", "}", "}", "}", ";", "}" ]

[ "Loads", "filename", "in", "the", "database" ]

[ "function", "connect", "(", "uri", ",", "cb", ")", "{", "pg", ".", "connect", "(", "uri", ",", "function", "(", "err", ",", "client", ",", "done", ")", "{", "// Backwards compatibility with pg", "if", "(", "typeof", "done", "===", "'undefined'", ")", "{", "done", "=", "noop", ";", "}", "if", "(", "err", ")", "{", "cb", "(", "err", ",", "null", ",", "done", ")", ";", "}", "else", "{", "cb", "(", "null", ",", "client", ",", "done", ")", ";", "}", "}", ")", ";", "}" ]

[ "Connects", "to", "database", "at", "uri" ]

[ "function", "getClient", "(", "uri", ",", "cb", ")", "{", "if", "(", "typeof", "uri", "===", "'function'", ")", "{", "cb", "=", "uri", ";", "uri", "=", "conf", ".", "db", ";", "}", "connect", "(", "uri", ",", "function", "(", "err", ",", "client", ",", "done", ")", "{", "if", "(", "err", ")", "{", "cb", "(", "err", ",", "null", ",", "done", ")", ";", "}", "else", "{", "cb", "(", "null", ",", "client", ",", "done", ")", ";", "}", "}", ")", ";", "}" ]

[ "Returns", "a", "pg", "client", "you", "can", "either", "specify", "a", "connection", "uri", "or", "let", "the", "function", "use", "conf", ".", "db" ]

[ "function", "getFirstReturnStatement", "(", "node", ")", "{", "if", "(", "!", "node", "||", "!", "node", ".", "body", ")", "{", "return", ";", "}", "if", "(", "node", ".", "body", ".", "type", "===", "'BlockStatement'", ")", "{", "node", "=", "node", ".", "body", ";", "}", "for", "(", "var", "i", "=", "0", ";", "i", "<", "node", ".", "body", ".", "length", ";", "i", "++", ")", "{", "if", "(", "node", ".", "body", "[", "i", "]", ".", "type", "===", "'ReturnStatement'", ")", "{", "return", "node", ".", "body", "[", "i", "]", ";", "}", "}", "}" ]

[ "Pareses", "a", "FunctionExpression", "or", "BlockStatement", "and", "returns", "the", "first", "ReturnStatement" ]

[ "function", "get", "(", "tableName", ",", "fieldNames", ",", "where", ",", "orderBy", ")", "{", "if", "(", "orderBy", "&&", "!", "checkOrderBy", "(", "orderBy", ")", ")", "{", "throw", "new", "Error", "(", "'Invalid arg: orderBy'", ")", ";", "}", "if", "(", "!", "db", ")", "{", "throw", "new", "Error", "(", "'Not connected'", ")", ";", "}", "let", "sql", "=", "`", "${", "fieldNames", ".", "join", "(", "','", ")", "}", "${", "tableName", "}", "`", ";", "if", "(", "where", ")", "{", "sql", "+=", "`", "${", "where", "}", "`", ";", "}", "if", "(", "orderBy", ")", "{", "sql", "+=", "`", "${", "orderBy", ".", "join", "(", "','", ")", "}", "`", ";", "}", "return", "new", "Promise", "(", "(", "(", "resolve", ",", "reject", ")", "=>", "{", "db", ".", "get", "(", "sql", ",", "[", "]", ",", "(", "error", ",", "row", ")", "=>", "{", "if", "(", "error", ")", "{", "reject", "(", "error", ")", ";", "}", "else", "{", "resolve", "(", "row", ")", ";", "}", "}", ")", ";", "}", ")", ")", ";", "}" ]

[ "return", "single", "row" ]

[ "function", "all", "(", "tableName", ",", "fieldNames", ",", "where", ",", "orderBy", ",", "limit", "=", "null", ",", "join", "=", "null", ")", "{", "if", "(", "orderBy", "&&", "!", "checkOrderBy", "(", "orderBy", ")", ")", "{", "throw", "new", "Error", "(", "'Invalid arg: orderBy'", ")", ";", "}", "if", "(", "!", "db", ")", "{", "throw", "new", "Error", "(", "'Not connected'", ")", ";", "}", "let", "sql", "=", "`", "${", "fieldNames", ".", "join", "(", "','", ")", "}", "${", "tableName", "}", "`", ";", "if", "(", "join", ")", "{", "sql", "+=", "`", "${", "join", "}", "`", ";", "}", "if", "(", "where", ")", "{", "sql", "+=", "`", "${", "where", "}", "`", ";", "}", "if", "(", "orderBy", ")", "{", "sql", "+=", "`", "${", "orderBy", ".", "join", "(", "','", ")", "}", "`", ";", "}", "if", "(", "limit", ")", "{", "sql", "+=", "`", "${", "limit", "}", "`", ";", "}", "return", "new", "Promise", "(", "(", "(", "resolve", ",", "reject", ")", "=>", "{", "db", ".", "all", "(", "sql", ",", "[", "]", ",", "(", "error", ",", "rows", ")", "=>", "{", "if", "(", "error", ")", "{", "reject", "(", "error", ")", ";", "}", "else", "{", "resolve", "(", "rows", ")", ";", "}", "}", ")", ";", "}", ")", ")", ";", "}" ]

[ "return", "all", "rows" ]

[ "function", "(", "db", ")", "{", "if", "(", "!", "db", ".", "type", ")", "{", "return", "defaultDbType", ";", "}", "return", "dbTypes", ".", "find", "(", "function", "(", "dbType", ")", "{", "return", "dbType", ".", "name", "===", "db", ".", "type", ";", "}", ")", "||", "null", ";", "}" ]

[ "Given", "a", "database", "object", "get", "the", "database", "type" ]

[ "function", "(", "obj", ",", "keys", ")", "{", "return", "keys", ".", "reduce", "(", "function", "(", "memo", ",", "key", ")", "{", "if", "(", "obj", "[", "key", "]", "!==", "undefined", ")", "{", "memo", "[", "key", "]", "=", "obj", "[", "key", "]", ";", "}", "return", "memo", ";", "}", ",", "{", "}", ")", ";", "}" ]

[ "Return", "a", "copy", "of", "an", "object", "with", "only", "the", "picked", "keys" ]

[ "function", "(", "doc", ")", "{", "if", "(", "!", "this", ".", "_props", ")", "{", "return", "doc", ";", "}", "return", "this", ".", "_props", ".", "reduce", "(", "function", "(", "obj", ",", "prop", ")", "{", "if", "(", "doc", ".", "hasOwnProperty", "(", "prop", ")", ")", "{", "obj", "[", "prop", "]", "=", "doc", "[", "prop", "]", ";", "}", "return", "obj", ";", "}", ",", "{", "}", ")", ";", "}" ]

[ "Remove", "extraneous", "properties", "from", "a", "proposed", "document" ]

[ "function", "(", "doc", ")", "{", "if", "(", "!", "this", ".", "isValid", "(", "doc", ")", ")", "{", "return", "Promise", ".", "resolve", "(", "false", ")", ";", "}", "var", "props", "=", "pick", "(", "doc", ",", "this", ".", "_uniq", ")", ";", "if", "(", "!", "Object", ".", "keys", "(", "props", ")", ".", "length", ")", "{", "return", "Promise", ".", "resolve", "(", "true", ")", ";", "}", "return", "this", ".", "_dbApi", ".", "isAdmissible", "(", "doc", ",", "props", ")", ";", "}" ]

[ "Check", "if", "a", "proposed", "document", "is", "admissible", "into", "the", "database" ]

[ "function", "(", "doc", ")", "{", "var", "that", "=", "this", ";", "doc", "=", "that", ".", "_in_map", "(", "doc", ")", ";", "return", "this", ".", "_init", ".", "then", "(", "function", "(", ")", "{", "return", "that", ".", "isAdmissible", "(", "doc", ")", ";", "}", ")", ".", "then", "(", "function", "(", "admissible", ")", "{", "if", "(", "!", "admissible", ")", "{", "throw", "new", "Error", "(", "'Document not admissible'", ")", ";", "}", "doc", "=", "that", ".", "clean", "(", "doc", ")", ";", "if", "(", "that", ".", "_index", ")", "{", "delete", "doc", "[", "that", ".", "_index", "]", ";", "}", "return", "that", ".", "getNextIndex", "(", ")", ";", "}", ")", ".", "then", "(", "function", "(", "max", ")", "{", "if", "(", "that", ".", "_index", "&&", "typeof", "max", "===", "'number'", ")", "{", "doc", "[", "that", ".", "_index", "]", "=", "max", ";", "}", "return", "that", ".", "_dbApi", ".", "create", "(", "doc", ")", ".", "then", "(", "function", "(", "doc", ")", "{", "if", "(", "!", "doc", ")", "{", "throw", "new", "Error", "(", "'Document not created'", ")", ";", "}", "return", "doc", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Create", "and", "insert", "a", "new", "document", "into", "the", "database" ]

[ "function", "(", "props", ")", "{", "var", "that", "=", "this", ";", "return", "this", ".", "_dbApi", ".", "find", "(", "props", "||", "{", "}", ")", ".", "then", "(", "function", "(", "docs", ")", "{", "return", "docs", ".", "map", "(", "that", ".", "_out_map", ")", ";", "}", ")", ";", "}" ]

[ "Get", "all", "documents", "from", "the", "database", "with", "matching", "properties" ]

[ "function", "(", "id", ")", "{", "var", "that", "=", "this", ";", "return", "this", ".", "_dbApi", ".", "read", "(", "id", ")", ".", "then", "(", "function", "(", "doc", ")", "{", "return", "that", ".", "_readDoc", "(", "doc", ")", ";", "}", ")", ";", "}" ]

[ "Get", "a", "document", "from", "the", "database", "by", "database", "ID" ]

[ "function", "(", "key", ")", "{", "var", "that", "=", "this", ";", "if", "(", "!", "this", ".", "_key", "||", "!", "key", ")", "{", "return", "Promise", ".", "reject", "(", "new", "Error", "(", "'No unique key specified'", ")", ")", ";", "}", "var", "props", "=", "{", "}", ";", "props", "[", "this", ".", "_key", "]", "=", "key", ";", "return", "this", ".", "_dbApi", ".", "find", "(", "props", ")", ".", "then", "(", "function", "(", "docs", ")", "{", "return", "that", ".", "_readDoc", "(", "docs", "[", "0", "]", ")", ";", "}", ")", ";", "}" ]

[ "Get", "a", "document", "from", "the", "database", "by", "key" ]

[ "function", "(", "index", ")", "{", "var", "that", "=", "this", ";", "var", "props", "=", "this", ".", "_propIndex", "(", "index", ")", ";", "if", "(", "!", "props", ")", "{", "return", "Promise", ".", "reject", "(", "new", "Error", "(", "'No auto-indexing key specified'", ")", ")", ";", "}", "return", "this", ".", "_dbApi", ".", "find", "(", "props", ")", ".", "then", "(", "function", "(", "docs", ")", "{", "return", "that", ".", "_readDoc", "(", "docs", "[", "0", "]", ")", ";", "}", ")", ";", "}" ]

[ "Get", "a", "document", "from", "the", "database", "by", "auto", "-", "index" ]

[ "function", "(", "doc", ",", "updates", ")", "{", "updates", "=", "this", ".", "_in_map", "(", "updates", "||", "{", "}", ")", ";", "Object", ".", "keys", "(", "doc", ")", ".", "forEach", "(", "function", "(", "prop", ")", "{", "if", "(", "updates", ".", "hasOwnProperty", "(", "prop", ")", ")", "{", "doc", "[", "prop", "]", "=", "updates", "[", "prop", "]", ";", "}", "}", ")", ";", "if", "(", "!", "this", ".", "isValid", "(", "doc", ")", ")", "{", "throw", "new", "Error", "(", "'Updated document is invalid'", ")", ";", "}", "var", "id", "=", "doc", "[", "this", ".", "_dbType", ".", "id", "]", ";", "this", ".", "_uniq", ".", "forEach", "(", "function", "(", "uniq", ")", "{", "delete", "doc", "[", "uniq", "]", ";", "}", ")", ";", "doc", "=", "this", ".", "clean", "(", "doc", ")", ";", "return", "this", ".", "_dbApi", ".", "update", "(", "id", ",", "doc", ")", ";", "}" ]

[ "Update", "an", "existing", "database", "document" ]

[ "function", "(", "id", ",", "updates", ")", "{", "var", "that", "=", "this", ";", "return", "this", ".", "read", "(", "id", ")", ".", "then", "(", "function", "(", "doc", ")", "{", "return", "that", ".", "_updateDoc", "(", "doc", ",", "updates", ")", ";", "}", ")", ";", "}" ]

[ "Update", "a", "document", "in", "the", "database", "by", "database", "ID" ]

[ "function", "(", "key", ",", "updates", ")", "{", "var", "that", "=", "this", ";", "if", "(", "!", "this", ".", "_key", "||", "!", "key", ")", "{", "return", "Promise", ".", "reject", "(", "new", "Error", "(", "'No unique key specified'", ")", ")", ";", "}", "return", "this", ".", "readByKey", "(", "key", ")", ".", "then", "(", "function", "(", "doc", ")", "{", "return", "that", ".", "_updateDoc", "(", "doc", ",", "updates", ")", ";", "}", ")", ";", "}" ]

[ "Update", "a", "document", "in", "the", "database", "by", "key" ]

[ "function", "(", "index", ",", "updates", ")", "{", "var", "that", "=", "this", ";", "return", "this", ".", "readByIndex", "(", "index", ")", ".", "then", "(", "function", "(", "doc", ")", "{", "return", "that", ".", "_updateDoc", "(", "doc", ",", "updates", ")", ";", "}", ")", ";", "}" ]

[ "Update", "a", "document", "in", "the", "database", "by", "auto", "-", "index" ]

[ "function", "(", "key", ")", "{", "var", "that", "=", "this", ";", "if", "(", "!", "this", ".", "_key", "||", "!", "key", ")", "{", "return", "Promise", ".", "reject", "(", "new", "Error", "(", "'No unique key specified'", ")", ")", ";", "}", "return", "this", ".", "readByKey", "(", "key", ")", ".", "then", "(", "function", "(", "doc", ")", "{", "return", "that", ".", "delete", "(", "doc", "[", "that", ".", "_dbType", ".", "id", "]", ")", ";", "}", ")", ";", "}" ]

[ "Delete", "a", "document", "from", "the", "database", "by", "key" ]

[ "function", "(", "index", ")", "{", "var", "that", "=", "this", ";", "return", "this", ".", "readByIndex", "(", "index", ")", ".", "then", "(", "function", "(", "doc", ")", "{", "return", "that", ".", "delete", "(", "doc", "[", "that", ".", "_dbType", ".", "id", "]", ")", ";", "}", ")", ";", "}" ]

[ "Delete", "a", "document", "from", "the", "database", "by", "auto", "-", "index" ]

[ "function", "(", "operation", ",", "res", ")", "{", "var", "that", "=", "this", ";", "var", "method", "=", "res", ".", "req", ".", "method", ";", "return", "operation", ".", "then", "(", "function", "(", "doc", ")", "{", "if", "(", "method", "===", "'POST'", ")", "{", "if", "(", "that", ".", "_path", "&&", "(", "that", ".", "_key", "||", "that", ".", "_index", ")", ")", "{", "res", ".", "header", "(", "'Location'", ",", "'/'", "+", "that", ".", "_path", "+", "'/'", "+", "doc", "[", "that", ".", "_key", "||", "that", ".", "_index", "]", ")", ";", "}", "return", "res", ".", "status", "(", "201", ")", ".", "json", "(", "doc", ")", ";", "}", "return", "res", ".", "status", "(", "200", ")", ".", "json", "(", "doc", ")", ";", "}", ",", "function", "(", "err", ")", "{", "console", ".", "error", "(", "err", ".", "message", ")", ";", "if", "(", "method", "===", "'POST'", "||", "method", "===", "'PUT'", ")", "{", "return", "res", ".", "status", "(", "409", ")", ".", "end", "(", ")", ";", "}", "if", "(", "method", "===", "'GET'", ")", "{", "res", ".", "status", "(", "404", ")", ".", "end", "(", ")", ";", "}", "return", "res", ".", "status", "(", "500", ")", ".", "end", "(", ")", ";", "}", ")", ";", "}" ]

[ "Middleware", "REST", "handler", "for", "CRUD", "operations" ]

[ "function", "get_trit", "(", "n", ",", "i", ")", "{", "// convert entire number to balanced ternary string then slice", "// would be nice to extract without converting everything, see extract_digit(), which", "// works for unbalanced ternary, but balanced converts 2 -> 1i, so individual digit extraction", "// is more difficult -- see https://en.wikipedia.org/wiki/Balanced_ternary#Conversion_from_ternary", "var", "s", "=", "n2bts", "(", "n", ")", ";", "return", "~", "~", "BT_DIGIT_TO_N", "[", "s", ".", "charAt", "(", "s", ".", "length", "-", "i", "-", "1", ")", "]", ";", "}" ]

[ "get", "trit", "value", "at", "ith", "index", "of", "n", "i", "of", "0", "=", "least", "significant" ]

[ "function", "resolveFunctionList", "(", "functionList", ",", "basedir", ")", "{", "if", "(", "!", "functionList", ")", "return", "[", "]", "return", "(", "Array", ".", "isArray", "(", "functionList", ")", "?", "functionList", ":", "[", "functionList", "]", ")", ".", "map", "(", "function", "(", "proc", ")", "{", "if", "(", "typeof", "(", "proc", ")", "===", "'string'", ")", "{", "proc", "=", "require", "(", "resolve", ".", "sync", "(", "proc", ",", "{", "basedir", ":", "basedir", "}", ")", ")", "}", "return", "toAsync", "(", "proc", ")", "}", ")", "}" ]

[ "Resolve", "and", "require", "a", "list", "of", "module", "path", "that", "exports", "async", "function" ]

[ "function", "processJson", "(", "obj", ")", "{", "for", "(", "var", "i", "in", "obj", ")", "{", "if", "(", "typeof", "(", "obj", "[", "i", "]", ")", "===", "\"object\"", ")", "{", "processJson", "(", "obj", "[", "i", "]", ")", ";", "// found an obj or array keep digging", "}", "else", "if", "(", "obj", "[", "i", "]", "!==", "null", ")", "{", "obj", "[", "i", "]", "=", "getFunctionNameAndArgs", "(", "obj", "[", "i", "]", ")", ";", "// not an obj or array, check contents", "}", "}", "return", "obj", ";", "}" ]

[ "Loop", "through", "entire", "json", "object" ]

[ "function", "getFunctionNameAndArgs", "(", "value", ")", "{", "var", "pattern", "=", "/", "^(.*)\\{\\{([^()]+?)(\\((.+)\\))?\\}\\}(.*)$", "/", "g", ",", "match", ",", "func", ",", "args", ";", "var", "argArray", "=", "[", "]", ",", "surroundings", "=", "[", "]", ";", "var", "retValue", ";", "while", "(", "match", "=", "pattern", ".", "exec", "(", "value", ")", ")", "{", "surroundings", "[", "0", "]", "=", "match", "[", "1", "]", ";", "func", "=", "match", "[", "2", "]", ";", "args", "=", "match", "[", "4", "]", ";", "surroundings", "[", "1", "]", "=", "match", "[", "5", "]", ";", "}", "if", "(", "args", "!==", "undefined", ")", "{", "if", "(", "args", ".", "indexOf", "(", "\"[\"", ")", "!==", "-", "1", ")", "{", "// is an array as string", "args", "=", "JSON", ".", "parse", "(", "args", ")", ";", "argArray", ".", "push", "(", "args", ")", ";", "}", "else", "{", "// one or more string/number params", "args", "=", "args", ".", "replace", "(", "/", ", ", "/", "gi", ",", "\",\"", ")", ";", "args", "=", "args", ".", "replace", "(", "/", "'", "/", "gi", ",", "\"\"", ",", "\"gi\"", ")", ";", "argArray", "=", "args", ".", "split", "(", "','", ")", ";", "}", "}", "// return value if no Faker method is detected", "retValue", "=", "func", "?", "executeFunctionByName", "(", "func", ",", "argArray", ")", ":", "value", ";", "if", "(", "surroundings", "[", "0", "]", ")", "{", "// prefix", "retValue", "=", "surroundings", "[", "0", "]", "+", "retValue", ";", "}", "if", "(", "surroundings", "[", "1", "]", ")", "{", "// postfix", "retValue", "+=", "surroundings", "[", "1", "]", ";", "}", "return", "retValue", ";", "}" ]

[ "Get", "func", "name", "extract", "args", "and", "exec", "on", "their", "values" ]

[ "function", "executeFunctionByName", "(", "functionName", ",", "args", ")", "{", "var", "namespaces", "=", "functionName", ".", "split", "(", "\".\"", ")", ";", "var", "nsLength", "=", "namespaces", ".", "length", ";", "var", "context", "=", "Faker", ";", "var", "parentContext", "=", "Faker", ";", "if", "(", "namespaces", "[", "0", "]", ".", "toLowerCase", "(", ")", "===", "'definitions'", ")", "{", "grunt", ".", "log", ".", "warn", "(", "'The definitions module from Faker.js is not avail in this task.'", ")", ";", "return", ";", "}", "for", "(", "var", "i", "=", "0", ";", "i", "<", "nsLength", ";", "i", "++", ")", "{", "context", "=", "context", "[", "namespaces", "[", "i", "]", "]", ";", "}", "for", "(", "var", "j", "=", "0", ";", "j", "<", "nsLength", "-", "1", ";", "j", "++", ")", "{", "parentContext", "=", "parentContext", "[", "namespaces", "[", "j", "]", "]", ";", "}", "return", "context", ".", "apply", "(", "parentContext", ",", "args", ")", ";", "}" ]

[ "Execute", "function", "as", "string" ]

[ "function", "(", ")", "{", "if", "(", "errors", ".", "length", ")", "return", "cb", "(", "errors", ")", ";", "var", "transform", "=", "opts", ".", "transform", "||", "function", "(", "_result", ",", "_cb", ")", "{", "_cb", "(", "null", ",", "_result", ")", ";", "}", ";", "transform", "(", "result", ",", "function", "(", "err", ",", "_result", ")", "{", "if", "(", "err", ")", "{", "errors", ".", "push", "(", "formatError", "(", "err", ",", "key", ")", ")", ";", "cb", "(", "errors", ")", ";", "}", "else", "{", "cb", "(", "null", ",", "_result", ")", ";", "}", "}", ")", ";", "}" ]

[ "setup", "function", "to", "call", "once", "all", "keys", "have", "been", "recursed" ]

[ "function", "(", "text", ",", "color", "=", "[", "255", ",", "255", ",", "255", "]", ",", "colorBg", "=", "[", "0", ",", "0", ",", "0", "]", ",", "style", "=", "\"reset\"", ")", "{", "// First check for raw RGB truecolor code... if the console scheme", "// supports this then no probs... but if not - we need to degrade appropriately.", "if", "(", "color", ".", "constructor", "===", "Array", "&&", "colorBg", ".", "constructor", "===", "Array", ")", "{", "if", "(", "config", ".", "scheme", "===", "\"16M\"", ")", "{", "return", "this", ".", "_styleTruecolor", "(", "text", ",", "color", ",", "colorBg", ",", "style", ")", ";", "}", "else", "{", "return", "this", ".", "_degrade", "(", "text", ",", "color", ",", "colorBg", ",", "style", ")", ";", "}", "}", "else", "{", "throw", "new", "Error", "(", "\"Unrecognized or malformed RGB array values.\"", ")", ";", "}", "}" ]

[ "Marks", "the", "text", "string", "with", "multiple", "RGB", "colors", "and", "ANSI", "named", "style", "characteristics", "." ]

[ "function", "decimalLength", "(", "n", ")", "{", "let", "ns", "=", "cleanNumber", "(", "n", ")", ".", "toString", "(", ")", ";", "let", "ems", "=", "ns", ".", "match", "(", "/", "e([\\+\\-]\\d+)$", "/", ")", ";", "let", "e", "=", "0", ";", "if", "(", "ems", "&&", "ems", "[", "1", "]", ")", "e", "=", "parseInt", "(", "ems", "[", "1", "]", ")", ";", "ns", "=", "ns", ".", "replace", "(", "/", "e[\\-\\+]\\d+$", "/", ",", "''", ")", ";", "let", "parts", "=", "ns", ".", "split", "(", "'.'", ",", "2", ")", ";", "if", "(", "parts", ".", "length", "===", "1", ")", "return", "-", "e", ";", "return", "parts", "[", "1", "]", ".", "length", "-", "e", ";", "}" ]

[ "calculate", "the", "decimal", "part", "length", "of", "a", "number" ]

[ "function", "createClean", "(", "inPath", ")", "{", "if", "(", "!", "inPath", ")", "{", "throw", "new", "Error", "(", "'Input path argument is required'", ")", ";", "}", "return", "function", "cleanDir", "(", ")", "{", "return", "gulp", ".", "src", "(", "inPath", ",", "{", "read", ":", "false", "}", ")", ".", "pipe", "(", "clean", "(", ")", ")", ";", "}", ";", "}" ]

[ "Higher", "order", "function", "to", "create", "gulp", "function", "that", "cleans", "directories", "." ]

[ "function", "Exception", "(", "code", ",", "message", ")", "{", "const", "factory", "=", "Object", ".", "create", "(", "Exception", ".", "prototype", ")", ";", "factory", ".", "code", "=", "code", ";", "factory", ".", "message", "=", "message", ";", "factory", ".", "stack", "=", "factory", ".", "toString", "(", ")", ";", "return", "factory", ";", "}" ]

[ "Create", "a", "swagger", "response", "instance", "." ]

[ "function", "someSchemasValidate", "(", "propName", ")", "{", "return", "schema", "[", "propName", "]", ".", "some", "(", "function", "(", "possibleType", ")", "{", "var", "tempInput", "=", "{", "}", ",", "tempSchema", "=", "{", "}", ",", "tempErrs", ";", "tempInput", "[", "propName", "]", "=", "input", "[", "propName", "]", ";", "tempSchema", "[", "propName", "]", "=", "possibleType", ";", "tempErrs", "=", "getErrs", "(", "{", "input", ":", "tempInput", ",", "schema", ":", "tempSchema", ",", "optional", ":", "optional", "}", ")", ";", "return", "tempErrs", ".", "length", "===", "0", ";", "}", ")", ";", "}" ]

[ "used", "for", "array", "schema", "types", "where", "all", "we", "need", "is", "to", "pass", "a", "single", "array", "element" ]

[ "function", "firstExist", "(", "fileNames", ")", "{", "const", "head", "=", "fileNames", ".", "slice", "(", "0", ",", "1", ")", ";", "if", "(", "head", ".", "length", "===", "0", ")", "{", "return", "new", "Promise", "(", "(", "resolve", ",", "reject", ")", "=>", "{", "resolve", "(", "false", ")", ";", "}", ")", ";", "}", "const", "tail", "=", "fileNames", ".", "slice", "(", "1", ")", ";", "return", "fileExist", "(", "head", "[", "0", "]", ")", ".", "then", "(", "(", "result", ")", "=>", "{", "if", "(", "false", "===", "result", ")", "{", "return", "firstExist", "(", "tail", ")", ";", "}", "return", "result", ";", "}", ")", ";", "}" ]

[ "Search", "for", "first", "existing", "file" ]

[ "function", "(", "csg", ")", "{", "var", "newpolygons", "=", "this", ".", "polygons", ".", "concat", "(", "csg", ".", "polygons", ")", ";", "var", "result", "=", "CSG", ".", "fromPolygons", "(", "newpolygons", ")", ";", "result", ".", "properties", "=", "this", ".", "properties", ".", "_merge", "(", "csg", ".", "properties", ")", ";", "result", ".", "isCanonicalized", "=", "this", ".", "isCanonicalized", "&&", "csg", ".", "isCanonicalized", ";", "result", ".", "isRetesselated", "=", "this", ".", "isRetesselated", "&&", "csg", ".", "isRetesselated", ";", "return", "result", ";", "}" ]

[ "Like", "union", "but", "when", "we", "know", "that", "the", "two", "solids", "are", "not", "intersecting", "Do", "not", "use", "if", "you", "are", "not", "completely", "sure", "that", "the", "solids", "do", "not", "intersect!" ]

[ "function", "(", "matrix4x4", ")", "{", "var", "newpolygons", "=", "this", ".", "polygons", ".", "map", "(", "function", "(", "p", ")", "{", "return", "p", ".", "transform", "(", "matrix4x4", ")", ";", "}", ")", ";", "var", "result", "=", "CSG", ".", "fromPolygons", "(", "newpolygons", ")", ";", "result", ".", "properties", "=", "this", ".", "properties", ".", "_transform", "(", "matrix4x4", ")", ";", "result", ".", "isRetesselated", "=", "this", ".", "isRetesselated", ";", "return", "result", ";", "}" ]

[ "Affine", "transformation", "of", "CSG", "object", ".", "Returns", "a", "new", "CSG", "object" ]

[ "function", "(", "normal", ",", "point", ",", "length", ")", "{", "var", "plane", "=", "CSG", ".", "Plane", ".", "fromNormalAndPoint", "(", "normal", ",", "point", ")", ";", "var", "onb", "=", "new", "CSG", ".", "OrthoNormalBasis", "(", "plane", ")", ";", "var", "crosssect", "=", "this", ".", "sectionCut", "(", "onb", ")", ";", "var", "midpiece", "=", "crosssect", ".", "extrudeInOrthonormalBasis", "(", "onb", ",", "length", ")", ";", "var", "piece1", "=", "this", ".", "cutByPlane", "(", "plane", ")", ";", "var", "piece2", "=", "this", ".", "cutByPlane", "(", "plane", ".", "flipped", "(", ")", ")", ";", "var", "result", "=", "piece1", ".", "union", "(", "[", "midpiece", ",", "piece2", ".", "translate", "(", "plane", ".", "normal", ".", "times", "(", "length", ")", ")", "]", ")", ";", "return", "result", ";", "}" ]

[ "cut", "the", "solid", "at", "a", "plane", "and", "stretch", "the", "cross", "-", "section", "found", "along", "plane", "normal" ]

[ "function", "(", "csg", ")", "{", "if", "(", "(", "this", ".", "polygons", ".", "length", "===", "0", ")", "||", "(", "csg", ".", "polygons", ".", "length", "===", "0", ")", ")", "{", "return", "false", ";", "}", "else", "{", "var", "mybounds", "=", "this", ".", "getBounds", "(", ")", ";", "var", "otherbounds", "=", "csg", ".", "getBounds", "(", ")", ";", "if", "(", "mybounds", "[", "1", "]", ".", "x", "<", "otherbounds", "[", "0", "]", ".", "x", ")", "return", "false", ";", "if", "(", "mybounds", "[", "0", "]", ".", "x", ">", "otherbounds", "[", "1", "]", ".", "x", ")", "return", "false", ";", "if", "(", "mybounds", "[", "1", "]", ".", "y", "<", "otherbounds", "[", "0", "]", ".", "y", ")", "return", "false", ";", "if", "(", "mybounds", "[", "0", "]", ".", "y", ">", "otherbounds", "[", "1", "]", ".", "y", ")", "return", "false", ";", "if", "(", "mybounds", "[", "1", "]", ".", "z", "<", "otherbounds", "[", "0", "]", ".", "z", ")", "return", "false", ";", "if", "(", "mybounds", "[", "0", "]", ".", "z", ">", "otherbounds", "[", "1", "]", ".", "z", ")", "return", "false", ";", "return", "true", ";", "}", "}" ]

[ "returns", "true", "if", "there", "is", "a", "possibility", "that", "the", "two", "solids", "overlap", "returns", "false", "if", "we", "can", "be", "sure", "that", "they", "do", "not", "overlap" ]