Datasets:

---

CM

/

codexglue_code2text_javascript

like 12

[ "function", "sumov", "(", "object", ",", "depth", "=", "0", ")", "{", "if", "(", "isNumber", "(", "object", ")", ")", "{", "return", "parseFloat", "(", "object", ")", ";", "}", "else", "if", "(", "isObject", "(", "object", ")", "&&", "Number", ".", "isInteger", "(", "depth", ")", ")", "{", "return", "sumObjectValues", "(", "object", ",", "depth", ")", ";", "}", "return", "0", ";", "}" ]

[ "Computes", "the", "sum", "of", "all", "numeric", "values", "in", "an", "object" ]

[ "function", "shuffleObjArrays", "(", "map", ",", "options", ")", "{", "var", "newMap", "=", "!", "!", "options", "&&", "true", "===", "options", ".", "copy", "?", "{", "}", ":", "map", ";", "var", "copyNonArrays", "=", "!", "!", "options", "&&", "true", "===", "options", ".", "copy", "&&", "true", "===", "(", "options", ".", "copyNonArrays", "||", "options", ".", "copyNonArray", ")", ";", "var", "values", "=", "null", ";", "for", "(", "var", "key", "in", "map", ")", "{", "values", "=", "map", "[", "key", "]", ";", "if", "(", "isArray", "(", "values", ")", ")", "{", "newMap", "[", "key", "]", "=", "shuffle", "(", "values", ",", "options", ")", ";", "}", "else", "if", "(", "copyNonArrays", ")", "{", "newMap", "[", "key", "]", "=", "map", "[", "key", "]", ";", "}", "}", "return", "newMap", ";", "}" ]

[ "Shuffles", "the", "arrays", "of", "the", "given", "map", "." ]

[ "function", "crypto_stream_salsa20_xor", "(", "c", ",", "cpos", ",", "m", ",", "mpos", ",", "b", ",", "n", ",", "k", ")", "{", "var", "z", "=", "new", "Uint8Array", "(", "16", ")", ",", "x", "=", "new", "Uint8Array", "(", "64", ")", ";", "var", "u", ",", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "16", ";", "i", "++", ")", "z", "[", "i", "]", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "8", ";", "i", "++", ")", "z", "[", "i", "]", "=", "n", "[", "i", "]", ";", "while", "(", "b", ">=", "64", ")", "{", "crypto_core_salsa20", "(", "x", ",", "z", ",", "k", ",", "sigma", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "64", ";", "i", "++", ")", "c", "[", "cpos", "+", "i", "]", "=", "m", "[", "mpos", "+", "i", "]", "^", "x", "[", "i", "]", ";", "u", "=", "1", ";", "for", "(", "i", "=", "8", ";", "i", "<", "16", ";", "i", "++", ")", "{", "u", "=", "u", "+", "(", "z", "[", "i", "]", "&", "0xff", ")", "|", "0", ";", "z", "[", "i", "]", "=", "u", "&", "0xff", ";", "u", ">>>=", "8", ";", "}", "b", "-=", "64", ";", "cpos", "+=", "64", ";", "mpos", "+=", "64", ";", "}", "if", "(", "b", ">", "0", ")", "{", "crypto_core_salsa20", "(", "x", ",", "z", ",", "k", ",", "sigma", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "b", ";", "i", "++", ")", "c", "[", "cpos", "+", "i", "]", "=", "m", "[", "mpos", "+", "i", "]", "^", "x", "[", "i", "]", ";", "}", "return", "0", ";", "}" ]

[ "expand", "32", "-", "byte", "k" ]

[ "function", "handler", "(", "instance", ",", "context", ",", "func", ",", "index", ",", "callback", ")", "{", "return", "function", "(", ")", "{", "var", "old", "=", "instance", ".", "results", "[", "index", "]", ";", "instance", ".", "results", "[", "index", "]", "=", "tryExpr", "(", "func", ",", "context", ")", ";", "if", "(", "old", "===", "instance", ".", "results", "[", "index", "]", ")", "return", ";", "if", "(", "instance", ".", "dependenciesCount", "===", "1", "||", "!", "Interpolable", ".", "allowDelayedUpdate", ")", "callback", "(", "instance", ".", "output", "(", "context", ")", ",", "'set'", ")", ";", "else", "if", "(", "!", "instance", ".", "willFire", ")", "instance", ".", "willFire", "=", "context", ".", "delay", "(", "function", "(", ")", "{", "// call on nextTick to manage other dependencies update without multiple rerender", "if", "(", "instance", ".", "willFire", ")", "{", "instance", ".", "willFire", "=", "null", ";", "callback", "(", "instance", ".", "output", "(", "context", ")", ",", "'set'", ")", ";", "}", "}", ",", "0", ")", ";", "}", ";", "}" ]

[ "produce", "context", "s", "subscibtion", "event", "handler" ]

[ "function", "directOutput", "(", "context", ")", "{", "var", "o", "=", "tryExpr", "(", "this", ".", "parts", "[", "1", "]", ".", "func", ",", "context", ")", ";", "return", "(", "typeof", "o", "===", "'undefined'", "&&", "!", "this", ".", "_strict", ")", "?", "''", ":", "o", ";", "}" ]

[ "special", "case", "when", "interpolable", "is", "composed", "of", "only", "one", "expression", "with", "no", "text", "decoration", "return", "expr", "result", "directly" ]

[ "function", "(", "context", ",", "callback", ",", "binds", ")", "{", "var", "instance", "=", "new", "Instance", "(", "this", ")", ";", "var", "count", "=", "0", ",", "binded", "=", "false", ";", "for", "(", "var", "i", "=", "1", ",", "len", "=", "this", ".", "parts", ".", "length", ";", "i", "<", "len", ";", "i", "=", "i", "+", "2", ")", "{", "var", "block", "=", "this", ".", "parts", "[", "i", "]", ";", "if", "(", "block", ".", "binded", ")", "{", "binded", "=", "true", ";", "var", "h", "=", "handler", "(", "instance", ",", "context", ",", "block", ".", "func", ",", "count", ",", "callback", ")", ",", "dep", "=", "block", ".", "dep", ";", "for", "(", "var", "j", "=", "0", ",", "lenJ", "=", "dep", ".", "length", ";", "j", "<", "lenJ", ";", "j", "++", ")", "context", ".", "subscribe", "(", "dep", "[", "j", "]", ",", "h", ",", "false", ",", "instance", ".", "binds", ")", ";", "}", "count", "++", ";", "}", "if", "(", "binded", "&&", "binds", ")", "binds", ".", "push", "(", "unsub", "(", "instance", ")", ")", ";", "return", "instance", ";", "}" ]

[ "produce", "instance", "and", "bind", "to", "context" ]

[ "function", "(", "context", ")", "{", "if", "(", "this", ".", "directOutput", ")", "return", "this", ".", "directOutput", "(", "context", ")", ";", "var", "out", "=", "\"\"", ",", "odd", "=", "true", ",", "parts", "=", "this", ".", "parts", ";", "for", "(", "var", "j", "=", "0", ",", "len", "=", "parts", ".", "length", ";", "j", "<", "len", ";", "++", "j", ")", "{", "if", "(", "odd", ")", "out", "+=", "parts", "[", "j", "]", ";", "else", "{", "var", "r", "=", "tryExpr", "(", "parts", "[", "j", "]", ".", "func", ",", "context", ")", ";", "if", "(", "typeof", "r", "===", "'undefined'", ")", "{", "if", "(", "this", ".", "_strict", ")", "return", ";", "out", "+=", "''", ";", "}", "out", "+=", "r", ";", "}", "odd", "=", "!", "odd", ";", "}", "return", "out", ";", "}" ]

[ "output", "interpolable", "with", "given", "context" ]

[ "function", "tree", "(", "app", ",", "options", ")", "{", "var", "opts", "=", "extend", "(", "{", "}", ",", "options", ")", ";", "var", "node", "=", "{", "label", ":", "getLabel", "(", "app", ",", "opts", ")", ",", "metadata", ":", "getMetadata", "(", "app", ",", "opts", ")", "}", ";", "// get the names of the children to lookup", "var", "names", "=", "arrayify", "(", "opts", ".", "names", "||", "[", "'nodes'", "]", ")", ";", "return", "names", ".", "reduce", "(", "function", "(", "acc", ",", "name", ")", "{", "var", "children", "=", "app", "[", "name", "]", ";", "if", "(", "typeof", "children", "!==", "'object'", ")", "{", "return", "node", ";", "}", "// build a tree for each child node", "var", "nodes", "=", "[", "]", ";", "for", "(", "var", "key", "in", "children", ")", "{", "var", "child", "=", "children", "[", "key", "]", ";", "if", "(", "typeof", "child", "[", "opts", ".", "method", "]", "===", "'function'", ")", "{", "nodes", ".", "push", "(", "child", "[", "opts", ".", "method", "]", "(", "opts", ")", ")", ";", "}", "else", "{", "var", "res", "=", "tree", "(", "child", ",", "opts", ")", ";", "nodes", ".", "push", "(", "res", ")", ";", "}", "}", "if", "(", "nodes", ".", "length", ")", "{", "node", ".", "nodes", "=", "(", "node", ".", "nodes", "||", "[", "]", ")", ".", "concat", "(", "nodes", ")", ";", "}", "return", "node", ";", "}", ",", "node", ")", ";", "}" ]

[ "Default", "tree", "building", "function", ".", "Gets", "the", "label", "and", "metadata", "properties", "for", "the", "current", "app", "and", "recursively", "generates", "the", "child", "nodes", "and", "child", "trees", "if", "possible", "." ]

[ "function", "getLabel", "(", "app", ",", "options", ")", "{", "if", "(", "typeof", "options", ".", "getLabel", "===", "'function'", ")", "{", "return", "options", ".", "getLabel", "(", "app", ",", "options", ")", ";", "}", "return", "app", ".", "full_name", "||", "app", ".", "nickname", "||", "app", ".", "name", ";", "}" ]

[ "Figure", "out", "a", "label", "to", "add", "for", "a", "node", "in", "the", "tree", "." ]

[ "function", "(", "template", ",", "templateUrl", ")", "{", "var", "deferred", "=", "$q", ".", "defer", "(", ")", ";", "if", "(", "template", ")", "{", "deferred", ".", "resolve", "(", "template", ")", ";", "}", "else", "if", "(", "templateUrl", ")", "{", "// Check to see if the template has already been loaded.", "var", "cachedTemplate", "=", "$templateCache", ".", "get", "(", "templateUrl", ")", ";", "if", "(", "cachedTemplate", ")", "{", "deferred", ".", "resolve", "(", "cachedTemplate", ")", ";", "}", "else", "{", "// If not, let's grab the template for the first time.", "$http", ".", "get", "(", "templateUrl", ")", ".", "then", "(", "function", "(", "result", ")", "{", "// Save template into the cache and return the template.", "$templateCache", ".", "put", "(", "templateUrl", ",", "result", ".", "data", ")", ";", "deferred", ".", "resolve", "(", "result", ".", "data", ")", ";", "}", ",", "function", "(", "error", ")", "{", "deferred", ".", "reject", "(", "error", ")", ";", "}", ")", ";", "}", "}", "else", "{", "deferred", ".", "reject", "(", "'No template or templateUrl has been specified.'", ")", ";", "}", "return", "deferred", ".", "promise", ";", "}" ]

[ "Returns", "a", "promise", "which", "gets", "the", "template", "either", "from", "the", "template", "parameter", "or", "via", "a", "request", "to", "the", "templateUrl", "parameter", "." ]

[ "function", "(", "e", ")", "{", "this", ".", "touch", ".", "cur", "=", "'dragging'", ";", "var", "delta", "=", "0", ";", "if", "(", "this", ".", "touch", ".", "lastY", "&&", "(", "e", ".", "gesture", ".", "direction", "==", "'up'", "||", "e", ".", "gesture", ".", "direction", "==", "'down'", ")", ")", "{", "//tilt", "delta", "=", "e", ".", "gesture", ".", "deltaY", "-", "this", ".", "touch", ".", "lastY", ";", "this", ".", "angleX", "+=", "delta", ";", "}", "else", "if", "(", "this", ".", "touch", ".", "lastX", "&&", "(", "e", ".", "gesture", ".", "direction", "==", "'left'", "||", "e", ".", "gesture", ".", "direction", "==", "'right'", ")", ")", "{", "//pan", "delta", "=", "e", ".", "gesture", ".", "deltaX", "-", "this", ".", "touch", ".", "lastX", ";", "this", ".", "angleZ", "+=", "delta", ";", "}", "if", "(", "delta", ")", "this", ".", "onDraw", "(", ")", ";", "this", ".", "touch", ".", "lastX", "=", "e", ".", "gesture", ".", "deltaX", ";", "this", ".", "touch", ".", "lastY", "=", "e", ".", "gesture", ".", "deltaY", ";", "}" ]

[ "pan", "&", "tilt", "with", "one", "finger" ]

[ "function", "(", "e", ")", "{", "this", ".", "touch", ".", "cur", "=", "'shifting'", ";", "var", "factor", "=", "5e-3", ";", "var", "delta", "=", "0", ";", "if", "(", "this", ".", "touch", ".", "lastY", "&&", "(", "e", ".", "gesture", ".", "direction", "==", "'up'", "||", "e", ".", "gesture", ".", "direction", "==", "'down'", ")", ")", "{", "this", ".", "touch", ".", "shiftControl", ".", "removeClass", "(", "'shift-horizontal'", ")", ".", "addClass", "(", "'shift-vertical'", ")", ".", "css", "(", "'top'", ",", "e", ".", "gesture", ".", "center", ".", "pageY", "+", "'px'", ")", ";", "delta", "=", "e", ".", "gesture", ".", "deltaY", "-", "this", ".", "touch", ".", "lastY", ";", "this", ".", "viewpointY", "-=", "factor", "*", "delta", "*", "this", ".", "viewpointZ", ";", "this", ".", "angleX", "+=", "delta", ";", "}", "if", "(", "this", ".", "touch", ".", "lastX", "&&", "(", "e", ".", "gesture", ".", "direction", "==", "'left'", "||", "e", ".", "gesture", ".", "direction", "==", "'right'", ")", ")", "{", "this", ".", "touch", ".", "shiftControl", ".", "removeClass", "(", "'shift-vertical'", ")", ".", "addClass", "(", "'shift-horizontal'", ")", ".", "css", "(", "'left'", ",", "e", ".", "gesture", ".", "center", ".", "pageX", "+", "'px'", ")", ";", "delta", "=", "e", ".", "gesture", ".", "deltaX", "-", "this", ".", "touch", ".", "lastX", ";", "this", ".", "viewpointX", "+=", "factor", "*", "delta", "*", "this", ".", "viewpointZ", ";", "this", ".", "angleZ", "+=", "delta", ";", "}", "if", "(", "delta", ")", "this", ".", "onDraw", "(", ")", ";", "this", ".", "touch", ".", "lastX", "=", "e", ".", "gesture", ".", "deltaX", ";", "this", ".", "touch", ".", "lastY", "=", "e", ".", "gesture", ".", "deltaY", ";", "}" ]

[ "shift", "after", "0", ".", "5s", "touch&hold" ]

[ "function", "(", "initial_csg", ")", "{", "var", "csg", "=", "initial_csg", ".", "canonicalized", "(", ")", ";", "var", "mesh", "=", "new", "GL", ".", "Mesh", "(", "{", "normals", ":", "true", ",", "colors", ":", "true", "}", ")", ";", "var", "meshes", "=", "[", "mesh", "]", ";", "var", "vertexTag2Index", "=", "{", "}", ";", "var", "vertices", "=", "[", "]", ";", "var", "colors", "=", "[", "]", ";", "var", "triangles", "=", "[", "]", ";", "// set to true if we want to use interpolated vertex normals", "// this creates nice round spheres but does not represent the shape of", "// the actual model", "var", "smoothlighting", "=", "this", ".", "solid", ".", "smooth", ";", "var", "polygons", "=", "csg", ".", "toPolygons", "(", ")", ";", "var", "numpolygons", "=", "polygons", ".", "length", ";", "for", "(", "var", "j", "=", "0", ";", "j", "<", "numpolygons", ";", "j", "++", ")", "{", "var", "polygon", "=", "polygons", "[", "j", "]", ";", "var", "color", "=", "this", ".", "solid", ".", "color", ";", "// default color", "if", "(", "polygon", ".", "shared", "&&", "polygon", ".", "shared", ".", "color", ")", "{", "color", "=", "polygon", ".", "shared", ".", "color", ";", "}", "else", "if", "(", "polygon", ".", "color", ")", "{", "color", "=", "polygon", ".", "color", ";", "}", "if", "(", "color", ".", "length", "<", "4", ")", "color", ".", "push", "(", "1.", ")", ";", "//opaque", "var", "indices", "=", "polygon", ".", "vertices", ".", "map", "(", "function", "(", "vertex", ")", "{", "var", "vertextag", "=", "vertex", ".", "getTag", "(", ")", ";", "var", "vertexindex", "=", "vertexTag2Index", "[", "vertextag", "]", ";", "var", "prevcolor", "=", "colors", "[", "vertexindex", "]", ";", "if", "(", "smoothlighting", "&&", "(", "vertextag", "in", "vertexTag2Index", ")", "&&", "(", "prevcolor", "[", "0", "]", "==", "color", "[", "0", "]", ")", "&&", "(", "prevcolor", "[", "1", "]", "==", "color", "[", "1", "]", ")", "&&", "(", "prevcolor", "[", "2", "]", "==", "color", "[", "2", "]", ")", ")", "{", "vertexindex", "=", "vertexTag2Index", "[", "vertextag", "]", ";", "}", "else", "{", "vertexindex", "=", "vertices", ".", "length", ";", "vertexTag2Index", "[", "vertextag", "]", "=", "vertexindex", ";", "vertices", ".", "push", "(", "[", "vertex", ".", "pos", ".", "x", ",", "vertex", ".", "pos", ".", "y", ",", "vertex", ".", "pos", ".", "z", "]", ")", ";", "colors", ".", "push", "(", "color", ")", ";", "}", "return", "vertexindex", ";", "}", ")", ";", "for", "(", "var", "i", "=", "2", ";", "i", "<", "indices", ".", "length", ";", "i", "++", ")", "{", "triangles", ".", "push", "(", "[", "indices", "[", "0", "]", ",", "indices", "[", "i", "-", "1", "]", ",", "indices", "[", "i", "]", "]", ")", ";", "}", "// if too many vertices, start a new mesh;", "if", "(", "vertices", ".", "length", ">", "65000", ")", "{", "// finalize the old mesh", "mesh", ".", "triangles", "=", "triangles", ";", "mesh", ".", "vertices", "=", "vertices", ";", "mesh", ".", "colors", "=", "colors", ";", "mesh", ".", "computeWireframe", "(", ")", ";", "mesh", ".", "computeNormals", "(", ")", ";", "if", "(", "mesh", ".", "vertices", ".", "length", ")", "{", "meshes", ".", "push", "(", "mesh", ")", ";", "}", "// start a new mesh", "mesh", "=", "new", "GL", ".", "Mesh", "(", "{", "normals", ":", "true", ",", "colors", ":", "true", "}", ")", ";", "triangles", "=", "[", "]", ";", "colors", "=", "[", "]", ";", "vertices", "=", "[", "]", ";", "}", "}", "// finalize last mesh", "mesh", ".", "triangles", "=", "triangles", ";", "mesh", ".", "vertices", "=", "vertices", ";", "mesh", ".", "colors", "=", "colors", ";", "mesh", ".", "computeWireframe", "(", ")", ";", "mesh", ".", "computeNormals", "(", ")", ";", "if", "(", "mesh", ".", "vertices", ".", "length", ")", "{", "meshes", ".", "push", "(", "mesh", ")", ";", "}", "return", "meshes", ";", "}" ]

[ "Convert", "from", "CSG", "solid", "to", "an", "array", "of", "GL", ".", "Mesh", "objects", "limiting", "the", "number", "of", "vertices", "per", "mesh", "to", "less", "than", "2^16" ]

[ "function", "(", "err", ",", "objs", ")", "{", "that", ".", "worker", "=", "null", ";", "if", "(", "err", ")", "{", "that", ".", "setError", "(", "err", ")", ";", "that", ".", "setStatus", "(", "\"Error.\"", ")", ";", "that", ".", "state", "=", "3", ";", "// incomplete", "}", "else", "{", "that", ".", "setCurrentObjects", "(", "objs", ")", ";", "that", ".", "setStatus", "(", "\"Ready.\"", ")", ";", "that", ".", "state", "=", "2", ";", "// complete", "}", "that", ".", "enableItems", "(", ")", ";", "}" ]

[ "handle", "the", "results" ]

[ "function", "runBranch", "(", "index", ",", "options", ")", "{", "var", "{", "tree", ",", "signal", ",", "start", ",", "promise", "}", "=", "options", ";", "var", "currentBranch", "=", "tree", ".", "branches", "[", "index", "]", ";", "if", "(", "!", "currentBranch", "&&", "tree", ".", "branches", "===", "signal", ".", "branches", ")", "{", "if", "(", "tree", ".", "branches", "[", "index", "-", "1", "]", ")", "{", "tree", ".", "branches", "[", "index", "-", "1", "]", ".", "duration", "=", "Date", ".", "now", "(", ")", "-", "start", ";", "}", "signal", ".", "isExecuting", "=", "false", ";", "if", "(", "promise", ")", "{", "promise", ".", "resolve", "(", "signal", ")", ";", "}", "return", ";", "}", "if", "(", "!", "currentBranch", ")", "{", "return", ";", "}", "if", "(", "Array", ".", "isArray", "(", "currentBranch", ")", ")", "{", "return", "runAsyncBranch", "(", "index", ",", "currentBranch", ",", "options", ")", ";", "}", "else", "{", "return", "runSyncBranch", "(", "index", ",", "currentBranch", ",", "options", ")", ";", "}", "}" ]

[ "Run", "tree", "branch", "or", "resolve", "signal", "if", "no", "more", "branches", "in", "recursion", "." ]

[ "function", "runAsyncBranch", "(", "index", ",", "currentBranch", ",", "options", ")", "{", "var", "{", "tree", ",", "args", ",", "signal", ",", "state", ",", "promise", ",", "start", ",", "services", "}", "=", "options", ";", "var", "promises", "=", "currentBranch", ".", "map", "(", "action", "=>", "{", "var", "actionFunc", "=", "tree", ".", "actions", "[", "action", ".", "actionIndex", "]", ";", "var", "actionArgs", "=", "createActionArgs", "(", "args", ",", "action", ",", "state", ",", "true", ")", ";", "var", "outputs", "=", "action", ".", "outputs", "?", "Object", ".", "keys", "(", "action", ".", "outputs", ")", ":", "[", "]", ";", "action", ".", "isExecuting", "=", "true", ";", "action", ".", "args", "=", "merge", "(", "{", "}", ",", "args", ")", ";", "var", "nextActionPromise", ";", "var", "foundResult", "=", "signal", ".", "asyncActionResults", ".", "find", "(", "(", "result", ")", "=>", "isEqualArrays", "(", "result", ".", "outputPath", ",", "action", ".", "path", ")", ")", ";", "// If actions results provided, you run it in replay mode", "if", "(", "foundResult", ")", "{", "nextActionPromise", "=", "Promise", ".", "resolve", "(", "foundResult", ")", ";", "}", "else", "{", "var", "next", "=", "createNextAsyncAction", "(", "actionFunc", ",", "outputs", ")", ";", "actionFunc", ".", "apply", "(", "null", ",", "actionArgs", ".", "concat", "(", "next", ".", "fn", ",", "services", ")", ")", ";", "nextActionPromise", "=", "next", ".", "promise", ";", "}", "return", "nextActionPromise", ".", "then", "(", "result", "=>", "{", "action", ".", "hasExecuted", "=", "true", ";", "action", ".", "isExecuting", "=", "false", ";", "action", ".", "output", "=", "result", ".", "args", ";", "// Save short results snippet for replay", "signal", ".", "asyncActionResults", ".", "push", "(", "{", "outputPath", ":", "action", ".", "path", ",", "path", ":", "result", ".", "path", ",", "args", ":", "result", ".", "args", "}", ")", ";", "merge", "(", "args", ",", "result", ".", "args", ")", ";", "if", "(", "result", ".", "path", ")", "{", "action", ".", "outputPath", "=", "result", ".", "path", ";", "var", "output", "=", "action", ".", "outputs", "[", "result", ".", "path", "]", ";", "return", "runBranch", "(", "0", ",", "{", "args", ",", "signal", ",", "state", ",", "start", ",", "promise", ",", "services", ",", "tree", ":", "{", "actions", ":", "tree", ".", "actions", ",", "branches", ":", "output", "}", "}", ")", ";", "}", "}", ")", ".", "catch", "(", "(", "e", ")", "=>", "promise", ".", "reject", "(", "e", ")", ")", ";", "}", ")", ";", "return", "Promise", ".", "all", "(", "promises", ")", ".", "then", "(", "(", ")", "=>", "runBranch", "(", "index", "+", "1", ",", "options", ")", ")", ";", "}" ]

[ "Run", "async", "branch" ]

[ "function", "runSyncBranch", "(", "index", ",", "currentBranch", ",", "options", ")", "{", "var", "{", "args", ",", "tree", ",", "signal", ",", "state", ",", "start", ",", "promise", ",", "services", "}", "=", "options", ";", "try", "{", "var", "action", "=", "currentBranch", ";", "var", "actionFunc", "=", "tree", ".", "actions", "[", "action", ".", "actionIndex", "]", ";", "var", "actionArgs", "=", "createActionArgs", "(", "args", ",", "action", ",", "state", ",", "false", ")", ";", "var", "outputs", "=", "action", ".", "outputs", "?", "Object", ".", "keys", "(", "action", ".", "outputs", ")", ":", "[", "]", ";", "action", ".", "mutations", "=", "[", "]", ";", "action", ".", "args", "=", "merge", "(", "{", "}", ",", "args", ")", ";", "var", "next", "=", "createNextSyncAction", "(", "actionFunc", ",", "outputs", ")", ";", "actionFunc", ".", "apply", "(", "null", ",", "actionArgs", ".", "concat", "(", "next", ",", "services", ")", ")", ";", "var", "result", "=", "next", ".", "_result", "||", "{", "}", ";", "merge", "(", "args", ",", "result", ".", "args", ")", ";", "action", ".", "isExecuting", "=", "false", ";", "action", ".", "hasExecuted", "=", "true", ";", "action", ".", "output", "=", "result", ".", "args", ";", "if", "(", "result", ".", "path", ")", "{", "action", ".", "outputPath", "=", "result", ".", "path", ";", "var", "output", "=", "action", ".", "outputs", "[", "result", ".", "path", "]", ";", "var", "runResult", "=", "runBranch", "(", "0", ",", "{", "args", ",", "signal", ",", "state", ",", "start", ",", "promise", ",", "services", ",", "tree", ":", "{", "actions", ":", "tree", ".", "actions", ",", "branches", ":", "output", "}", "}", ")", ";", "if", "(", "runResult", "&&", "runResult", ".", "then", ")", "{", "return", "runResult", ".", "then", "(", "(", ")", "=>", "{", "return", "runBranch", "(", "index", "+", "1", ",", "options", ")", ";", "}", ")", ";", "}", "return", "runBranch", "(", "index", "+", "1", ",", "options", ")", ";", "}", "return", "runBranch", "(", "index", "+", "1", ",", "options", ")", ";", "}", "catch", "(", "e", ")", "{", "promise", ".", "reject", "(", "e", ")", ";", "}", "}" ]

[ "Run", "sync", "branch" ]

[ "function", "addOutputs", "(", "next", ",", "outputs", ")", "{", "if", "(", "Array", ".", "isArray", "(", "outputs", ")", ")", "{", "outputs", ".", "forEach", "(", "key", "=>", "{", "next", "[", "key", "]", "=", "next", ".", "bind", "(", "null", ",", "key", ")", ";", "}", ")", ";", "}", "return", "next", ";", "}" ]

[ "Add", "output", "paths", "to", "next", "function", "." ]

[ "function", "createNextFunction", "(", "action", ",", "resolver", ")", "{", "return", "function", "next", "(", "...", "args", ")", "{", "var", "path", "=", "typeof", "args", "[", "0", "]", "===", "'string'", "?", "args", "[", "0", "]", ":", "null", ";", "var", "arg", "=", "path", "?", "args", "[", "1", "]", ":", "args", "[", "0", "]", ";", "var", "result", "=", "{", "path", ":", "path", "?", "path", ":", "action", ".", "defaultOutput", ",", "args", ":", "arg", "}", ";", "if", "(", "resolver", ")", "{", "resolver", "(", "result", ")", ";", "}", "else", "{", "next", ".", "_result", "=", "result", ";", "}", "}", ";", "}" ]

[ "Create", "next", "function", "in", "signal", "chain", ".", "It", "s", "unified", "method", "for", "async", "and", "sync", "actions", "." ]

[ "function", "getStateMutatorsAndAccessors", "(", "state", ",", "action", ",", "isAsync", ")", "{", "var", "mutators", "=", "[", "'apply'", ",", "'concat'", ",", "'deepMerge'", ",", "'push'", ",", "'merge'", ",", "'unset'", ",", "'set'", ",", "'splice'", ",", "'unshift'", "]", ";", "var", "accessors", "=", "[", "'get'", ",", "'exists'", "]", ";", "var", "methods", "=", "[", "]", ";", "if", "(", "isAsync", ")", "{", "methods", "=", "methods", ".", "concat", "(", "accessors", ")", ";", "}", "else", "{", "methods", "=", "methods", ".", "concat", "(", "mutators", ")", ";", "methods", "=", "methods", ".", "concat", "(", "accessors", ")", ";", "}", "return", "methods", ".", "reduce", "(", "(", "stateMethods", ",", "methodName", ")", "=>", "{", "var", "method", "=", "state", "[", "methodName", "]", ".", "bind", "(", "state", ")", ";", "stateMethods", "[", "methodName", "]", "=", "(", "...", "args", ")", "=>", "{", "var", "path", "=", "[", "]", ";", "var", "firstArg", "=", "args", "[", "0", "]", ";", "if", "(", "Array", ".", "isArray", "(", "firstArg", ")", ")", "{", "path", "=", "args", ".", "shift", "(", ")", ";", "}", "else", "if", "(", "typeof", "firstArg", "===", "'string'", ")", "{", "path", "=", "[", "args", ".", "shift", "(", ")", "]", ";", "}", "if", "(", "args", ".", "length", "===", "0", ")", "{", "return", "method", ".", "apply", "(", "null", ",", "[", "path", ".", "slice", "(", ")", "]", ")", ";", "}", "action", ".", "mutations", ".", "push", "(", "{", "name", ":", "methodName", ",", "path", ":", "path", ".", "slice", "(", ")", ",", "args", ":", "args", "}", ")", ";", "return", "method", ".", "apply", "(", "null", ",", "[", "path", ".", "slice", "(", ")", "]", ".", "concat", "(", "args", ")", ")", ";", "}", ";", "return", "stateMethods", ";", "}", ",", "Object", ".", "create", "(", "null", ")", ")", ";", "}" ]

[ "Get", "state", "mutators", "and", "accessors", "Each", "mutation", "will", "save", "in", "action", "descriptor", ".", "This", "method", "allow", "add", "ability", "to", "gather", "information", "about", "call", "every", "function", "." ]

[ "function", "staticTree", "(", "signalActions", ")", "{", "var", "actions", "=", "[", "]", ";", "var", "branches", "=", "transformBranch", "(", "signalActions", ",", "[", "]", ",", "[", "]", ",", "actions", ",", "false", ")", ";", "return", "{", "actions", ",", "branches", "}", ";", "}" ]

[ "Transform", "signal", "actions", "to", "static", "tree", ".", "Every", "function", "will", "be", "exposed", "as", "object", "definition", "that", "will", "store", "meta", "information", "and", "function", "call", "results", "." ]

[ "function", "transformBranch", "(", "action", ",", "...", "args", ")", "{", "return", "Array", ".", "isArray", "(", "action", ")", "?", "transformAsyncBranch", ".", "apply", "(", "null", ",", "[", "action", ",", "...", "args", "]", ")", ":", "transformSyncBranch", ".", "apply", "(", "null", ",", "[", "action", ",", "...", "args", "]", ")", ";", "}" ]

[ "Transform", "tree", "branch" ]

[ "function", "transformAsyncBranch", "(", "action", ",", "parentAction", ",", "path", ",", "actions", ",", "isSync", ")", "{", "action", "=", "action", ".", "slice", "(", ")", ";", "isSync", "=", "!", "isSync", ";", "return", "action", ".", "map", "(", "(", "subAction", ",", "index", ")", "=>", "{", "path", ".", "push", "(", "index", ")", ";", "var", "result", "=", "transformBranch", "(", "subAction", ",", "action", ",", "path", ",", "actions", ",", "isSync", ")", ";", "path", ".", "pop", "(", ")", ";", "return", "result", ";", "}", ")", ".", "filter", "(", "branch", "=>", "!", "!", "branch", ")", ";", "}" ]

[ "Transform", "action", "to", "async", "branch" ]

[ "function", "transformSyncBranch", "(", "action", ",", "parentAction", ",", "path", ",", "actions", ",", "isSync", ")", "{", "var", "branch", "=", "{", "name", ":", "getFunctionName", "(", "action", ")", ",", "args", ":", "{", "}", ",", "output", ":", "null", ",", "duration", ":", "0", ",", "mutations", ":", "[", "]", ",", "isAsync", ":", "!", "isSync", ",", "outputPath", ":", "null", ",", "isExecuting", ":", "false", ",", "hasExecuted", ":", "false", ",", "path", ":", "path", ".", "slice", "(", ")", ",", "outputs", ":", "null", ",", "actionIndex", ":", "actions", ".", "indexOf", "(", "action", ")", "===", "-", "1", "?", "actions", ".", "push", "(", "action", ")", "-", "1", ":", "actions", ".", "indexOf", "(", "action", ")", "}", ";", "var", "nextAction", "=", "parentAction", "[", "parentAction", ".", "indexOf", "(", "action", ")", "+", "1", "]", ";", "if", "(", "!", "Array", ".", "isArray", "(", "nextAction", ")", "&&", "typeof", "nextAction", "===", "'object'", ")", "{", "parentAction", ".", "splice", "(", "parentAction", ".", "indexOf", "(", "nextAction", ")", ",", "1", ")", ";", "branch", ".", "outputs", "=", "Object", ".", "keys", "(", "nextAction", ")", ".", "reduce", "(", "(", "paths", ",", "key", ")", "=>", "{", "path", "=", "path", ".", "concat", "(", "'outputs'", ",", "key", ")", ";", "paths", "[", "key", "]", "=", "transformBranch", "(", "nextAction", "[", "key", "]", ",", "parentAction", ",", "path", ",", "actions", ",", "false", ")", ";", "path", ".", "pop", "(", ")", ";", "path", ".", "pop", "(", ")", ";", "return", "paths", ";", "}", ",", "{", "}", ")", ";", "}", "return", "branch", ";", "}" ]

[ "Transform", "action", "to", "sync", "branch" ]

[ "function", "analyze", "(", "actions", ")", "{", "if", "(", "!", "Array", ".", "isArray", "(", "actions", ")", ")", "{", "throw", "new", "Error", "(", "'State: Signal actions should be array'", ")", ";", "}", "actions", ".", "forEach", "(", "(", "action", ",", "index", ")", "=>", "{", "if", "(", "typeof", "action", "===", "'undefined'", "||", "typeof", "action", "===", "'string'", ")", "{", "throw", "new", "Error", "(", "`", "${", "index", "}", "`", ")", ";", "}", "if", "(", "Array", ".", "isArray", "(", "action", ")", ")", "{", "analyze", "(", "action", ")", ";", "}", "else", "if", "(", "Object", ".", "prototype", ".", "toString", ".", "call", "(", "action", ")", "===", "\"[object Object]\"", ")", "{", "Object", ".", "keys", "(", "action", ")", ".", "forEach", "(", "function", "(", "output", ")", "{", "analyze", "(", "action", "[", "output", "]", ")", ";", "}", ")", ";", "}", "}", ")", ";", "}" ]

[ "Analyze", "actions", "for", "errors" ]

[ "function", "getFunctionName", "(", "fn", ")", "{", "var", "name", "=", "fn", ".", "toString", "(", ")", ";", "name", "=", "name", ".", "substr", "(", "'function '", ".", "length", ")", ";", "name", "=", "name", ".", "substr", "(", "0", ",", "name", ".", "indexOf", "(", "'('", ")", ")", ";", "return", "name", ";", "}" ]

[ "Get", "function", "name" ]

[ "function", "Player", "(", "params", ")", "{", "this", ".", "platformID", "=", "this", ".", "key", "=", "params", ".", "key", ";", "this", ".", "kills", "=", "params", ".", "kills", ";", "this", ".", "deaths", "=", "params", ".", "deaths", ";", "this", ".", "name", "=", "params", ".", "name", ";", "this", ".", "rank", "=", "params", ".", "rank", ";", "this", ".", "weapon", "=", "params", ".", "weapon", ";", "}" ]

[ "a", "leetcoin", "player" ]

[ "function", "Cms", "(", "module", ",", "with_app", ")", "{", "if", "(", "!", "module", ")", "throw", "new", "Error", "(", "'Requires a module'", ")", ";", "if", "(", "!", "module", ".", "config", ")", "throw", "new", "Error", "(", "'Module requires config'", ")", ";", "if", "(", "!", "module", ".", "config", ".", "name", ")", "logger", ".", "info", "(", "'No name specified in config. Calling it null.'", ")", "if", "(", "!", "module", ".", "config", ".", "mongoConnectString", ")", "throw", "new", "Error", "(", "'Config requires mongoConnectString'", ")", ";", "if", "(", "!", "module", ".", "models", ")", "throw", "new", "Error", "(", "'Module requires models'", ")", ";", "// module info and shortcut to configuration", "this", ".", "module", "=", "module", ";", "this", ".", "config", "=", "module", ".", "config", ";", "// connection to mongo", "this", ".", "connection", "=", "null", ";", "// the storage client", "this", ".", "client", "=", "null", ";", "// gridfs storage (untested)", "this", ".", "gfs", "=", "null", ";", "// the express app", "this", ".", "app", "=", "null", ";", "// login, logout", "this", ".", "auth", "=", "null", ";", "// meta info for models", "this", ".", "meta", "=", "null", ";", "// guard manages view permissions", "this", ".", "guard", "=", "null", ";", "// workflow provides state transition info to view", "this", ".", "workflow", "=", "null", ";", "logger", ".", "info", "(", "'cms init'", ")", ";", "//process.nextTick(this._init.bind(this));", "this", ".", "_init", "(", "with_app", "===", "undefined", "?", "true", ":", "with_app", ")", ";", "}" ]

[ "Construct", "the", "Cms", "with", "a", "module", ".", "Cms", "ready", "modules", "must", "export", "at", "least", "models", "and", "config", "." ]

[ "function", "handlePromise", "(", "query", ",", "q", ",", "model", ",", "resultsPerPage", ")", "{", "return", "Promise", ".", "all", "(", "[", "query", ".", "exec", "(", ")", ",", "model", ".", "count", "(", "q", ")", ".", "exec", "(", ")", "]", ")", ".", "spread", "(", "function", "(", "results", ",", "count", ")", "{", "return", "[", "results", ",", "Math", ".", "ceil", "(", "count", "/", "resultsPerPage", ")", "||", "1", ",", "count", "]", "}", ")", ";", "}" ]

[ "Return", "a", "promise", "with", "results" ]

[ "function", "handleCallback", "(", "query", ",", "q", ",", "model", ",", "resultsPerPage", ",", "callback", ")", "{", "return", "async", ".", "parallel", "(", "{", "results", ":", "function", "(", "callback", ")", "{", "query", ".", "exec", "(", "callback", ")", ";", "}", ",", "count", ":", "function", "(", "callback", ")", "{", "model", ".", "count", "(", "q", ",", "function", "(", "err", ",", "count", ")", "{", "callback", "(", "err", ",", "count", ")", ";", "}", ")", ";", "}", "}", ",", "function", "(", "error", ",", "data", ")", "{", "if", "(", "error", ")", "{", "return", "callback", "(", "error", ")", ";", "}", "callback", "(", "null", ",", "data", ".", "results", ",", "Math", ".", "ceil", "(", "data", ".", "count", "/", "resultsPerPage", ")", "||", "1", ",", "data", ".", "count", ")", ";", "}", ")", ";", "}" ]

[ "Call", "callback", "function", "passed", "with", "results" ]

[ "function", "foreachInDir", "(", "dirpath", ",", "fnc", ",", "done", ")", "{", "// Read the files", "fs", ".", "readdir", "(", "dirpath", ",", "function", "(", "err", ",", "files", ")", "{", "// Return error", "if", "(", "err", ")", "{", "return", "done", "(", "err", ")", ";", "}", "// Process each file", "parallel", "(", "files", ".", "map", "(", "function", "(", "f", ")", "{", "return", "fnc", ".", "bind", "(", "null", ",", "f", ")", ";", "}", ")", ",", "done", ")", ";", "}", ")", ";", "}" ]

[ "Execute", "a", "callback", "for", "each", "file", "in", "a", "directory" ]

[ "function", "rdf", "(", "argv", ",", "callback", ")", "{", "var", "command", "=", "argv", "[", "2", "]", ";", "var", "exec", ";", "if", "(", "!", "command", ")", "{", "console", ".", "log", "(", "'rdf help for command list'", ")", ";", "process", ".", "exit", "(", "-", "1", ")", ";", "}", "try", "{", "exec", "=", "require", "(", "'./bin/'", "+", "command", "+", "'.js'", ")", ";", "}", "catch", "(", "err", ")", "{", "console", ".", "error", "(", "command", "+", "': command not found'", ")", ";", "process", ".", "exit", "(", "-", "1", ")", ";", "}", "argv", ".", "splice", "(", "2", ",", "1", ")", ";", "exec", "(", "argv", ",", "callback", ")", ";", "}" ]

[ "rdf", "calls", "child", "script" ]

[ "function", "bin", "(", ")", "{", "rdf", "(", "process", ".", "argv", ",", "function", "(", "err", ",", "res", ")", "{", "if", "(", "Array", ".", "isArray", "(", "res", ")", ")", "{", "for", "(", "var", "i", "=", "0", ";", "i", "<", "res", ".", "length", ";", "i", "++", ")", "{", "console", ".", "log", "(", "res", "[", "i", "]", ")", ";", "}", "}", "else", "{", "console", ".", "log", "(", "res", ")", ";", "}", "}", ")", ";", "}" ]

[ "rdf", "as", "a", "command" ]

[ "function", "update", "(", "options", ")", "{", "var", "reqOpt", "=", "{", "host", ":", "url", ".", "parse", "(", "options", ".", "updateVersionURL", ")", ".", "host", ",", "uri", ":", "url", ".", "parse", "(", "options", ".", "updateVersionURL", ")", ",", "path", ":", "url", ".", "parse", "(", "options", ".", "updateVersionURL", ")", ".", "pathname", ",", "port", ":", "options", ".", "port", "}", ";", "options", ".", "error", "=", "options", ".", "error", "||", "function", "(", ")", "{", "}", ";", "options", ".", "success", "=", "options", ".", "success", "||", "function", "(", ")", "{", "}", ";", "doLog", "=", "options", ".", "log", "||", "false", ";", "log", "(", "doLog", ")", ";", "_handleUpdateProcess", "(", "reqOpt", ",", "options", ")", ";", "}" ]

[ "parses", "the", "given", "URL", "and", "passes", "to", "handler" ]

[ "function", "(", "start", ",", "end", ",", "query", ")", "{", "//console.log(\"deep.store.Collection.range : \", start, end, query);", "var", "res", "=", "null", ";", "var", "total", "=", "0", ";", "query", "=", "query", "||", "\"\"", ";", "return", "deep", ".", "when", "(", "this", ".", "get", "(", "query", ")", ")", ".", "done", "(", "function", "(", "res", ")", "{", "total", "=", "res", ".", "length", ";", "if", "(", "typeof", "start", "===", "'string'", ")", "start", "=", "parseInt", "(", "start", ")", ";", "if", "(", "typeof", "end", "===", "'string'", ")", "end", "=", "parseInt", "(", "end", ")", ";", "start", "=", "Math", ".", "min", "(", "start", ",", "total", ")", ";", "res", "=", "res", ".", "slice", "(", "start", ",", "end", "+", "1", ")", ";", "end", "=", "start", "+", "res", ".", "length", "-", "1", ";", "query", "+=", "\"&limit(\"", "+", "(", "res", ".", "length", ")", "+", "\",\"", "+", "start", "+", "\")\"", ";", "return", "ranger", ".", "createRangeObject", "(", "start", ",", "end", ",", "total", ",", "res", ".", "length", ",", "deep", ".", "utils", ".", "copy", "(", "res", ")", ",", "query", ")", ";", "}", ")", ";", "}" ]

[ "select", "a", "range", "in", "collection" ]

[ "function", "(", "lintFile", ")", "{", "var", "deferred", "=", "new", "Deferred", "(", ")", ";", "parseJslintXml", "(", "lintFile", ",", "function", "(", "err", ",", "lintErrors", ")", "{", "if", "(", "lintErrors", ")", "{", "deferred", ".", "resolve", "(", "lintErrors", ")", ";", "}", "else", "{", "if", "(", "err", "&&", "err", ".", "code", "===", "'ENOENT'", ")", "{", "console", ".", "warn", "(", "'No jslint xml file found at:'", ",", "lintFile", ")", ";", "}", "else", "if", "(", "err", ")", "{", "console", ".", "log", "(", "err", ")", ";", "}", "deferred", ".", "reject", "(", ")", ";", "}", "}", ")", ";", "return", "deferred", ".", "promise", ";", "}" ]

[ "Get", "the", "lint", "errors", "from", "an", "jslint", "xml", "file", ".", "o" ]

[ "function", "(", "lintFile", ",", "callback", ")", "{", "fs", ".", "readFile", "(", "lintFile", ",", "function", "(", "err", ",", "data", ")", "{", "if", "(", "err", ")", "{", "callback", "(", "err", ")", ";", "}", "else", "{", "var", "parser", "=", "new", "xml2js", ".", "Parser", "(", "{", "mergeAttrs", ":", "true", "}", ")", ";", "parser", ".", "parseString", "(", "data", ",", "function", "(", "err", ",", "result", ")", "{", "if", "(", "err", ")", "{", "callback", "(", "err", ")", ";", "}", "else", "if", "(", "result", "&&", "result", ".", "jslint", ")", "{", "callback", "(", "null", ",", "result", ".", "jslint", ".", "file", ")", ";", "}", "else", "{", "callback", "(", "'Invalid jslint xml file'", ")", ";", "}", "}", ")", ";", "}", "}", ")", ";", "}" ]

[ "Parse", "a", "jslint", "xml", "report", "." ]

[ "function", "(", "req", ",", "res", ",", "lintErrors", ")", "{", "var", "html", "=", "template", "(", "{", "lintErrors", ":", "lintErrors", "}", ")", ";", "res", ".", "end", "(", "html", ")", ";", "}" ]

[ "Render", "the", "error", "report", "." ]

[ "function", "(", "predicate", ",", "asyncFunction", ")", "{", "if", "(", "predicate", "(", ")", ")", "{", "return", "asyncFunction", "(", ")", ".", "then", "(", "function", "(", ")", "{", "return", "Parse", ".", "Promise", ".", "_continueWhile", "(", "predicate", ",", "asyncFunction", ")", ";", "}", ")", ";", "}", "return", "Parse", ".", "Promise", ".", "as", "(", ")", ";", "}" ]

[ "Runs", "the", "given", "asyncFunction", "repeatedly", "as", "long", "as", "the", "predicate", "function", "returns", "a", "truthy", "value", ".", "Stops", "repeating", "if", "asyncFunction", "returns", "a", "rejected", "promise", "." ]

[ "function", "(", "resolvedCallback", ",", "rejectedCallback", ")", "{", "var", "promise", "=", "new", "Parse", ".", "Promise", "(", ")", ";", "var", "wrappedResolvedCallback", "=", "function", "(", ")", "{", "var", "result", "=", "arguments", ";", "if", "(", "resolvedCallback", ")", "{", "result", "=", "[", "resolvedCallback", ".", "apply", "(", "this", ",", "result", ")", "]", ";", "}", "if", "(", "result", ".", "length", "===", "1", "&&", "Parse", ".", "Promise", ".", "is", "(", "result", "[", "0", "]", ")", ")", "{", "result", "[", "0", "]", ".", "then", "(", "function", "(", ")", "{", "promise", ".", "resolve", ".", "apply", "(", "promise", ",", "arguments", ")", ";", "}", ",", "function", "(", "error", ")", "{", "promise", ".", "reject", "(", "error", ")", ";", "}", ")", ";", "}", "else", "{", "promise", ".", "resolve", ".", "apply", "(", "promise", ",", "result", ")", ";", "}", "}", ";", "var", "wrappedRejectedCallback", "=", "function", "(", "error", ")", "{", "var", "result", "=", "[", "]", ";", "if", "(", "rejectedCallback", ")", "{", "result", "=", "[", "rejectedCallback", "(", "error", ")", "]", ";", "if", "(", "result", ".", "length", "===", "1", "&&", "Parse", ".", "Promise", ".", "is", "(", "result", "[", "0", "]", ")", ")", "{", "result", "[", "0", "]", ".", "then", "(", "function", "(", ")", "{", "promise", ".", "resolve", ".", "apply", "(", "promise", ",", "arguments", ")", ";", "}", ",", "function", "(", "error", ")", "{", "promise", ".", "reject", "(", "error", ")", ";", "}", ")", ";", "}", "else", "{", "// A Promises/A+ compliant implementation would call:", "// promise.resolve.apply(promise, result);", "promise", ".", "reject", "(", "result", "[", "0", "]", ")", ";", "}", "}", "else", "{", "promise", ".", "reject", "(", "error", ")", ";", "}", "}", ";", "if", "(", "this", ".", "_resolved", ")", "{", "wrappedResolvedCallback", ".", "apply", "(", "this", ",", "this", ".", "_result", ")", ";", "}", "else", "if", "(", "this", ".", "_rejected", ")", "{", "wrappedRejectedCallback", "(", "this", ".", "_error", ")", ";", "}", "else", "{", "this", ".", "_resolvedCallbacks", ".", "push", "(", "wrappedResolvedCallback", ")", ";", "this", ".", "_rejectedCallbacks", ".", "push", "(", "wrappedRejectedCallback", ")", ";", "}", "return", "promise", ";", "}" ]

[ "Adds", "callbacks", "to", "be", "called", "when", "this", "promise", "is", "fulfilled", ".", "Returns", "a", "new", "Promise", "that", "will", "be", "fulfilled", "when", "the", "callback", "is", "complete", ".", "It", "allows", "chaining", ".", "If", "the", "callback", "itself", "returns", "a", "Promise", "then", "the", "one", "returned", "by", "then", "will", "not", "be", "fulfilled", "until", "that", "one", "returned", "by", "the", "callback", "is", "fulfilled", "." ]

[ "function", "(", "optionsOrCallback", ",", "model", ")", "{", "var", "options", ";", "if", "(", "_", ".", "isFunction", "(", "optionsOrCallback", ")", ")", "{", "var", "callback", "=", "optionsOrCallback", ";", "options", "=", "{", "success", ":", "function", "(", "result", ")", "{", "callback", "(", "result", ",", "null", ")", ";", "}", ",", "error", ":", "function", "(", "error", ")", "{", "callback", "(", "null", ",", "error", ")", ";", "}", "}", ";", "}", "else", "{", "options", "=", "_", ".", "clone", "(", "optionsOrCallback", ")", ";", "}", "options", "=", "options", "||", "{", "}", ";", "return", "this", ".", "then", "(", "function", "(", "result", ")", "{", "if", "(", "options", ".", "success", ")", "{", "options", ".", "success", ".", "apply", "(", "this", ",", "arguments", ")", ";", "}", "else", "if", "(", "model", ")", "{", "// When there's no callback, a sync event should be triggered.", "model", ".", "trigger", "(", "'sync'", ",", "model", ",", "result", ",", "options", ")", ";", "}", "return", "Parse", ".", "Promise", ".", "as", ".", "apply", "(", "Parse", ".", "Promise", ",", "arguments", ")", ";", "}", ",", "function", "(", "error", ")", "{", "if", "(", "options", ".", "error", ")", "{", "if", "(", "!", "_", ".", "isUndefined", "(", "model", ")", ")", "{", "options", ".", "error", "(", "model", ",", "error", ")", ";", "}", "else", "{", "options", ".", "error", "(", "error", ")", ";", "}", "}", "else", "if", "(", "model", ")", "{", "// When there's no error callback, an error event should be triggered.", "model", ".", "trigger", "(", "'error'", ",", "model", ",", "error", ",", "options", ")", ";", "}", "// By explicitly returning a rejected Promise, this will work with", "// either jQuery or Promises/A semantics.", "return", "Parse", ".", "Promise", ".", "error", "(", "error", ")", ";", "}", ")", ";", "}" ]

[ "Run", "the", "given", "callbacks", "after", "this", "promise", "is", "fulfilled", "." ]

[ "function", "(", "s", ")", "{", "if", "(", "s", ".", "match", "(", "/", "\\.", "/", ")", ")", "{", "var", "l", "=", "s", ".", "split", "(", "/", "\\.", "/", ")", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "l", ".", "length", "-", "1", ";", "i", "++", ")", "{", "l", "[", "i", "]", "=", "'_children.'", "+", "l", "[", "i", "]", ";", "}", "return", "l", ".", "join", "(", "'.'", ")", ";", "}", "else", "{", "return", "s", ";", "}", "}" ]

[ "If", "there", "are", ".", "then", "some", "children", "records", "are", "being", "referenced", ".", "The", "actual", "way", "they", "are", "placed", "in", "the", "record", "is", "in", "_children", ";", "so", "add", "_children", "where", "needed", "." ]

[ "function", "(", "filters", ",", "fieldPrefix", ",", "selectorWithoutBells", ")", "{", "return", "{", "querySelector", ":", "this", ".", "_makeMongoConditions", "(", "filters", ".", "conditions", "||", "{", "}", ",", "fieldPrefix", ",", "selectorWithoutBells", ")", ",", "sortHash", ":", "this", ".", "_makeMongoSortHash", "(", "filters", ".", "sort", "||", "{", "}", ",", "fieldPrefix", ")", "}", ";", "}" ]

[ "Make", "parameters", "for", "queries", ".", "It", "s", "the", "equivalent", "of", "what", "would", "be", "an", "SQL", "creator", "for", "a", "SQL", "layer" ]

[ "function", "(", "cb", ")", "{", "if", "(", "!", "self", ".", "positionField", ")", "{", "cb", "(", "null", ")", ";", "}", "else", "{", "// If repositioning is required, do it", "if", "(", "self", ".", "positionField", ")", "{", "var", "where", ",", "beforeId", ";", "if", "(", "!", "options", ".", "position", ")", "{", "where", "=", "'end'", ";", "}", "else", "{", "where", "=", "options", ".", "position", ".", "where", ";", "beforeId", "=", "options", ".", "position", ".", "beforeId", ";", "}", "self", ".", "reposition", "(", "recordWithLookups", ",", "where", ",", "beforeId", ",", "cb", ")", ";", "}", "}", "}" ]

[ "This", "will", "get", "called", "shortly", ".", "Bypasses", "straight", "to", "callback", "or", "calls", "reposition", "with", "right", "parameters", "and", "then", "calls", "callback" ]

[ "function", "(", "state", ")", "{", "if", "(", "this", ".", "_", ".", "state", "==", "state", ")", "return", "false", ";", "this", ".", "_", ".", "state", "=", "state", ";", "var", "element", "=", "CKEDITOR", ".", "document", ".", "getById", "(", "this", ".", "_", ".", "id", ")", ";", "if", "(", "element", ")", "{", "element", ".", "setState", "(", "state", ",", "'cke_button'", ")", ";", "state", "==", "CKEDITOR", ".", "TRISTATE_DISABLED", "?", "element", ".", "setAttribute", "(", "'aria-disabled'", ",", "true", ")", ":", "element", ".", "removeAttribute", "(", "'aria-disabled'", ")", ";", "if", "(", "!", "this", ".", "hasArrow", ")", "{", "// Note: aria-pressed attribute should not be added to menuButton instances. (#11331)\r", "state", "==", "CKEDITOR", ".", "TRISTATE_ON", "?", "element", ".", "setAttribute", "(", "'aria-pressed'", ",", "true", ")", ":", "element", ".", "removeAttribute", "(", "'aria-pressed'", ")", ";", "}", "else", "{", "var", "newLabel", "=", "state", "==", "CKEDITOR", ".", "TRISTATE_ON", "?", "this", ".", "_", ".", "editor", ".", "lang", ".", "button", ".", "selectedLabel", ".", "replace", "(", "/", "%1", "/", "g", ",", "this", ".", "label", ")", ":", "this", ".", "label", ";", "CKEDITOR", ".", "document", ".", "getById", "(", "this", ".", "_", ".", "id", "+", "'_label'", ")", ".", "setText", "(", "newLabel", ")", ";", "}", "return", "true", ";", "}", "else", "return", "false", ";", "}" ]

[ "Sets", "the", "button", "state", "." ]

[ "function", "rPath", "(", "htmlyFile", ",", "sourceFilepath", ")", "{", "htmlyFile", "=", "pathResolve", "(", "__dirname", ",", "htmlyFile", ")", "htmlyFile", "=", "pathRelative", "(", "dirname", "(", "sourceFilepath", ")", ",", "htmlyFile", ")", "htmlyFile", "=", "slash", "(", "htmlyFile", ")", "if", "(", "!", "/", "^(\\.|\\/)", "/", ".", "test", "(", "htmlyFile", ")", ")", "{", "return", "'./'", "+", "htmlyFile", "}", "else", "{", "return", "htmlyFile", "}", "}" ]

[ "Generate", "a", "relative", "path", "to", "a", "htmly", "file", "relative", "to", "source", "file" ]

[ "function", "warning", "(", ")", "{", "let", "sentence", "=", "\"\"", ";", "const", "avoidList", "=", "getWords", "(", "\"avoid_list\"", ")", ";", "const", "avoid", "=", "nu", ".", "chooseFrom", "(", "avoidList", ")", ";", "const", "rnum", "=", "Math", ".", "floor", "(", "Math", ".", "random", "(", ")", "*", "10", ")", ";", "if", "(", "rnum", "<=", "3", ")", "{", "sentence", "=", "`", "${", "avoid", "}", "`", ";", "}", "else", "if", "(", "rnum", "<=", "6", ")", "{", "sentence", "=", "`", "${", "avoid", "}", "`", ";", "}", "else", "if", "(", "rnum", "<=", "8", ")", "{", "sentence", "=", "`", "${", "avoid", "}", "`", ";", "}", "else", "{", "sentence", "=", "`", "${", "avoid", "}", "`", ";", "}", "return", "nu", ".", "sentenceCase", "(", "sentence", ")", ";", "}" ]

[ "Warns", "of", "what", "to", "avoid" ]

[ "function", "getIterableObjectEntries", "(", "obj", ")", "{", "let", "index", "=", "0", ";", "const", "propKeys", "=", "Reflect", ".", "ownKeys", "(", "obj", ")", ";", "return", "{", "[", "Symbol", ".", "iterator", "]", "(", ")", "{", "return", "this", ";", "}", ",", "next", "(", ")", "{", "if", "(", "index", "<", "propKeys", ".", "length", ")", "{", "const", "key", "=", "propKeys", "[", "index", "]", ";", "index", "+=", "1", ";", "return", "{", "\"value\"", ":", "[", "key", ",", "obj", "[", "key", "]", "]", "}", ";", "}", "return", "{", "\"done\"", ":", "true", "}", ";", "}", "}", ";", "}" ]

[ "Creates", "an", "iterable", "based", "on", "an", "object", "literal" ]

[ "function", "findWhere", "(", "arr", ",", "key", ",", "value", ")", "{", "return", "arr", ".", "find", "(", "elem", "=>", "{", "for", "(", "const", "[", "k", ",", "v", "]", "of", "getIterableObjectEntries", "(", "elem", ")", ")", "{", "if", "(", "k", "===", "key", "&&", "v", "===", "value", ")", "{", "return", "true", ";", "}", "}", "}", ")", ";", "}" ]

[ "Returns", "the", "object", "where", "the", "given", "own", "key", "exists", "and", "equal", "with", "value" ]

[ "function", "findWhereKey", "(", "arr", ",", "key", ")", "{", "return", "arr", ".", "find", "(", "elem", "=>", "{", "for", "(", "const", "[", "k", "]", "of", "getIterableObjectEntries", "(", "elem", ")", ")", "{", "if", "(", "k", "===", "key", ")", "{", "return", "true", ";", "}", "}", "}", ")", ";", "}" ]

[ "Returns", "the", "object", "where", "the", "given", "own", "key", "exists" ]

[ "function", "load", "(", "module", ")", "{", "var", "toTransform", ",", "transformedModule", "=", "{", "}", ";", "if", "(", "typeof", "module", "===", "\"string\"", ")", "{", "toTransform", "=", "require", "(", "module", ")", ";", "}", "else", "{", "toTransform", "=", "module", ";", "}", "for", "(", "var", "item", "in", "toTransform", ")", "{", "// transform only sync/async methods to promiseable since having utility methods also promiseable", "// could do more harm than good.", "if", "(", "typeof", "toTransform", "[", "item", "]", "===", "\"function\"", "&&", "isFunctionPromiseable", "(", "toTransform", ",", "item", ",", "toTransform", "[", "item", "]", ")", ")", "{", "transformedModule", "[", "item", "]", "=", "rebuildAsPromise", "(", "toTransform", ",", "item", ",", "toTransform", "[", "item", "]", ")", ";", "}", "else", "{", "transformedModule", "[", "item", "]", "=", "toTransform", "[", "item", "]", ";", "}", "}", "return", "transformedModule", ";", "}" ]

[ "Load", "a", "module", "transforming", "all", "the", "async", "methods", "that", "have", "callbacks", "into", "promises", "enabled", "functions", "." ]

[ "function", "rebuildAsPromise", "(", "_thisObject", ",", "name", ",", "fn", ")", "{", "// if is a regular function, that has an async correspondent also make it promiseable", "if", "(", "!", "isFunctionAsync", "(", "_thisObject", ",", "name", ",", "fn", ")", ")", "{", "return", "function", "(", ")", "{", "var", "that", "=", "this", ",", "args", "=", "arguments", ";", "return", "blinkts", ".", "lang", ".", "promiseCode", "(", "function", "(", ")", "{", "return", "fn", ".", "apply", "(", "that", ",", "args", ")", ";", "}", ")", ";", "}", ";", "}", "// if it's an async function, make it promiseable.", "return", "function", "(", ")", "{", "var", "args", "=", "Array", ".", "prototype", ".", "slice", ".", "apply", "(", "arguments", ")", ",", "that", "=", "this", ";", "return", "new", "blinkts", ".", "lang", ".", "Promise", "(", "function", "(", "fulfill", ",", "reject", ")", "{", "args", ".", "push", "(", "function", "(", "err", ",", "r", ")", "{", "if", "(", "err", ")", "{", "reject", "(", "err", ")", ";", "}", "if", "(", "arguments", ".", "length", ">", "2", ")", "{", "// if the callback received multiple arguments, put them into an array.", "fulfill", "(", "Array", ".", "prototype", ".", "slice", ".", "call", "(", "arguments", ",", "1", ")", ")", ";", "}", "else", "{", "fulfill", "(", "r", ")", ";", "}", "}", ")", ";", "try", "{", "var", "result", "=", "fn", ".", "apply", "(", "that", ",", "args", ")", ";", "}", "catch", "(", "e", ")", "{", "// if the function failed, so we don't get a chance to get our callback called.", "reject", "(", "e", ")", ";", "}", "}", ")", ";", "}", ";", "}" ]

[ "Takes", "the", "current", "function", "and", "wraps", "it", "around", "a", "promise", "." ]

[ "function", "(", "err", ",", "res", ")", "{", "if", "(", "err", ")", "return", "callback", "(", "err", ")", ";", "self", ".", "_rawResponse", "=", "res", ";", "if", "(", "!", "res", "||", "!", "res", "[", "'cps:reply'", "]", ")", "return", "callback", "(", "new", "Error", "(", "\"Invalid reply\"", ")", ")", ";", "self", ".", "seconds", "=", "res", "[", "'cps:reply'", "]", "[", "'cps:seconds'", "]", ";", "if", "(", "res", "[", "'cps:reply'", "]", "[", "'cps:content'", "]", ")", "{", "var", "content", "=", "res", "[", "'cps:reply'", "]", "[", "'cps:content'", "]", ";", "self", "=", "_", ".", "merge", "(", "self", ",", "content", ")", ";", "}", "callback", "(", "res", "[", "'cps:reply'", "]", "[", "'cps:error'", "]", ",", "self", ")", ";", "}" ]

[ "Merges", "response", "content", "into", "objects", "variables", "so", "it", "can", "be", "easily", "accessible" ]

[ "function", "TypedNumber", "(", "config", ")", "{", "const", "number", "=", "this", ";", "// validate min", "if", "(", "config", ".", "hasOwnProperty", "(", "'min'", ")", "&&", "!", "util", ".", "isNumber", "(", "config", ".", "min", ")", ")", "{", "const", "message", "=", "util", ".", "propertyErrorMessage", "(", "'min'", ",", "config", ".", "min", ",", "'Must be a number.'", ")", ";", "throw", "Error", "(", "message", ")", ";", "}", "// validate max", "if", "(", "config", ".", "hasOwnProperty", "(", "'max'", ")", "&&", "!", "util", ".", "isNumber", "(", "config", ".", "max", ")", ")", "{", "const", "message", "=", "util", ".", "propertyErrorMessage", "(", "'max'", ",", "config", ".", "max", ",", "'Must be a number.'", ")", ";", "throw", "Error", "(", "message", ")", ";", "}", "// validate max is greater than min", "if", "(", "config", ".", "hasOwnProperty", "(", "'max'", ")", "&&", "config", ".", "hasOwnProperty", "(", "'min'", ")", "&&", "config", ".", "min", ">", "config", ".", "max", ")", "{", "const", "message", "=", "util", ".", "propertyErrorMessage", "(", "'max'", ",", "config", ".", "max", ",", "'Must be a number that is less than the minimum: '", "+", "config", ".", "min", "+", "'.'", ")", ";", "throw", "Error", "(", "message", ")", ";", "}", "// define properties", "Object", ".", "defineProperties", "(", "number", ",", "{", "exclusiveMax", ":", "{", "/**\n * @property\n * @name TypedNumber#exclusiveMax\n * @type {boolean}\n */", "value", ":", "!", "!", "config", ".", "exclusiveMax", ",", "writable", ":", "false", "}", ",", "exclusiveMin", ":", "{", "/**\n * @property\n * @name TypedNumber#exclusiveMin\n * @type {boolean}\n */", "value", ":", "!", "!", "config", ".", "exclusiveMin", ",", "writable", ":", "false", "}", ",", "integer", ":", "{", "/**\n * @property\n * @name TypedNumber#integer\n * @type {boolean}\n */", "value", ":", "!", "!", "config", ".", "integer", ",", "writable", ":", "false", "}", ",", "max", ":", "{", "/**\n * @property\n * @name TypedNumber#max\n * @type {number}\n */", "value", ":", "Number", "(", "config", ".", "max", ")", ",", "writable", ":", "false", "}", ",", "min", ":", "{", "/**\n * @property\n * @name TypedNumber#min\n * @type {number}\n */", "value", ":", "Number", "(", "config", ".", "min", ")", ",", "writable", ":", "false", "}", "}", ")", ";", "return", "number", ";", "}" ]

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

[ "function", "recursiveMapping", "(", "source", ")", "{", "if", "(", "source", ".", "type", "===", "'array'", ")", "{", "if", "(", "source", ".", "items", "[", "'$ref'", "]", "||", "source", ".", "items", ".", "type", "===", "'object'", ")", "{", "source", ".", "items", "=", "mapSimpleField", "(", "source", ".", "items", ")", ";", "}", "else", "if", "(", "source", ".", "items", ".", "type", "===", "'object'", ")", "{", "recursiveMapping", "(", "source", ".", "items", ")", ";", "}", "else", "mapSimpleField", "(", "source", ")", ";", "}", "else", "if", "(", "source", ".", "type", "===", "'object'", ")", "{", "for", "(", "var", "property", "in", "source", ".", "properties", ")", "{", "if", "(", "source", ".", "properties", "[", "property", "]", "[", "'$ref'", "]", ")", "{", "source", ".", "properties", "[", "property", "]", "=", "mapSimpleField", "(", "source", ".", "properties", "[", "property", "]", ")", ";", "}", "else", "if", "(", "source", ".", "properties", "[", "property", "]", ".", "type", "===", "'object'", "||", "source", ".", "properties", "[", "property", "]", ".", "type", "===", "'array'", ")", "{", "recursiveMapping", "(", "source", ".", "properties", "[", "property", "]", ")", ";", "}", "}", "}", "else", "if", "(", "source", ".", "schema", ")", "{", "if", "(", "source", ".", "schema", ".", "type", "===", "'object'", ")", "{", "for", "(", "var", "property", "in", "source", ".", "schema", ".", "properties", ")", "{", "if", "(", "source", ".", "schema", ".", "properties", "[", "property", "]", "[", "'$ref'", "]", ")", "{", "source", ".", "schema", ".", "properties", "[", "property", "]", "=", "mapSimpleField", "(", "source", ".", "schema", ".", "properties", "[", "property", "]", ")", ";", "}", "}", "}", "}", "else", "{", "//map simple inputs if any", "source", "=", "mapSimpleField", "(", "source", ")", ";", "}", "}" ]

[ "loop", "through", "one", "common", "field", "recursively", "constructing", "and", "populating", "all", "its", "children", "imfv" ]

[ "function", "(", "yamlContent", ",", "context", ",", "callback", ")", "{", "var", "jsonAPISchema", ";", "try", "{", "jsonAPISchema", "=", "yamljs", ".", "parse", "(", "yamlContent", ")", ";", "}", "catch", "(", "e", ")", "{", "return", "callback", "(", "{", "\"code\"", ":", "851", ",", "\"msg\"", ":", "e", ".", "message", "}", ")", ";", "}", "try", "{", "swagger", ".", "validateYaml", "(", "jsonAPISchema", ")", ";", "}", "catch", "(", "e", ")", "{", "return", "callback", "(", "{", "\"code\"", ":", "173", ",", "\"msg\"", ":", "e", ".", "message", "}", ")", ";", "}", "context", ".", "yaml", "=", "jsonAPISchema", ";", "swagger", ".", "mapAPis", "(", "jsonAPISchema", ",", "function", "(", "response", ")", "{", "context", ".", "soajs", ".", "config", ".", "schema", "=", "response", ".", "schema", ";", "context", ".", "soajs", ".", "config", ".", "errors", "=", "response", ".", "errors", ";", "var", "myValidator", "=", "new", "Validator", "(", ")", ";", "var", "check", "=", "myValidator", ".", "validate", "(", "context", ".", "soajs", ".", "config", ",", "schema", ")", ";", "if", "(", "check", ".", "valid", ")", "{", "return", "callback", "(", "null", ",", "true", ")", ";", "}", "else", "{", "var", "errMsgs", "=", "[", "]", ";", "check", ".", "errors", ".", "forEach", "(", "function", "(", "oneError", ")", "{", "errMsgs", ".", "push", "(", "oneError", ".", "stack", ")", ";", "}", ")", ";", "return", "callback", "(", "{", "\"code\"", ":", "172", ",", "\"msg\"", ":", "new", "Error", "(", "errMsgs", ".", "join", "(", "\" - \"", ")", ")", ".", "message", "}", ")", ";", "}", "}", ")", ";", "}" ]

[ "parse", "the", "yaml", "and", "generate", "a", "config", ".", "js", "content", "from", "it" ]

[ "function", "(", "yamlJson", ")", "{", "if", "(", "typeof", "yamlJson", "!==", "'object'", ")", "{", "throw", "new", "Error", "(", "\"Yaml file was converted to a string\"", ")", ";", "}", "if", "(", "!", "yamlJson", ".", "paths", "||", "Object", ".", "keys", "(", "yamlJson", ".", "paths", ")", ".", "length", "===", "0", ")", "{", "throw", "new", "Error", "(", "\"Yaml file is missing api schema\"", ")", ";", "}", "//loop in path", "for", "(", "var", "onePath", "in", "yamlJson", ".", "paths", ")", "{", "//loop in methods", "for", "(", "var", "oneMethod", "in", "yamlJson", ".", "paths", "[", "onePath", "]", ")", "{", "if", "(", "!", "yamlJson", ".", "paths", "[", "onePath", "]", "[", "oneMethod", "]", ".", "summary", "||", "yamlJson", ".", "paths", "[", "onePath", "]", "[", "oneMethod", "]", ".", "summary", "===", "\"\"", ")", "{", "throw", "new", "Error", "(", "\"Please enter a summary for API \"", "+", "oneMethod", "+", "\": \"", "+", "onePath", "+", "\" you want to build.\"", ")", ";", "}", "}", "}", "}" ]

[ "validate", "that", "parsed", "yaml", "content", "has", "the", "minimum", "required", "fields" ]

[ "function", "(", "obj", ")", "{", "if", "(", "typeof", "obj", "!==", "\"object\"", "||", "obj", "===", "null", ")", "{", "return", "obj", ";", "}", "if", "(", "obj", "instanceof", "Date", ")", "{", "return", "new", "Date", "(", "obj", ".", "getTime", "(", ")", ")", ";", "}", "if", "(", "obj", "instanceof", "RegExp", ")", "{", "return", "new", "RegExp", "(", "obj", ")", ";", "}", "if", "(", "obj", "instanceof", "Array", "&&", "Object", ".", "keys", "(", "obj", ")", ".", "every", "(", "function", "(", "k", ")", "{", "return", "!", "isNaN", "(", "k", ")", ";", "}", ")", ")", "{", "return", "obj", ".", "slice", "(", "0", ")", ";", "}", "var", "_obj", "=", "{", "}", ";", "for", "(", "var", "attr", "in", "obj", ")", "{", "if", "(", "Object", ".", "hasOwnProperty", ".", "call", "(", "obj", ",", "attr", ")", ")", "{", "_obj", "[", "attr", "]", "=", "swagger", ".", "cloneObj", "(", "obj", "[", "attr", "]", ")", ";", "}", "}", "return", "_obj", ";", "}" ]

[ "clone", "a", "javascript", "object", "with", "type", "casting" ]

[ "function", "(", "serviceInfo", ")", "{", "var", "config", "=", "{", "\"type\"", ":", "\"service\"", ",", "\"prerequisites\"", ":", "{", "\"cpu\"", ":", "\" \"", ",", "\"memory\"", ":", "\" \"", "}", ",", "\"swagger\"", ":", "true", ",", "\"injection\"", ":", "true", ",", "\"serviceName\"", ":", "serviceInfo", ".", "serviceName", ",", "\"serviceGroup\"", ":", "serviceInfo", ".", "serviceGroup", ",", "\"serviceVersion\"", ":", "serviceInfo", ".", "serviceVersion", ",", "\"servicePort\"", ":", "serviceInfo", ".", "servicePort", ",", "\"requestTimeout\"", ":", "serviceInfo", ".", "requestTimeout", ",", "\"requestTimeoutRenewal\"", ":", "serviceInfo", ".", "requestTimeoutRenewal", ",", "\"extKeyRequired\"", ":", "serviceInfo", ".", "extKeyRequired", ",", "\"oauth\"", ":", "serviceInfo", ".", "oauth", ",", "\"session\"", ":", "serviceInfo", ".", "session", ",", "\"errors\"", ":", "{", "}", ",", "\"schema\"", ":", "{", "}", "}", ";", "if", "(", "serviceInfo", ".", "dbs", "&&", "Array", ".", "isArray", "(", "serviceInfo", ".", "dbs", ")", "&&", "serviceInfo", ".", "dbs", ".", "length", ">", "0", ")", "{", "config", "[", "\"dbs\"", "]", "=", "serviceInfo", ".", "dbs", ";", "config", "[", "\"models\"", "]", "=", "{", "\"path\"", ":", "'%__dirname% + \"/lib/models/\"'", ",", "\"name\"", ":", "\"\"", "}", ";", "var", "modelProps", "=", "Object", ".", "keys", "(", "serviceInfo", ".", "dbs", "[", "0", "]", ")", ";", "if", "(", "modelProps", ".", "indexOf", "(", "\"mongo\"", ")", "!==", "-", "1", ")", "{", "config", ".", "models", ".", "name", "=", "serviceInfo", ".", "dbs", "[", "0", "]", "=", "\"mongo\"", ";", "}", "else", "{", "config", ".", "models", ".", "name", "=", "serviceInfo", ".", "dbs", "[", "0", "]", "=", "\"es\"", ";", "}", "}", "return", "config", ";", "}" ]

[ "map", "variables", "to", "meet", "the", "service", "configuration", "object", "schema" ]

[ "function", "(", "yamlJson", ",", "cb", ")", "{", "let", "all_apis", "=", "{", "}", ";", "let", "all_errors", "=", "{", "}", ";", "let", "paths", "=", "reformatPaths", "(", "yamlJson", ".", "paths", ")", ";", "let", "definitions", "=", "yamlJson", ".", "definitions", ";", "let", "parameters", "=", "yamlJson", ".", "parameters", ";", "let", "convertedDefinitions", "=", "{", "}", ";", "let", "convertedParameters", "=", "{", "}", ";", "// convert definitions first", "if", "(", "definitions", ")", "{", "let", "definitionsKeys", "=", "Object", ".", "keys", "(", "definitions", ")", ";", "definitionsKeys", ".", "forEach", "(", "function", "(", "eachDef", ")", "{", "convertedDefinitions", "[", "eachDef", "]", "=", "convertItem", "(", "null", ",", "definitions", "[", "eachDef", "]", ",", "1", ")", ";", "// 1 ??? definitions should never have schema -=-=-=-=-=", "}", ")", ";", "}", "// convert parameters then", "if", "(", "parameters", ")", "{", "let", "parametersKeys", "=", "Object", ".", "keys", "(", "parameters", ")", ";", "parametersKeys", ".", "forEach", "(", "function", "(", "eachParam", ")", "{", "convertedParameters", "[", "eachParam", "]", "=", "convertItem", "(", "convertedDefinitions", ",", "parameters", "[", "eachParam", "]", ",", "1", ")", ";", "}", ")", ";", "all_apis", ".", "commonFields", "=", "convertedParameters", ";", "}", "let", "pathsKeys", "=", "Object", ".", "keys", "(", "paths", ")", ";", "pathsKeys", ".", "forEach", "(", "function", "(", "eachPath", ")", "{", "let", "methods", "=", "paths", "[", "eachPath", "]", ";", "let", "methodsKeys", "=", "Object", ".", "keys", "(", "methods", ")", ";", "methodsKeys", ".", "forEach", "(", "function", "(", "eachMethod", ")", "{", "let", "apiData", "=", "methods", "[", "eachMethod", "]", ";", "if", "(", "!", "all_apis", "[", "eachMethod", "]", ")", "{", "all_apis", "[", "eachMethod", "]", "=", "{", "}", ";", "}", "var", "mwFile", "=", "eachPath", ".", "replace", "(", "/", "\\\\", "/", "g", ",", "\"_\"", ")", ".", "replace", "(", "/", ":", "/", "g", ",", "\"_\"", ")", ".", "replace", "(", "/", "\\/", "/", "g", ",", "\"_\"", ")", ".", "replace", "(", "/", "[_]{2,}", "/", "g", ",", "\"_\"", ")", ".", "replace", "(", "/", "{", "/", "g", ",", "\"\"", ")", ".", "replace", "(", "/", "}", "/", "g", ",", "\"\"", ")", ";", "mwFile", "=", "mwFile", ".", "toLowerCase", "(", ")", ";", "if", "(", "mwFile", "[", "0", "]", "===", "\"_\"", ")", "{", "mwFile", "=", "mwFile", ".", "substring", "(", "1", ")", ";", "}", "mwFile", "+=", "\"_\"", "+", "eachMethod", ".", "toLowerCase", "(", ")", "+", "\".js\"", ";", "all_apis", "[", "eachMethod", "]", "[", "eachPath", "]", "=", "{", "_apiInfo", ":", "{", "}", ",", "\"mw\"", ":", "'%dirname% + \"/lib/mw/'", "+", "mwFile", "+", "'\"'", "}", ";", "let", "newSoajsApi", "=", "all_apis", "[", "eachMethod", "]", "[", "eachPath", "]", ";", "let", "params", "=", "apiData", ".", "parameters", ";", "let", "group", "=", "apiData", ".", "tags", "?", "apiData", ".", "tags", "[", "0", "]", ":", "\"\"", ";", "newSoajsApi", ".", "_apiInfo", ".", "group", "=", "group", "&&", "group", "!==", "''", "?", "group", ":", "\"general\"", ";", "newSoajsApi", ".", "_apiInfo", ".", "l", "=", "apiData", ".", "summary", ";", "newSoajsApi", ".", "imfv", "=", "convertParams", "(", "convertedDefinitions", ",", "convertedParameters", ",", "params", ")", ";", "}", ")", ";", "}", ")", ";", "// todo: convert errors", "return", "cb", "(", "{", "\"schema\"", ":", "all_apis", ",", "\"errors\"", ":", "all_errors", "}", ")", ";", "}" ]

[ "map", "apis", "to", "meet", "service", "configuraiton", "schema", "from", "a", "parsed", "swagger", "yaml", "json", "object" ]

[ "function", "(", "files", ",", "callback", ")", "{", "//loop on all files and write them", "async", ".", "each", "(", "files", ",", "function", "(", "fileObj", ",", "mCb", ")", "{", "var", "data", "=", "swagger", ".", "cloneObj", "(", "fileObj", ".", "data", ")", ";", "//if tokens, replace all occurences with corresponding values", "if", "(", "fileObj", ".", "tokens", ")", "{", "for", "(", "var", "i", "in", "fileObj", ".", "tokens", ")", "{", "var", "regexp", "=", "new", "RegExp", "(", "\"%\"", "+", "i", "+", "\"%\"", ",", "\"g\"", ")", ";", "data", "=", "data", ".", "replace", "(", "regexp", ",", "fileObj", ".", "tokens", "[", "i", "]", ")", ";", "}", "}", "if", "(", "fileObj", ".", "purify", ")", "{", "data", "=", "data", ".", "replace", "(", "/", "\\\\\"", "/", "g", ",", "'\"'", ")", ".", "replace", "(", "/", "[\"]+", "/", "g", ",", "'\"'", ")", ".", "replace", "(", "/", "\"__dirname", "/", "g", ",", "'__dirname'", ")", ";", "data", "=", "data", ".", "replace", "(", "/", "(\"group\": \"__empty__\")", "/", "g", ",", "'\"group\": \"\"'", ")", ";", "data", "=", "data", ".", "replace", "(", "/", "(\"prefix\": \"(\\s?|\\s+),)", "/", "g", ",", "'\"prefix\": \"\",'", ")", ";", "data", "=", "data", ".", "replace", "(", "/", "(\"l\": \"__empty__\")", "/", "g", ",", "'\"l\": \"\"'", ")", ";", "//\"__dirname + \\\"/lib/mw/_get.js\\\"\"", "//\"__dirname + \"/lib/mw/_get.js\"\"", "//\"__dirname + \"/lib/mw/_get.js\"", "//__dirname + \"/lib/mw/_get.js\"", "}", "console", ".", "log", "(", "\"creating file:\"", ",", "fileObj", ".", "file", ")", ";", "fs", ".", "writeFile", "(", "fileObj", ".", "file", ",", "data", ",", "\"utf8\"", ",", "mCb", ")", ";", "}", ",", "function", "(", "error", ")", "{", "if", "(", "error", ")", "{", "return", "callback", "(", "{", "\"code\"", ":", "854", ",", "\"msg\"", ":", "error", ".", "message", "}", ")", ";", "}", "return", "callback", "(", "null", ",", "true", ")", ";", "}", ")", ";", "}" ]

[ "function", "that", "generates", "the", "files", "for", "the", "microservice" ]

[ "function", "(", ")", "{", "var", "args", "=", "[", "]", ";", "for", "(", "var", "_i", "=", "0", ";", "_i", "<", "arguments", ".", "length", ";", "_i", "++", ")", "{", "args", "[", "_i", "]", "=", "arguments", "[", "_i", "]", ";", "}", "this", ".", "testCategory", "=", "name", ";", "return", "construct", "(", "original", ",", "args", ")", ";", "}" ]

[ "the", "new", "constructor", "behaviour" ]

[ "function", "createWordNode", "(", "item", ")", "{", "var", "wordNode", "=", "parser", ".", "createParentNode", "(", "'Word'", ")", "if", "(", "options", "&&", "options", ".", "pos", ")", "{", "wordNode", ".", "data", "=", "item", "}", "var", "textNode", "=", "parser", ".", "createTextNode", "(", "'Text'", ",", "item", ".", "surface_form", ")", "parser", ".", "add", "(", "textNode", ",", "wordNode", ")", "return", "wordNode", "}" ]

[ "Create", "WordNode", "with", "POS", "." ]

[ "function", "createTextNode", "(", "type", ",", "item", ")", "{", "var", "node", "=", "parser", ".", "createTextNode", "(", "type", ",", "item", ".", "surface_form", ")", "if", "(", "options", "&&", "options", ".", "pos", ")", "{", "node", ".", "data", "=", "item", "}", "return", "node", "}" ]

[ "Create", "TextNode", "for", "SymbolNode", "PunctuationNode", "WhiteSpaceNode", "and", "SourceNode", "with", "POS", "." ]

[ "function", "XError", "(", "/*code, message, data, privateData, cause*/", ")", "{", "if", "(", "Error", ".", "captureStackTrace", ")", "Error", ".", "captureStackTrace", "(", "this", ",", "this", ")", ";", "else", "this", ".", "stack", "=", "new", "Error", "(", ")", ".", "stack", ";", "var", "code", ",", "message", ",", "data", ",", "cause", ",", "privateData", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "arguments", ".", "length", ";", "i", "++", ")", "{", "var", "arg", "=", "arguments", "[", "i", "]", ";", "if", "(", "XError", ".", "isXError", "(", "arg", ")", "||", "arg", "instanceof", "Error", ")", "{", "if", "(", "cause", "!==", "undefined", ")", "{", "data", "=", "cause", ";", "}", "cause", "=", "arg", ";", "}", "else", "if", "(", "typeof", "arg", "===", "'string'", "||", "typeof", "arg", "===", "'number'", ")", "{", "if", "(", "typeof", "arg", "!==", "'string'", ")", "arg", "=", "''", "+", "arg", ";", "if", "(", "code", "===", "undefined", "&&", "arg", ".", "indexOf", "(", "' '", ")", "==", "-", "1", ")", "code", "=", "arg", ";", "else", "if", "(", "message", "===", "undefined", ")", "message", "=", "arg", ";", "else", "if", "(", "data", "===", "undefined", ")", "data", "=", "arg", ";", "else", "if", "(", "privateData", "===", "undefined", ")", "privateData", "=", "arg", ";", "else", "if", "(", "cause", "===", "undefined", ")", "cause", "=", "new", "Error", "(", "arg", ")", ";", "}", "else", "if", "(", "arg", "===", "null", "||", "arg", "===", "undefined", ")", "{", "if", "(", "code", "===", "undefined", ")", "code", "=", "null", ";", "else", "if", "(", "message", "===", "undefined", ")", "message", "=", "null", ";", "else", "if", "(", "data", "===", "undefined", ")", "data", "=", "null", ";", "else", "if", "(", "privateData", "===", "undefined", ")", "privateData", "=", "null", ";", "else", "if", "(", "cause", "===", "undefined", ")", "cause", "=", "null", ";", "}", "else", "{", "if", "(", "data", "===", "undefined", ")", "data", "=", "arg", ";", "else", "if", "(", "privateData", "===", "undefined", ")", "privateData", "=", "arg", ";", "}", "}", "code", "=", "code", "||", "(", "cause", "&&", "cause", ".", "code", ")", "||", "XError", ".", "INTERNAL_ERROR", ";", "message", "=", "message", "||", "(", "cause", "&&", "cause", ".", "message", ")", ";", "if", "(", "code", ")", "{", "var", "errorCodeInfo", "=", "registry", ".", "getErrorCode", "(", "code", ")", ";", "if", "(", "errorCodeInfo", ")", "{", "if", "(", "errorCodeInfo", ".", "code", ")", "code", "=", "errorCodeInfo", ".", "code", ";", "// in case of aliased error codes", "if", "(", "!", "message", "&&", "errorCodeInfo", ".", "message", ")", "message", "=", "errorCodeInfo", ".", "message", ";", "}", "}", "this", ".", "code", "=", "code", ";", "this", ".", "message", "=", "message", "||", "'An error occurred'", ";", "this", ".", "data", "=", "data", ";", "this", ".", "privateData", "=", "privateData", ";", "this", ".", "cause", "=", "cause", ";", "this", ".", "name", "=", "'XError'", ";", "Object", ".", "defineProperty", "(", "this", ",", "'_isXError'", ",", "{", "configurable", ":", "false", ",", "enumerable", ":", "false", ",", "writable", ":", "false", ",", "value", ":", "true", "}", ")", ";", "}" ]

[ "Construct", "a", "Extended", "Error", "instance", ".", "All", "parameters", "are", "optional", "with", "the", "exception", "that", "a", "code", "is", "required", "if", "a", "message", "is", "given", "and", "that", "data", "is", "required", "if", "privateData", "is", "given", "." ]

[ "function", "cpuAverage", "(", ")", "{", "//Initialise sum of idle and time of cores and fetch CPU info", "var", "totalIdle", "=", "0", ",", "totalTick", "=", "0", ";", "var", "cpus", "=", "os", ".", "cpus", "(", ")", ";", "//Loop through CPU cores", "for", "(", "var", "i", "=", "0", ",", "len", "=", "cpus", ".", "length", ";", "i", "<", "len", ";", "i", "++", ")", "{", "//Select CPU core", "var", "cpu", "=", "cpus", "[", "i", "]", ";", "//Total up the time in the cores tick", "for", "(", "type", "in", "cpu", ".", "times", ")", "{", "totalTick", "+=", "cpu", ".", "times", "[", "type", "]", ";", "}", "//Total up the idle time of the core", "totalIdle", "+=", "cpu", ".", "times", ".", "idle", ";", "}", "//Return the average Idle and Tick times", "return", "{", "idle", ":", "totalIdle", "/", "cpus", ".", "length", ",", "total", ":", "totalTick", "/", "cpus", ".", "length", "}", ";", "}" ]

[ "Create", "function", "to", "get", "CPU", "information" ]

[ "function", "(", "r", ",", "g", ",", "b", ",", "a", ")", "{", "var", "rnum", "=", "typeof", "r", "===", "\"number\"", ";", "if", "(", "rnum", "&&", "typeof", "g", "===", "\"number\"", "&&", "typeof", "b", "===", "\"number\"", ")", "{", "//default alpha to one ", "a", "=", "typeof", "a", "===", "\"number\"", "?", "a", ":", "1.0", ";", "}", "else", "{", "r", "=", "g", "=", "b", "=", "a", "=", "rnum", "?", "r", ":", "1.0", ";", "}", "if", "(", "this", ".", "premultiplied", ")", "{", "r", "*=", "a", ";", "g", "*=", "a", ";", "b", "*=", "a", ";", "}", "this", ".", "color", "=", "colorToFloat", "(", "~", "~", "(", "r", "*", "255", ")", ",", "~", "~", "(", "g", "*", "255", ")", ",", "~", "~", "(", "b", "*", "255", ")", ",", "~", "~", "(", "a", "*", "255", ")", ")", ";", "}" ]

[ "Sets", "the", "color", "of", "this", "sprite", "batcher", "which", "is", "used", "in", "subsequent", "draw", "calls", ".", "This", "does", "not", "flush", "the", "batch", "." ]

[ "function", "ParseJapaneseBasic", "(", "file", ",", "options", ")", "{", "var", "offset", "=", "0", "var", "line", "=", "1", "var", "column", "=", "1", "var", "position", "if", "(", "!", "(", "this", "instanceof", "ParseJapaneseBasic", ")", ")", "{", "return", "new", "ParseJapaneseBasic", "(", "file", ",", "options", ")", "}", "if", "(", "file", "&&", "file", ".", "message", ")", "{", "this", ".", "file", "=", "file", "}", "else", "{", "options", "=", "file", "}", "position", "=", "options", "&&", "options", ".", "position", "if", "(", "position", "!==", "null", "&&", "position", "!==", "undefined", ")", "{", "this", ".", "position", "=", "Boolean", "(", "position", ")", "}", "this", ".", "offset", "=", "offset", "this", ".", "line", "=", "line", "this", ".", "column", "=", "column", "}" ]

[ "Transform", "Japanese", "natural", "language", "into", "an", "NLCST", "-", "tree", "." ]

[ "function", "ParamedicRunner", "(", "_platformId", ",", "_plugins", ",", "_callback", ",", "bJustBuild", ",", "nPort", ",", "msTimeout", ",", "browserify", ",", "bSilent", ",", "bVerbose", ",", "platformPath", ")", "{", "this", ".", "tunneledUrl", "=", "\"\"", ";", "this", ".", "port", "=", "nPort", ";", "this", ".", "justBuild", "=", "bJustBuild", ";", "this", ".", "plugins", "=", "_plugins", ";", "this", ".", "platformId", "=", "_platformId", ";", "this", ".", "callback", "=", "_callback", ";", "this", ".", "tempFolder", "=", "null", ";", "this", ".", "timeout", "=", "msTimeout", ";", "this", ".", "verbose", "=", "bVerbose", ";", "this", ".", "platformPath", "=", "platformPath", ";", "if", "(", "browserify", ")", "{", "this", ".", "browserify", "=", "\"--browserify\"", ";", "}", "else", "{", "this", ".", "browserify", "=", "''", ";", "}", "if", "(", "bSilent", ")", "{", "var", "logOutput", "=", "this", ".", "logOutput", "=", "[", "]", ";", "this", ".", "logMessage", "=", "function", "(", "msg", ")", "{", "logOutput", ".", "push", "(", "msg", ")", ";", "}", ";", "}", "else", "{", "this", ".", "logMessage", "=", "function", "(", "msg", ")", "{", "console", ".", "log", "(", "msg", ")", ";", "}", ";", "}", "}" ]

[ "10", "minutes", "in", "msec", "-", "this", "will", "become", "a", "param" ]

[ "function", "findImports", "(", "filePath", ",", "result", ")", "{", "var", "importPaths", "=", "getImportPaths", "(", "filePath", ")", ";", "var", "importPathsAbs", "=", "resolveImportPaths", "(", "filePath", ",", "importPaths", ")", ";", "if", "(", "importPathsAbs", ".", "length", ")", "result", ".", "full", "[", "filePath", "]", "=", "importPathsAbs", ";", "importPathsAbs", ".", "forEach", "(", "function", "(", "path", ")", "{", "if", "(", "result", ".", "simple", ".", "indexOf", "(", "path", ")", "===", "-", "1", ")", "{", "result", ".", "simple", ".", "push", "(", "path", ")", ";", "findImports", "(", "path", ",", "result", ")", ";", "}", "}", ")", ";", "return", "result", ";", "}" ]

[ "Recursivley", "finds", "all" ]

[ "function", "getImportPaths", "(", "filePath", ")", "{", "var", "importPaths", "=", "[", "]", ";", "try", "{", "var", "contents", "=", "fs", ".", "readFileSync", "(", "filePath", ")", ".", "toString", "(", "'utf8'", ")", ";", "importPaths", "=", "parseImpt", "(", "contents", ")", ";", "}", "catch", "(", "exception", ")", "{", "}", "return", "importPaths", ";", "}" ]

[ "Finds", "all", "the" ]

[ "function", "updatePosition", "(", "instance", ",", "tetherBounds", ")", "{", "const", "x", "=", "tetherBounds", ".", "x", "+", "(", "instance", ".", "horizontalAlignment", "===", "HORIZONTAL_ALIGN", ".", "LEFT", "?", "0", ":", "tetherBounds", ".", "width", ")", "const", "y", "=", "tetherBounds", ".", "y", "+", "(", "instance", ".", "verticalAlignment", "===", "VERTICAL_ALIGN", ".", "TOP", "?", "0", ":", "tetherBounds", ".", "height", ")", "if", "(", "transformsSupported", ")", "{", "instance", ".", "_root", ".", "style", ".", "transform", "=", "`", "${", "x", "}", "${", "y", "}", "`", "}", "else", "{", "instance", ".", "_root", ".", "style", ".", "left", "=", "`", "${", "x", "}", "`", "instance", ".", "_root", ".", "style", ".", "top", "=", "`", "${", "y", "}", "`", "}", "}" ]

[ "Updates", "the", "position", "of", "the", "szn", "-", "tethered", "element", "according", "to", "the", "current", "tethering", "alignment", "and", "the", "provided", "bounds", "of", "the", "tethering", "element", "." ]

[ "function", "updateAttributes", "(", "instance", ")", "{", "if", "(", "instance", ".", "horizontalAlignment", "!==", "instance", ".", "_lastHorizontalAlignment", ")", "{", "const", "horizontalAlignment", "=", "instance", ".", "horizontalAlignment", "===", "HORIZONTAL_ALIGN", ".", "LEFT", "?", "'left'", ":", "'right'", "instance", ".", "_root", ".", "setAttribute", "(", "'data-horizontal-align'", ",", "horizontalAlignment", ")", "instance", ".", "_lastHorizontalAlignment", "=", "instance", ".", "horizontalAlignment", "}", "if", "(", "instance", ".", "verticalAlignment", "!==", "instance", ".", "_lastVerticalAlignment", ")", "{", "const", "verticalAlignment", "=", "instance", ".", "verticalAlignment", "===", "VERTICAL_ALIGN", ".", "TOP", "?", "'top'", ":", "'bottom'", "instance", ".", "_root", ".", "setAttribute", "(", "'data-vertical-align'", ",", "verticalAlignment", ")", "instance", ".", "_lastVerticalAlignment", "=", "instance", ".", "verticalAlignment", "}", "}" ]

[ "Updates", "the", "attributes", "on", "the", "szn", "-", "tethered", "element", "reporting", "the", "current", "alignment", "to", "the", "tethering", "element", "." ]

[ "function", "getTetherBounds", "(", "tether", ")", "{", "const", "bounds", "=", "tether", ".", "getBoundingClientRect", "(", ")", "const", "width", "=", "bounds", ".", "width", "const", "height", "=", "bounds", ".", "height", "let", "x", "=", "0", "let", "y", "=", "0", "let", "tetherOffsetContainer", "=", "tether", "while", "(", "tetherOffsetContainer", ")", "{", "x", "+=", "tetherOffsetContainer", ".", "offsetLeft", "y", "+=", "tetherOffsetContainer", ".", "offsetTop", "tetherOffsetContainer", "=", "tetherOffsetContainer", ".", "offsetParent", "}", "return", "{", "screenX", ":", "bounds", ".", "left", ",", "screenY", ":", "bounds", ".", "top", ",", "x", ",", "y", ",", "width", ",", "height", ",", "}", "}" ]

[ "Calculates", "and", "returns", "both", "the", "on", "-", "screen", "and", "on", "-", "page", "location", "and", "dimensions", "of", "the", "provided", "tether", "element", "." ]

[ "function", "getContentDimensions", "(", "instance", ")", "{", "const", "contentElement", "=", "instance", ".", "_root", ".", "firstElementChild", "if", "(", "!", "contentElement", ")", "{", "return", "{", "width", ":", "0", ",", "height", ":", "0", ",", "}", "}", "let", "width", "let", "height", "if", "(", "window", ".", "devicePixelRatio", ">", "1", ")", "{", "// This is much less performant, so we use in only on HiDPi displays", "const", "bounds", "=", "contentElement", ".", "getBoundingClientRect", "(", ")", "width", "=", "bounds", ".", "width", "height", "=", "bounds", ".", "height", "}", "else", "{", "width", "=", "contentElement", ".", "scrollWidth", "height", "=", "contentElement", ".", "scrollHeight", "}", "return", "{", "width", ",", "height", ",", "}", "}" ]

[ "Returns", "the", "dimensions", "of", "the", "content", "of", "the", "provided", "szn", "-", "tethered", "element", "." ]

[ "function", "(", "collectionID", ",", "criteria", ",", "cursor", ",", "limit", ")", "{", "collectionID", "=", "collectionID", ".", "toLowerCase", "(", ")", ";", "var", "deferred", "=", "q", ".", "defer", "(", ")", ";", "// acquire a connection from the pool", "db", ".", "getClient", "(", ")", ".", "then", "(", "function", "(", "dbClient", ")", "{", "if", "(", "!", "dbClient", ")", "{", "throw", "Error", "(", "\"Failed to acquire sqlite client\"", ")", ";", "}", "// do any necessary dynamic schema syncs, if its supported", "schemaSyncer", ".", "prepCollection", "(", "collectionID", ")", ".", "then", "(", "function", "(", ")", "{", "return", "expandIfNecessary", "(", "collectionID", ",", "schemaSyncer", ".", "getTableSchema", "(", "collectionID", ")", ",", "null", ",", "criteria", ")", ";", "}", ")", "// perform the query", ".", "then", "(", "function", "(", ")", "{", "var", "sql", "=", "sqlAdaptor", ".", "createSelectSQL", "(", "collectionID", ",", "criteria", ",", "limit", ")", ";", "query", "(", "dbClient", ",", "sql", ")", ".", "then", "(", "// success", "function", "(", "r", ")", "{", "var", "results", "=", "dbClient", ".", "results", "(", ")", ";", "if", "(", "!", "results", "||", "results", ".", "rowCount", "<", "1", ")", "{", "// if no results, return empty array", "deferred", ".", "resolve", "(", "[", "]", ")", ";", "return", ";", "}", "var", "hydratedResults", "=", "sqlAdaptor", ".", "hydrateResults", "(", "results", ")", ";", "if", "(", "!", "cursor", ")", "{", "deferred", ".", "resolve", "(", "hydratedResults", ")", ";", "}", "else", "{", "var", "stream", "=", "createStreamFrom", "(", "hydratedResults", ")", ";", "deferred", ".", "resolve", "(", "stream", ")", ";", "}", "}", ",", "// error", "function", "(", "e", ")", "{", "jive", ".", "logger", ".", "error", "(", "e", ".", "stack", ")", ";", "deferred", ".", "reject", "(", "e", ")", ";", "}", ")", ";", "}", ")", ".", "fail", "(", "function", "(", "e", ")", "{", "deferred", ".", "reject", "(", "e", ")", ";", "}", ")", "// always try to release the client, if it exists", ".", "finally", "(", "function", "(", ")", "{", "if", "(", "dbClient", ")", "{", "// always try to release the client, if it exists", "dbClient", ".", "release", "(", ")", ";", "}", "}", ")", ";", "}", ")", "// failed to acquire the client", ".", "fail", "(", "function", "(", "e", ")", "{", "deferred", ".", "reject", "(", "e", ")", ";", "}", ")", ";", "return", "deferred", ".", "promise", ";", "}" ]

[ "Retrieve", "a", "piece", "of", "data", "from", "a", "named", "collection", "based", "on", "the", "criteria", "return", "promise", "with", "an", "array", "of", "the", "results", "when", "done", "." ]

[ "function", "(", "collectionID", ",", "key", ")", "{", "collectionID", "=", "collectionID", ".", "toLowerCase", "(", ")", ";", "var", "deferred", "=", "q", ".", "defer", "(", ")", ";", "schemaSyncer", ".", "prepCollection", "(", "collectionID", ")", ".", "then", "(", "function", "(", ")", "{", "sqliteObj", ".", "find", "(", "collectionID", ",", "{", "'_id'", ":", "key", "}", ",", "false", ",", "1", ")", ".", "then", "(", "// success", "function", "(", "r", ")", "{", "if", "(", "r", "&&", "r", ".", "length", ">", "0", ")", "{", "var", "firstElement", "=", "r", "[", "0", "]", ";", "if", "(", "isValue", "(", "firstElement", "[", "key", "]", ")", ")", "{", "var", "value", "=", "firstElement", "[", "key", "]", ";", "deferred", ".", "resolve", "(", "value", ")", ";", "}", "else", "{", "deferred", ".", "resolve", "(", "firstElement", ")", ";", "}", "}", "return", "deferred", ".", "resolve", "(", "null", ")", ";", "}", ",", "// failure", "function", "(", "e", ")", "{", "return", "q", ".", "reject", "(", "e", ")", ";", "}", ")", ";", "}", ")", ";", "return", "deferred", ".", "promise", ";", "}" ]

[ "Retrieve", "a", "piece", "of", "data", "from", "a", "named", "collection", "whose", "key", "is", "the", "one", "provided", "." ]

[ "function", "(", "collectionID", ",", "key", ")", "{", "collectionID", "=", "collectionID", ".", "toLowerCase", "(", ")", ";", "var", "deferred", "=", "q", ".", "defer", "(", ")", ";", "// acquire a connection from the pool", "db", ".", "getClient", "(", ")", ".", "then", "(", "function", "(", "dbClient", ")", "{", "if", "(", "!", "dbClient", ")", "{", "throw", "Error", "(", "\"Failed to acquire sqlite client\"", ")", ";", "}", "// start a transaction using the acquired db connection", "startTx", "(", "dbClient", ")", ".", "then", "(", "function", "(", ")", "{", "var", "sql", "=", "sqlAdaptor", ".", "createDeleteSQL", "(", "collectionID", ",", "key", ")", ";", "return", "query", "(", "dbClient", ",", "sql", ")", ";", "}", ")", "// commit the transaction if no problems are encountered, this should also close the acquired db client", "// and return it to the connection pool", ".", "then", "(", "function", "(", "r", ")", "{", "return", "commitTx", "(", "dbClient", ")", ".", "then", "(", "function", "(", ")", "{", "deferred", ".", "resolve", "(", "r", ")", ";", "}", ")", ";", "}", ")", "// ultimately rollback if there is any upstream thrown exception caught", ".", "catch", "(", "function", "(", "e", ")", "{", "return", "rollbackTx", "(", "dbClient", ",", "e", ")", ".", "finally", "(", "function", "(", ")", "{", "deferred", ".", "reject", "(", "e", ")", ";", "}", ")", ";", "}", ")", "// always try to release the client, if it exists", ".", "finally", "(", "function", "(", ")", "{", "if", "(", "dbClient", ")", "{", "// always try to release the client, if it exists", "dbClient", ".", "release", "(", ")", ";", "}", "}", ")", ";", "}", ")", "// failed to acquire the client", ".", "fail", "(", "function", "(", "e", ")", "{", "deferred", ".", "reject", "(", "e", ")", ";", "}", ")", ";", "return", "deferred", ".", "promise", ";", "}" ]

[ "Remove", "a", "piece", "of", "data", "from", "a", "name", "collection", "based", "to", "the", "provided", "key", "return", "promise", "containing", "removed", "items", "when", "done", ".", "If", "no", "key", "is", "provided", "all", "the", "data", "from", "the", "collection", "is", "removed", ".", "Is", "transactional", "-", "will", "rollback", "on", "error", "." ]

[ "function", "Comment", "(", ")", "{", "this", ".", "type", "=", "'func'", ";", "//func or attr", "this", ".", "descs", "=", "[", "]", ";", "this", ".", "attr", "=", "{", "name", ":", "null", "}", ";", "this", ".", "func", "=", "{", "name", ":", "null", ",", "params", ":", "null", "}", ";", "this", ".", "clazz", "=", "null", ";", "//class", "this", ".", "zuper", "=", "null", ";", "//super", "this", ".", "tags", "=", "{", "/*\n name:[val1,val2]\n */", "}", ";", "}" ]

[ "Comment", "is", "a", "block", "of", "source", "comemnt", "." ]

[ "function", "(", "name", ",", "value", ")", "{", "name", "=", "name", ".", "trim", "(", ")", ";", "value", "=", "(", "value", "||", "\"\"", ")", ".", "trim", "(", ")", ";", "switch", "(", "name", ")", "{", "//The following are single allowed.", "case", "'return'", ":", "case", "'copyright'", ":", "case", "'author'", ":", "case", "'since'", ":", "case", "'description'", ":", "case", "'example'", ":", "case", "'version'", ":", "case", "'override'", ":", "case", "'todo'", ":", "case", "'type'", ":", "case", "'ignore'", ":", "case", "'deprecated'", ":", "this", ".", "tags", "[", "name", "]", "=", "value", ";", "break", ";", "//The following are multiple allowed", "case", "'param'", ":", "case", "'see'", ":", "case", "'throws'", ":", "if", "(", "!", "Array", ".", "isArray", "(", "this", ".", "tags", "[", "name", "]", ")", ")", "{", "this", ".", "tags", "[", "name", "]", "=", "[", "value", "]", ";", "}", "else", "{", "this", ".", "tags", "[", "name", "]", ".", "push", "(", "value", ")", ";", "}", "break", ";", "//The following are meaning stuff.", "case", "'class'", ":", "this", ".", "clazz", "=", "value", ";", "break", ";", "case", "'extends'", ":", "this", ".", "zuper", "=", "value", ";", "break", ";", "default", ":", "//ignore others", "}", "}" ]

[ "Add", "a", "tag", "except", "class", "extends" ]

[ "function", "SourceTextParser", "(", "sourceText", ",", "classes", ",", "methods", ")", "{", "this", ".", "Comments", "=", "[", "]", ";", "this", ".", "sourceText", "=", "sourceText", ";", "this", ".", "classes", "=", "classes", ";", "this", ".", "methods", "=", "methods", ";", "}" ]

[ "Source", "text", "parser", "." ]

[ "function", "(", ")", "{", "var", "line", ",", "lines", "=", "this", ".", "sourceText", ".", "split", "(", "/", "\\n", "/", "mg", ")", ",", "lineLen", "=", "lines", ".", "length", ";", "var", "inCommenting", ",", "curComment", ",", "closeCommentIdx", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "lineLen", ";", "++", "i", ")", "{", "line", "=", "lines", "[", "i", "]", ".", "trim", "(", ")", ";", "if", "(", "line", ".", "startsWith", "(", "'/**'", ")", ")", "{", "inCommenting", "=", "true", ";", "curComment", "=", "new", "Comment", "(", ")", ";", "//Comment closed has to starts with \"*/\"", "}", "else", "if", "(", "line", ".", "startsWith", "(", "'*/'", ")", ")", "{", "inCommenting", "=", "false", ";", "closeCommentIdx", "=", "i", ";", "}", "else", "if", "(", "!", "inCommenting", "&&", "(", "1", "===", "i", "-", "closeCommentIdx", ")", "&&", "/", "(\\bfunction\\b\\s*?(\\w+?)\\s*\\(([^\\(\\)]*)\\))|((\\w+)?\\s*(?::|=)\\s*function\\s*\\(([^\\(\\)]*)\\))", "/", ".", "test", "(", "line", ")", ")", "{", "curComment", ".", "setFunc", "(", "RegExp", ".", "$2", "||", "RegExp", ".", "$5", ",", "RegExp", ".", "$3", "||", "RegExp", ".", "$6", ")", ";", "if", "(", "'string'", "!==", "typeof", "curComment", ".", "getTag", "(", "'ignore'", ")", ")", "{", "this", ".", "Comments", ".", "push", "(", "curComment", ")", ";", "}", "curComment", "=", "null", ";", "}", "else", "if", "(", "!", "inCommenting", "&&", "(", "1", "===", "i", "-", "closeCommentIdx", ")", "&&", "/", "(\\w+)\\s*(?::|=)(?!\\s*function)", "/", ".", "test", "(", "line", ")", ")", "{", "curComment", ".", "setAttr", "(", "RegExp", ".", "$1", ")", ";", "if", "(", "'string'", "!==", "typeof", "curComment", ".", "getTag", "(", "'ignore'", ")", ")", "{", "this", ".", "Comments", ".", "push", "(", "curComment", ")", ";", "}", "curComment", "=", "null", ";", "}", "else", "if", "(", "inCommenting", ")", "{", "line", "=", "line", ".", "replace", "(", "/", "^\\*", "/", ",", "''", ")", ".", "trim", "(", ")", ";", "if", "(", "/", "^@(\\w+)([^\\r\\n]*)", "/", ".", "test", "(", "line", ")", ")", "{", "curComment", ".", "addTag", "(", "RegExp", ".", "$1", ",", "RegExp", ".", "$2", "||", "\"\"", ")", ";", "}", "else", "{", "curComment", ".", "addDesc", "(", "line", ")", ";", "}", "}", "}", "//for", "this", ".", "_merge", "(", ")", ";", "}" ]

[ "Parse", "the", "source", "text", "to", "Comment", "structure", "." ]

[ "function", "createPage", "(", "filename", ")", "{", "let", "page", "=", "{", "path", ":", "filename", ",", "rawContent", ":", "fs", ".", "readFileSync", "(", "filename", ",", "\"utf8\"", ")", ",", "name", ":", "path", ".", "basename", "(", "filename", ")", ".", "replace", "(", "/", "\\.[^/.]+$", "/", ",", "\"\"", ")", ",", "filename", ":", "path", ".", "basename", "(", "filename", ")", ",", "folder", ":", "path", ".", "dirname", "(", "filename", ")", ",", "ext", ":", "path", ".", "extname", "(", "filename", ")", ",", "userData", ":", "{", "}", "}", ";", "page", ".", "isMarkdown", "=", "page", ".", "ext", ".", "toLocaleUpperCase", "(", ")", "==", "\".MD\"", ";", "if", "(", "page", ".", "isMarkdown", ")", "page", ".", "ext", "=", "\".html\"", ";", "page", ".", "template", "=", "doT", ".", "template", "(", "page", ".", "rawContent", ",", "null", ",", "page", ".", "userData", ")", ";", "page", ".", "outPath", "=", "path", ".", "join", "(", "path", ".", "relative", "(", "CONTENT", ",", "page", ".", "folder", ")", ",", "page", ".", "name", "+", "page", ".", "ext", ")", ";", "page", ".", "href", "=", "CONFIG", ".", "prefix", "+", "page", ".", "outPath", ";", "return", "page", ";", "}" ]

[ "Create", "page", "-", "templates" ]

[ "function", "(", "model", ")", "{", "model", ".", "unbind", "(", "'destroy'", ",", "this", ".", "unregister", ")", ";", "var", "coll", "=", "this", ".", "getCollection", "(", "model", ")", ";", "coll", "&&", "coll", ".", "remove", "(", "model", ")", ";", "}" ]

[ "Remove", "a", "model", "from", "the", "store", "." ]

[ "function", "(", "collection", ")", "{", "if", "(", "this", ".", "related", ")", "{", "this", ".", "related", ".", "unbind", "(", "'relational:add'", ",", "this", ".", "handleAddition", ")", ".", "unbind", "(", "'relational:remove'", ",", "this", ".", "handleRemoval", ")", ".", "unbind", "(", "'relational:reset'", ",", "this", ".", "handleReset", ")", "}", "if", "(", "!", "collection", "||", "!", "(", "collection", "instanceof", "Backbone", ".", "Collection", ")", ")", "{", "collection", "=", "new", "this", ".", "collectionType", "(", "[", "]", ",", "this", ".", "_getCollectionOptions", "(", ")", ")", ";", "}", "collection", ".", "model", "=", "this", ".", "relatedModel", ";", "if", "(", "this", ".", "options", ".", "collectionKey", ")", "{", "var", "key", "=", "this", ".", "options", ".", "collectionKey", "===", "true", "?", "this", ".", "options", ".", "reverseRelation", ".", "key", ":", "this", ".", "options", ".", "collectionKey", ";", "if", "(", "collection", "[", "key", "]", "&&", "collection", "[", "key", "]", "!==", "this", ".", "instance", ")", "{", "if", "(", "Backbone", ".", "Relational", ".", "showWarnings", "&&", "typeof", "console", "!==", "'undefined'", ")", "{", "console", ".", "warn", "(", "'Relation=%o; collectionKey=%s already exists on collection=%o'", ",", "this", ",", "key", ",", "this", ".", "options", ".", "collectionKey", ")", ";", "}", "}", "else", "if", "(", "key", ")", "{", "collection", "[", "key", "]", "=", "this", ".", "instance", ";", "}", "}", "collection", ".", "bind", "(", "'relational:add'", ",", "this", ".", "handleAddition", ")", ".", "bind", "(", "'relational:remove'", ",", "this", ".", "handleRemoval", ")", ".", "bind", "(", "'relational:reset'", ",", "this", ".", "handleReset", ")", ";", "return", "collection", ";", "}" ]

[ "Bind", "events", "and", "setup", "collectionKeys", "for", "a", "collection", "that", "is", "to", "be", "used", "as", "the", "backing", "store", "for", "a", "HasMany", ".", "If", "no", "collection", "is", "supplied", "a", "new", "collection", "will", "be", "created", "of", "the", "specified", "collectionType", "option", "." ]

[ "function", "(", "attributes", ",", "options", ")", "{", "var", "model", "=", "this", ";", "// 'build' is a possible entrypoint; it's possible no model hierarchy has been determined yet.", "this", ".", "initializeModelHierarchy", "(", ")", ";", "// Determine what type of (sub)model should be built if applicable.", "// Lookup the proper subModelType in 'this._subModels'.", "if", "(", "this", ".", "_subModels", "&&", "this", ".", "prototype", ".", "subModelTypeAttribute", "in", "attributes", ")", "{", "var", "subModelTypeAttribute", "=", "attributes", "[", "this", ".", "prototype", ".", "subModelTypeAttribute", "]", ";", "var", "subModelType", "=", "this", ".", "_subModels", "[", "subModelTypeAttribute", "]", ";", "if", "(", "subModelType", ")", "{", "model", "=", "subModelType", ";", "}", "}", "return", "new", "model", "(", "attributes", ",", "options", ")", ";", "}" ]

[ "Create", "a", "Backbone", ".", "Model", "instance", "based", "on", "attributes", "." ]

[ "function", "(", "element", ")", "{", "var", "event", "=", "document", ".", "createEvent", "(", "'MouseEvents'", ")", ";", "event", ".", "initMouseEvent", "(", "'mousedown'", ",", "true", ",", "true", ",", "window", ")", ";", "element", ".", "dispatchEvent", "(", "event", ")", ";", "}" ]

[ "click", "element", "with", "virtual", "mouse", "." ]

[ "function", "(", "event", ")", "{", "var", "inputs", "=", "$", "(", "event", ".", "target", ")", ".", "parents", "(", "\"form\"", ")", ".", "eq", "(", "0", ")", ".", "find", "(", "\":input:visible\"", ")", ";", "var", "inputIndex", "=", "inputs", ".", "index", "(", "event", ".", "target", ")", ";", "// If at end of focusable elements return false, if not move forward one.", "if", "(", "inputIndex", "==", "inputs", ".", "length", "-", "1", ")", "{", "// return false on last form input so we know to let the form submit.", "return", "false", "}", "else", "{", "inputs", "[", "inputIndex", "+", "1", "]", ".", "focus", "(", ")", ";", "}", "}" ]

[ "Move", "tab", "index", "forward", "one", "input", "inside", "the", "form", "an", "event", "originates", "." ]

[ "function", "valid", "(", "connote", ")", "{", "if", "(", "typeof", "connote", "!=", "\"string\"", ")", "{", "return", "false", ";", "}", "connote", "=", "connote", ".", "trim", "(", ")", ".", "toUpperCase", "(", ")", ";", "// handle 14 character couriers please", "if", "(", "connote", ".", "length", "===", "14", "&&", "connote", ".", "indexOf", "(", "\"CP\"", ")", "===", "0", ")", "{", "return", "false", ";", "}", "return", "[", "10", ",", "14", ",", "18", ",", "21", ",", "39", ",", "40", "]", ".", "indexOf", "(", "connote", ".", "length", ")", "!=", "-", "1", ";", "}" ]

[ "AustraliaPost", "connotes", "are", "various", "lengths" ]

[ "function", "enforce", "(", "targetFunction", ")", "{", "assert", "(", "_", ".", "isFunction", "(", "targetFunction", ")", ",", "'argument to wrap must be a function'", ")", ";", "assert", "(", "_", ".", "isObject", "(", "targetFunction", ".", "$schema", ")", ",", "`", "${", "targetFunction", ".", "name", "}", "`", ")", ";", "assert", "(", "_", ".", "isArray", "(", "targetFunction", ".", "$schema", ".", "arguments", ")", ",", "`", "${", "targetFunction", ".", "name", "}", "`", ")", ";", "assert", "(", "_", ".", "isArray", "(", "targetFunction", ".", "$schema", ".", "callbackResult", ")", ",", "`", "${", "targetFunction", ".", "name", "}", "`", "+", "'$schema.callbackResult property.'", ")", ";", "const", "fnName", "=", "_", ".", "toString", "(", "targetFunction", ".", "name", ")", ";", "// Return wrapped function, executes in a new context..", "const", "wrappedFunc", "=", "function", "wrappedFunc", "(", "...", "args", ")", "{", "if", "(", "!", "args", ".", "length", ")", "{", "throw", "new", "Error", "(", "`", "${", "fnName", "}", "`", ")", ";", "}", "//", "// Splice callback out of arguments array.", "//", "let", "originalCb", "=", "_", ".", "last", "(", "args", ")", ";", "assert", "(", "_", ".", "isFunction", "(", "originalCb", ")", ",", "`", "${", "fnName", "}", "`", ")", ";", "args", ".", "splice", "(", "args", ".", "length", "-", "1", ",", "1", ")", ";", "originalCb", "=", "_", ".", "once", "(", "originalCb", ")", ";", "//", "// Type-check arguments against \"arguments\" schema, invoke callback with", "// schema validation errors. This will throw its own errors.", "//", "const", "schemaArgs", "=", "{", "type", ":", "'array'", ",", "elements", ":", "targetFunction", ".", "$schema", ".", "arguments", ",", "}", ";", "try", "{", "construct", "(", "schemaArgs", ",", "args", ")", ";", "}", "catch", "(", "e", ")", "{", "return", "originalCb", "(", "new", "Error", "(", "`", "${", "fnName", "}", "${", "e", ".", "message", "}", "`", ")", ")", ";", "}", "//", "// Replace callback argument with an intercepting callback function.", "//", "args", ".", "push", "(", "(", "...", "resultArray", ")", "=>", "{", "const", "err", "=", "resultArray", ".", "length", "?", "resultArray", "[", "0", "]", ":", "undefined", ";", "const", "results", "=", "resultArray", ".", "slice", "(", "1", ")", ";", "if", "(", "err", ")", "{", "// Pass errors through unfiltered.", "return", "originalCb", "(", "err", ")", ";", "}", "// Type-check results, these must be passed to the callback, since they", "// cannot be thrown.", "const", "schemaCbResult", "=", "{", "type", ":", "'array'", ",", "elements", ":", "targetFunction", ".", "$schema", ".", "callbackResult", ",", "}", ";", "try", "{", "construct", "(", "schemaCbResult", ",", "results", ")", ";", "}", "catch", "(", "e", ")", "{", "return", "originalCb", "(", "new", "Error", "(", "`", "${", "fnName", "}", "`", "+", "`", "${", "e", ".", "message", "}", "`", ")", ")", ";", "}", "// Success, invoke original callback with results.", "return", "originalCb", "(", "...", "resultArray", ")", ";", "}", ")", ";", "//", "// Invoke target function, pass exceptions to callback.", "//", "let", "rv", ";", "try", "{", "rv", "=", "targetFunction", ".", "call", "(", "this", ",", "...", "args", ")", ";", "}", "catch", "(", "e", ")", "{", "return", "originalCb", "(", "e", ")", ";", "}", "return", "rv", ";", "}", ";", "wrappedFunc", ".", "$schema", "=", "targetFunction", ".", "$schema", ";", "return", "wrappedFunc", ";", "}" ]

[ "Wraps", "an", "asychronous", "function", "with", "runtime", "type", "argument", "and", "return", "value", "type", "checking", "." ]

[ "function", "wrappedFunc", "(", "...", "args", ")", "{", "if", "(", "!", "args", ".", "length", ")", "{", "throw", "new", "Error", "(", "`", "${", "fnName", "}", "`", ")", ";", "}", "//", "// Splice callback out of arguments array.", "//", "let", "originalCb", "=", "_", ".", "last", "(", "args", ")", ";", "assert", "(", "_", ".", "isFunction", "(", "originalCb", ")", ",", "`", "${", "fnName", "}", "`", ")", ";", "args", ".", "splice", "(", "args", ".", "length", "-", "1", ",", "1", ")", ";", "originalCb", "=", "_", ".", "once", "(", "originalCb", ")", ";", "//", "// Type-check arguments against \"arguments\" schema, invoke callback with", "// schema validation errors. This will throw its own errors.", "//", "const", "schemaArgs", "=", "{", "type", ":", "'array'", ",", "elements", ":", "targetFunction", ".", "$schema", ".", "arguments", ",", "}", ";", "try", "{", "construct", "(", "schemaArgs", ",", "args", ")", ";", "}", "catch", "(", "e", ")", "{", "return", "originalCb", "(", "new", "Error", "(", "`", "${", "fnName", "}", "${", "e", ".", "message", "}", "`", ")", ")", ";", "}", "//", "// Replace callback argument with an intercepting callback function.", "//", "args", ".", "push", "(", "(", "...", "resultArray", ")", "=>", "{", "const", "err", "=", "resultArray", ".", "length", "?", "resultArray", "[", "0", "]", ":", "undefined", ";", "const", "results", "=", "resultArray", ".", "slice", "(", "1", ")", ";", "if", "(", "err", ")", "{", "// Pass errors through unfiltered.", "return", "originalCb", "(", "err", ")", ";", "}", "// Type-check results, these must be passed to the callback, since they", "// cannot be thrown.", "const", "schemaCbResult", "=", "{", "type", ":", "'array'", ",", "elements", ":", "targetFunction", ".", "$schema", ".", "callbackResult", ",", "}", ";", "try", "{", "construct", "(", "schemaCbResult", ",", "results", ")", ";", "}", "catch", "(", "e", ")", "{", "return", "originalCb", "(", "new", "Error", "(", "`", "${", "fnName", "}", "`", "+", "`", "${", "e", ".", "message", "}", "`", ")", ")", ";", "}", "// Success, invoke original callback with results.", "return", "originalCb", "(", "...", "resultArray", ")", ";", "}", ")", ";", "//", "// Invoke target function, pass exceptions to callback.", "//", "let", "rv", ";", "try", "{", "rv", "=", "targetFunction", ".", "call", "(", "this", ",", "...", "args", ")", ";", "}", "catch", "(", "e", ")", "{", "return", "originalCb", "(", "e", ")", ";", "}", "return", "rv", ";", "}" ]

[ "Return", "wrapped", "function", "executes", "in", "a", "new", "context", ".." ]

[ "function", "countSubTreeDepth", "(", "scope", ")", "{", "var", "thisLevelDepth", "=", "0", ",", "childNodes", "=", "scope", ".", "childNodes", "(", ")", ",", "childNode", ",", "childDepth", ",", "i", ";", "if", "(", "!", "childNodes", "||", "childNodes", ".", "length", "===", "0", ")", "{", "return", "0", ";", "}", "for", "(", "i", "=", "childNodes", ".", "length", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "childNode", "=", "childNodes", "[", "i", "]", ",", "childDepth", "=", "1", "+", "countSubTreeDepth", "(", "childNode", ")", ";", "thisLevelDepth", "=", "Math", ".", "max", "(", "thisLevelDepth", ",", "childDepth", ")", ";", "}", "return", "thisLevelDepth", ";", "}" ]

[ "Returns", "the", "depth", "of", "the", "deepest", "subtree", "under", "this", "node" ]

[ "function", "(", "parent", ",", "siblings", ",", "index", ")", "{", "this", ".", "parent", "=", "parent", ";", "this", ".", "siblings", "=", "siblings", ".", "slice", "(", "0", ")", ";", "// If source node is in the target nodes", "var", "i", "=", "this", ".", "siblings", ".", "indexOf", "(", "this", ".", "source", ")", ";", "if", "(", "i", ">", "-", "1", ")", "{", "this", ".", "siblings", ".", "splice", "(", "i", ",", "1", ")", ";", "if", "(", "this", ".", "source", ".", "index", "(", ")", "<", "index", ")", "{", "index", "--", ";", "}", "}", "this", ".", "siblings", ".", "splice", "(", "index", ",", "0", ",", "this", ".", "source", ")", ";", "this", ".", "index", "=", "index", ";", "}" ]

[ "Move", "the", "node", "to", "a", "new", "position" ]

[ "function", "encrypt", "(", "message", ")", "{", "if", "(", "this", ".", "secure", "&&", "this", ".", "cipher", "&&", "this", ".", "secret", ")", "{", "if", "(", "this", ".", "secret", "===", "'secret'", ")", "{", "console", ".", "warn", "(", "'PLEASE change default secret password!'", ")", ";", "}", "debug", "(", "'%s encrypt message with %s'", ",", "this", ".", "name", ",", "this", ".", "cipher", ")", ";", "var", "cipher", "=", "crypto", ".", "createCipher", "(", "this", ".", "cipher", ",", "this", ".", "secret", ")", ";", "return", "Buffer", ".", "concat", "(", "[", "cipher", ".", "update", "(", "message", ")", ",", "cipher", ".", "final", "(", ")", "]", ")", ";", "}", "return", "message", ";", "}" ]

[ "Encrypt", "a", "message" ]

[ "function", "decrypt", "(", "message", ")", "{", "if", "(", "this", ".", "secure", "&&", "this", ".", "cipher", "&&", "this", ".", "secret", ")", "{", "if", "(", "this", ".", "secret", "===", "'secret'", ")", "{", "console", ".", "warn", "(", "'PLEASE change default secret password!'", ")", ";", "}", "debug", "(", "'%s decrypt message with %s'", ",", "this", ".", "name", ",", "this", ".", "cipher", ")", ";", "var", "decipher", "=", "crypto", ".", "createDecipher", "(", "this", ".", "cipher", ",", "this", ".", "secret", ")", ";", "return", "Buffer", ".", "concat", "(", "[", "decipher", ".", "update", "(", "message", ")", ",", "decipher", ".", "final", "(", ")", "]", ")", ";", "}", "return", "message", ";", "}" ]

[ "Decrypt", "a", "message" ]

[ "function", "verifyAddress", "(", "address", ")", "{", "var", "ifs", "=", "os", ".", "networkInterfaces", "(", ")", ";", "var", "nics", "=", "Object", ".", "keys", "(", "ifs", ")", ";", "var", "i", ",", "j", ",", "match", "=", "false", ";", "nicLoop", ":", "for", "(", "i", "=", "0", ";", "i", "<", "nics", ".", "length", ";", "i", "++", ")", "{", "var", "nic", "=", "ifs", "[", "nics", "[", "i", "]", "]", ";", "for", "(", "j", "=", "0", ";", "j", "<", "nic", ".", "length", ";", "j", "++", ")", "{", "if", "(", "nic", "[", "j", "]", ".", "address", "===", "address", "&&", "!", "nic", "[", "j", "]", ".", "internal", ")", "{", "match", "=", "true", ";", "break", "nicLoop", ";", "}", "}", "}", "return", "match", ";", "}" ]

[ "Verify", "that", "a", "provided", "address", "is", "configured", "on", "a", "NIC" ]

[ "function", "flatten", "(", "arr", ")", "{", "return", "arr", ".", "reduce", "(", "function", "(", "flat", ",", "toFlatten", ")", "{", "// See if this index is an array that itself needs to be flattened.", "if", "(", "toFlatten", ".", "some", "&&", "toFlatten", ".", "some", "(", "Array", ".", "isArray", ")", ")", "{", "return", "flat", ".", "concat", "(", "flatten", "(", "toFlatten", ")", ")", ";", "// Otherwise just add the current index to the end of the flattened array.", "}", "else", "{", "return", "flat", ".", "concat", "(", "toFlatten", ")", ";", "}", "}", ",", "[", "]", ")", ";", "}" ]

[ "flattens", "array", "of", "arrays", "of", "arrays", "..." ]

[ "function", "Registrations", "(", ")", "{", "Object", ".", "defineProperty", "(", "this", ",", "'_registrations'", ",", "{", "value", ":", "{", "}", ",", "enumerable", ":", "false", ",", "configurable", ":", "false", ",", "writable", ":", "false", "}", ")", "this", ".", "get", "=", "this", ".", "get", ".", "bind", "(", "this", ")", "this", ".", "put", "=", "this", ".", "put", ".", "bind", "(", "this", ")", "this", ".", "clear", "=", "this", ".", "clear", ".", "bind", "(", "this", ")", "this", ".", "has", "=", "this", ".", "has", ".", "bind", "(", "this", ")", "}" ]

[ "Registrations", "collection", "stores", "all", "configurations", "created", "for", "the", "container", "to", "resolve", "at", "runtime" ]

[ "function", "assembleAttrsFromServer", "(", "seedData", ",", "formObjectClass", ")", "{", "// Early return when there was no serialized object provided by the server", "if", "(", "!", "seedData", ")", "{", "return", "{", "}", "}", "// Otherwise assemble main and submodels' fields", "let", "attrs", "=", "merge", "(", "{", "}", ",", "seedData", ".", "fields", ",", "seedData", ".", "errors", ")", "// TODO: reenable this, but consider there might be ids/ id arrays in there", "// for (let submodel of formObjectClass.submodels) {", "// if (seedData.fields[submodel]) {", "// let submodelData = seedData.fields[submodel]", "// attrs[submodel] = merge({}, submodelData.fields, submodelData.errors)", "// }", "// }", "return", "attrs", "}" ]

[ "the", "values", "we", "want", "from", "the", "server", "-", "provided", "serialized", "object", "are", "nested", "under", "fields", ".", "The", "same", "is", "true", "for", "included", "submodels", "." ]

[ "function", "addCtrActionsToRouter", "(", "ctr", ",", "router", ",", "name", ",", "options", ")", "{", "for", "(", "let", "prop", "in", "ctr", ")", "{", "if", "(", "ctr", "[", "prop", "]", "instanceof", "Function", ")", "{", "const", "info", "=", "new", "RouteInfo", "(", "ctr", ",", "name", ",", "prop", ",", "ctr", "[", "prop", "]", ",", "options", ")", "/**\r\n * e.g. router.get(path, Middleware).\r\n */", "const", "path", "=", "name", "?", "'/'", "+", "name", "+", "info", ".", "path", ":", "info", ".", "path", "const", "mw", "=", "newMiddleware", "(", "info", ")", "debug", "(", "'Add route to %s %s'", ",", "info", ".", "method", ",", "path", ")", "router", "[", "info", ".", "method", "]", ".", "call", "(", "router", ",", "path", ",", "mw", ")", "}", "}", "return", "router", "}" ]

[ "For", "each", "method", "of", "ctr", "object", "creates", "a", "new", "Middleware", "that", "is", "added", "to", "router", "argument", ".", "Route", "query", "or", "body", "parameters", "are", "automatically", "mapped", "to", "method", "arguments", "." ]