Datasets:

---

CM

/

codexglue_code2text_javascript

like 12

[ "function", "(", "path", ")", "{", "var", "stat", "=", "null", ";", "try", "{", "stat", "=", "fs", ".", "statSync", "(", "path", ")", ";", "}", "catch", "(", "err", ")", "{", "console", ".", "log", "(", "err", ")", ";", "}", "return", "(", "stat", "&&", "stat", ".", "isFile", "(", ")", ")", ";", "}" ]

[ "Loads", "config", "file", "with", "many", "options" ]

[ "function", "loadHighlighter", "(", ")", "{", "var", "headElem", "=", "d", ".", "querySelector", "(", "'head'", ")", ";", "headElem", ".", "appendChild", "(", "h", "(", "'link'", ",", "{", "rel", ":", "'stylesheet'", ",", "href", ":", "'http://cdnjs.cloudflare.com/ajax/libs/highlight.js/8.4/styles/default.min.css'", "}", ")", ")", ";", "headElem", ".", "appendChild", "(", "h", "(", "'script'", ",", "{", "src", ":", "'http://cdnjs.cloudflare.com/ajax/libs/highlight.js/8.4/highlight.min.js'", "}", ")", ")", ";", "var", "interval", "=", "setInterval", "(", "function", "(", ")", "{", "if", "(", "!", "!", "window", ".", "hljs", ")", "{", "clearInterval", "(", "interval", ")", ";", "applyHighlighter", "(", ")", ";", "}", "}", ",", "100", ")", ";", "}" ]

[ "load", "syntax", "highlighting", "code" ]

[ "function", "algebraRing", "(", "identities", ",", "given", ")", "{", "// A ring is a group, with multiplication.", "const", "ring", "=", "group", "(", "{", "identity", ":", "identities", "[", "0", "]", ",", "contains", ":", "given", ".", "contains", ",", "equality", ":", "given", ".", "equality", ",", "compositionLaw", ":", "given", ".", "addition", ",", "inversion", ":", "given", ".", "negation", "}", ")", "// operators", "function", "multiplication", "(", ")", "{", "return", "[", "]", ".", "slice", ".", "call", "(", "arguments", ")", ".", "reduce", "(", "given", ".", "multiplication", ")", "}", "function", "inversion", "(", "a", ")", "{", "if", "(", "ring", ".", "equality", "(", "a", ",", "ring", ".", "zero", ")", ")", "{", "throw", "new", "TypeError", "(", "error", ".", "cannotDivideByZero", ")", "}", "return", "given", ".", "inversion", "(", "a", ")", "}", "function", "division", "(", "a", ")", "{", "const", "rest", "=", "[", "]", ".", "slice", ".", "call", "(", "arguments", ",", "1", ")", "return", "given", ".", "multiplication", "(", "a", ",", "rest", ".", "map", "(", "inversion", ")", ".", "reduce", "(", "given", ".", "multiplication", ")", ")", "}", "ring", ".", "multiplication", "=", "multiplication", "ring", ".", "inversion", "=", "inversion", "ring", ".", "division", "=", "division", "// Multiplicative identity.", "const", "one", "=", "identities", "[", "1", "]", "if", "(", "ring", ".", "notContains", "(", "one", ")", ")", "{", "throw", "new", "TypeError", "(", "error", ".", "doesNotContainIdentity", ")", "}", "// Check that one*one=one.", "if", "(", "ring", ".", "disequality", "(", "given", ".", "multiplication", "(", "one", ",", "one", ")", ",", "one", ")", ")", "{", "throw", "new", "TypeError", "(", "error", ".", "identityIsNotNeutral", ")", "}", "if", "(", "ring", ".", "notContains", "(", "identities", "[", "1", "]", ")", ")", "{", "throw", "new", "TypeError", "(", "error", ".", "doesNotContainIdentity", ")", "}", "ring", ".", "one", "=", "identities", "[", "1", "]", "return", "ring", "}" ]

[ "Define", "an", "algebra", "ring", "structure" ]

[ "function", "__pandocAvailable", "(", "cb", ")", "{", "var", "test", "=", "spawn", "(", "'pandoc'", ",", "[", "'--help'", "]", ")", ";", "test", ".", "on", "(", "'error'", ",", "function", "(", ")", "{", "console", ".", "error", "(", "'Pandoc not found'", ")", ";", "cb", "(", "'Pandoc not found'", ")", ";", "}", ")", ";", "test", ".", "on", "(", "'exit'", ",", "function", "(", ")", "{", "cb", "(", "null", ")", ";", "}", ")", ";", "test", ".", "stdin", ".", "end", "(", ")", ";", "}" ]

[ "Checks", "if", "the", "pandoc", "tool", "is", "available" ]

[ "function", "(", "user", ",", "permissions", ",", "options", ")", "{", "if", "(", "!", "permissions", "||", "_", ".", "isString", "(", "permissions", ")", ")", "{", "if", "(", "!", "initialized", ")", "{", "throw", "\"You must initialize FacebookUtils before calling link.\"", ";", "}", "requestedPermissions", "=", "permissions", ";", "return", "user", ".", "_linkWith", "(", "\"facebook\"", ",", "options", ")", ";", "}", "else", "{", "var", "newOptions", "=", "_", ".", "clone", "(", "options", ")", "||", "{", "}", ";", "newOptions", ".", "authData", "=", "permissions", ";", "return", "user", ".", "_linkWith", "(", "\"facebook\"", ",", "newOptions", ")", ";", "}", "}" ]

[ "Links", "Facebook", "to", "an", "existing", "PFUser", ".", "This", "method", "delegates", "to", "the", "Facebook", "SDK", "to", "authenticate", "the", "user", "and", "then", "automatically", "links", "the", "account", "to", "the", "Parse", ".", "User", "." ]

[ "function", "expand", "(", "source", ",", "opts", ")", "{", "opts", "=", "opts", "||", "{", "}", ";", "var", "re", "=", "opts", ".", "re", "=", "opts", ".", "re", "||", "'.'", ",", "isre", "=", "(", "re", "instanceof", "RegExp", ")", ",", "o", "=", "{", "}", ",", "k", ",", "v", ",", "parts", ",", "i", ",", "p", ";", "for", "(", "k", "in", "source", ")", "{", "v", "=", "source", "[", "k", "]", ";", "if", "(", "isre", "?", "!", "re", ".", "test", "(", "k", ")", ":", "!", "~", "k", ".", "indexOf", "(", "re", ")", ")", "{", "o", "[", "k", "]", "=", "v", ";", "}", "else", "{", "parts", "=", "k", ".", "split", "(", "re", ")", ";", "p", "=", "o", ";", "for", "(", "i", "=", "0", ";", "i", "<", "parts", ".", "length", ";", "i", "++", ")", "{", "k", "=", "parts", "[", "i", "]", ";", "if", "(", "i", "<", "parts", ".", "length", "-", "1", ")", "{", "p", "[", "k", "]", "=", "p", "[", "k", "]", "||", "{", "}", ";", "p", "=", "p", "[", "k", "]", ";", "}", "else", "{", "p", "[", "k", "]", "=", "v", ";", "}", "}", "}", "}", "return", "o", ";", "}" ]

[ "Takes", "a", "source", "object", "with", "dot", "-", "delimited", "keys", "and", "expands", "it", "to", "a", "deep", "object", "representation", "." ]

[ "function", "validateFile", "(", "path", ",", "rollCall", ")", "{", "var", "stat", "=", "path", "?", "fs", ".", "statSync", "(", "path", ")", ":", "{", "size", ":", "0", "}", ";", "if", "(", "!", "stat", ".", "size", ")", "{", "rollCall", ".", "error", "(", "'Failed to find any entries in \"'", "+", "path", "+", "'\" (file size: '", "+", "stat", ".", "size", "+", "')'", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}" ]

[ "Determines", "if", "a", "file", "has", "content", "and", "logs", "an", "error", "when", "the", "the", "file", "is", "empty" ]

[ "function", "updateFiles", "(", "files", ",", "func", ",", "bpath", ",", "eh", ")", "{", "try", "{", "if", "(", "Array", ".", "isArray", "(", "files", ")", "&&", "typeof", "func", "===", "'function'", ")", "{", "for", "(", "var", "i", "=", "0", ";", "i", "<", "files", ".", "length", ";", "i", "++", ")", "{", "var", "p", "=", "path", ".", "join", "(", "bpath", ",", "files", "[", "i", "]", ")", ",", "au", "=", "''", ";", "var", "content", "=", "rbot", ".", "file", ".", "read", "(", "p", ",", "{", "encoding", ":", "rbot", ".", "file", ".", "defaultEncoding", "}", ")", ";", "var", "ec", "=", "func", "(", "content", ",", "p", ")", ";", "if", "(", "content", "!==", "ec", ")", "{", "rbot", ".", "file", ".", "write", "(", "p", ",", "ec", ")", ";", "return", "au", ";", "}", "}", "}", "}", "catch", "(", "e", ")", "{", "if", "(", "typeof", "eh", "===", "'function'", ")", "{", "return", "eh", "(", "'Unable to update \"'", "+", "(", "Array", ".", "isArray", "(", "files", ")", "?", "files", ".", "join", "(", "','", ")", ":", "''", ")", "+", "'\" using: '", "+", "func", ",", "e", ")", ";", "}", "throw", "e", ";", "}", "}" ]

[ "Updates", "file", "contents", "using", "a", "specified", "function" ]

[ "function", "pickToArray", "(", "entities", ",", "property", ",", "deep", ")", "{", "if", "(", "!", "(", "entities", "instanceof", "Array", ")", "&&", "!", "isPlainObject", "(", "entities", ")", ")", "{", "throw", "new", "Error", "(", "'Expecting entity to be object or array of objects'", ")", "}", "else", "if", "(", "typeof", "property", "!==", "'string'", "&&", "!", "(", "property", "instanceof", "Array", ")", ")", "{", "throw", "new", "Error", "(", "'Expecting property to be string or array'", ")", "}", "var", "arr", "=", "entities", "instanceof", "Array", "?", "entities", ":", "[", "entities", "]", "return", "arr", ".", "reduce", "(", "function", "(", "result", ",", "obj", ")", "{", "if", "(", "!", "(", "obj", "instanceof", "Array", ")", "&&", "!", "isPlainObject", "(", "obj", ")", ")", "{", "return", "result", "}", "forEach", "(", "obj", ",", "function", "(", "value", ",", "key", ")", "{", "if", "(", "(", "property", "instanceof", "Array", "&&", "property", ".", "indexOf", "(", "key", ")", "!==", "-", "1", ")", "||", "(", "key", "===", "property", ")", ")", "{", "result", ".", "push", "(", "value", ")", "if", "(", "!", "(", "property", "instanceof", "Array", ")", ")", "{", "return", "false", "}", "}", "else", "if", "(", "deep", "&&", "(", "value", "instanceof", "Array", "||", "isPlainObject", "(", "value", ")", ")", ")", "{", "result", "=", "result", ".", "concat", "(", "pickToArray", "(", "value", ",", "property", ",", "deep", ")", ")", "}", "}", ")", "return", "result", "}", ",", "[", "]", ")", "}" ]

[ "Pick", "the", "value", "of", "the", "property", "property", "from", "each", "object", "in", "entities", ".", "Operation", "is", "recursive", "with", "deep", "==", "true", "." ]

[ "function", "loadFile", "(", "path", ")", "{", "if", "(", "config", ".", "asReference", "&&", "config", ".", "asReference", ".", "loadFile", ")", "{", "return", "config", ".", "asReference", ".", "loadFile", "(", "path", ")", ";", "}", "else", "if", "(", "typeof", "process", "!==", "\"undefined\"", "&&", "process", ".", "versions", "&&", "!", "!", "process", ".", "versions", ".", "node", "&&", "require", ".", "nodeRequire", ")", "{", "var", "fs", "=", "require", ".", "nodeRequire", "(", "'fs'", ")", ";", "var", "file", "=", "fs", ".", "readFileSync", "(", "path", ",", "'utf8'", ")", ";", "if", "(", "file", ".", "indexOf", "(", "'\\uFEFF'", ")", "===", "0", ")", "return", "file", ".", "substring", "(", "1", ")", ";", "return", "file", ";", "}", "else", "{", "var", "file", "=", "new", "java", ".", "io", ".", "File", "(", "path", ")", ",", "lineSeparator", "=", "java", ".", "lang", ".", "System", ".", "getProperty", "(", "\"line.separator\"", ")", ",", "input", "=", "new", "java", ".", "io", ".", "BufferedReader", "(", "new", "java", ".", "io", ".", "InputStreamReader", "(", "new", "java", ".", "io", ".", "FileInputStream", "(", "file", ")", ",", "'utf-8'", ")", ")", ",", "stringBuffer", ",", "line", ";", "try", "{", "stringBuffer", "=", "new", "java", ".", "lang", ".", "StringBuffer", "(", ")", ";", "line", "=", "input", ".", "readLine", "(", ")", ";", "if", "(", "line", "&&", "line", ".", "length", "(", ")", "&&", "line", ".", "charAt", "(", "0", ")", "===", "0xfeff", ")", "line", "=", "line", ".", "substring", "(", "1", ")", ";", "stringBuffer", ".", "append", "(", "line", ")", ";", "while", "(", "(", "line", "=", "input", ".", "readLine", "(", ")", ")", "!==", "null", ")", "{", "stringBuffer", ".", "append", "(", "lineSeparator", ")", ".", "append", "(", "line", ")", ";", "}", "return", "String", "(", "stringBuffer", ".", "toString", "(", ")", ")", ";", "}", "finally", "{", "input", ".", "close", "(", ")", ";", "}", "}", "}" ]

[ "load", "file", "code", "-", "stolen", "from", "text", "plugin" ]

[ "function", "escape", "(", "content", ")", "{", "return", "content", ".", "replace", "(", "/", "([\"'\\\\])", "/", "g", ",", "'\\\\$1'", ")", ".", "replace", "(", "/", "[\\f]", "/", "g", ",", "\"\\\\f\"", ")", ".", "replace", "(", "/", "[\\b]", "/", "g", ",", "\"\\\\b\"", ")", ".", "replace", "(", "/", "[\\n]", "/", "g", ",", "\"\\\\n\"", ")", ".", "replace", "(", "/", "[\\t]", "/", "g", ",", "\"\\\\t\"", ")", ".", "replace", "(", "/", "[\\r]", "/", "g", ",", "\"\\\\r\"", ")", ";", "}" ]

[ "when", "adding", "to", "the", "link", "buffer", "paths", "are", "normalised", "to", "the", "baseUrl", "when", "removing", "from", "the", "link", "buffer", "paths", "are", "normalised", "to", "the", "output", "file", "path" ]

[ "function", "areArgumentsValid", "(", "args", ")", "{", "var", "isValid", "=", "args", ".", "every", "(", "function", "(", "arg", ")", "{", "if", "(", "Array", ".", "isArray", "(", "arg", ")", ")", "{", "return", "areArgumentsValid", "(", "arg", ")", ";", "}", "return", "(", "arg", "!==", "null", "&&", "typeof", "arg", "===", "'object'", ")", ";", "}", ")", ";", "return", "isValid", ";", "}" ]

[ "Check", "if", "the", "passed", "arguments", "are", "valid", ".", "As", "long", "as", "arrays", "are", "encountered", "they", "are", "recursively", "checked", "." ]

[ "function", "mapStateToProps", "(", "state", ")", "{", "return", "{", "account", ":", "state", ".", "account", "?", "state", ".", "entities", ".", "accounts", "[", "state", ".", "account", ".", "id", "]", ":", "null", ",", "router", ":", "state", ".", "router", "}", "}" ]

[ "Place", "state", "of", "redux", "store", "into", "props", "of", "component" ]

[ "function", "(", ")", "{", "var", "clone", "=", "new", "CKEDITOR", ".", "dom", ".", "range", "(", "this", ".", "root", ")", ";", "clone", ".", "startContainer", "=", "this", ".", "startContainer", ";", "clone", ".", "startOffset", "=", "this", ".", "startOffset", ";", "clone", ".", "endContainer", "=", "this", ".", "endContainer", ";", "clone", ".", "endOffset", "=", "this", ".", "endOffset", ";", "clone", ".", "collapsed", "=", "this", ".", "collapsed", ";", "return", "clone", ";", "}" ]

[ "Clones", "this", "range", "." ]

[ "function", "getLengthOfPrecedingTextNodes", "(", "node", ")", "{", "var", "sum", "=", "0", ";", "while", "(", "(", "node", "=", "node", ".", "getPrevious", "(", ")", ")", "&&", "node", ".", "type", "==", "CKEDITOR", ".", "NODE_TEXT", ")", "sum", "+=", "node", ".", "getLength", "(", ")", ";", "return", "sum", ";", "}" ]

[ "Sums", "lengths", "of", "all", "preceding", "text", "nodes", "." ]

[ "function", "(", ")", "{", "var", "startNode", "=", "this", ".", "startContainer", ",", "endNode", "=", "this", ".", "endContainer", ",", "startOffset", "=", "this", ".", "startOffset", ",", "endOffset", "=", "this", ".", "endOffset", ",", "childCount", ";", "if", "(", "startNode", ".", "type", "==", "CKEDITOR", ".", "NODE_ELEMENT", ")", "{", "childCount", "=", "startNode", ".", "getChildCount", "(", ")", ";", "if", "(", "childCount", ">", "startOffset", ")", "startNode", "=", "startNode", ".", "getChild", "(", "startOffset", ")", ";", "else", "if", "(", "childCount", "<", "1", ")", "startNode", "=", "startNode", ".", "getPreviousSourceNode", "(", ")", ";", "else", "// startOffset > childCount but childCount is not 0", "{", "// Try to take the node just after the current position.", "startNode", "=", "startNode", ".", "$", ";", "while", "(", "startNode", ".", "lastChild", ")", "startNode", "=", "startNode", ".", "lastChild", ";", "startNode", "=", "new", "CKEDITOR", ".", "dom", ".", "node", "(", "startNode", ")", ";", "// Normally we should take the next node in DFS order. But it", "// is also possible that we've already reached the end of", "// document.", "startNode", "=", "startNode", ".", "getNextSourceNode", "(", ")", "||", "startNode", ";", "}", "}", "if", "(", "endNode", ".", "type", "==", "CKEDITOR", ".", "NODE_ELEMENT", ")", "{", "childCount", "=", "endNode", ".", "getChildCount", "(", ")", ";", "if", "(", "childCount", ">", "endOffset", ")", "endNode", "=", "endNode", ".", "getChild", "(", "endOffset", ")", ".", "getPreviousSourceNode", "(", "true", ")", ";", "else", "if", "(", "childCount", "<", "1", ")", "endNode", "=", "endNode", ".", "getPreviousSourceNode", "(", ")", ";", "else", "// endOffset > childCount but childCount is not 0", "{", "// Try to take the node just before the current position.", "endNode", "=", "endNode", ".", "$", ";", "while", "(", "endNode", ".", "lastChild", ")", "endNode", "=", "endNode", ".", "lastChild", ";", "endNode", "=", "new", "CKEDITOR", ".", "dom", ".", "node", "(", "endNode", ")", ";", "}", "}", "// Sometimes the endNode will come right before startNode for collapsed", "// ranges. Fix it. (#3780)", "if", "(", "startNode", ".", "getPosition", "(", "endNode", ")", "&", "CKEDITOR", ".", "POSITION_FOLLOWING", ")", "startNode", "=", "endNode", ";", "return", "{", "startNode", ":", "startNode", ",", "endNode", ":", "endNode", "}", ";", "}" ]

[ "Returns", "two", "nodes", "which", "are", "on", "the", "boundaries", "of", "this", "range", "." ]

[ "function", "(", "includeSelf", ",", "ignoreTextNode", ")", "{", "var", "start", "=", "this", ".", "startContainer", ",", "end", "=", "this", ".", "endContainer", ",", "ancestor", ";", "if", "(", "start", ".", "equals", "(", "end", ")", ")", "{", "if", "(", "includeSelf", "&&", "start", ".", "type", "==", "CKEDITOR", ".", "NODE_ELEMENT", "&&", "this", ".", "startOffset", "==", "this", ".", "endOffset", "-", "1", ")", "ancestor", "=", "start", ".", "getChild", "(", "this", ".", "startOffset", ")", ";", "else", "ancestor", "=", "start", ";", "}", "else", "{", "ancestor", "=", "start", ".", "getCommonAncestor", "(", "end", ")", ";", "}", "return", "ignoreTextNode", "&&", "!", "ancestor", ".", "is", "?", "ancestor", ".", "getParent", "(", ")", ":", "ancestor", ";", "}" ]

[ "Find", "the", "node", "which", "fully", "contains", "the", "range", "." ]

[ "function", "getValidEnlargeable", "(", "enlargeable", ")", "{", "return", "enlargeable", "&&", "enlargeable", ".", "type", "==", "CKEDITOR", ".", "NODE_ELEMENT", "&&", "enlargeable", ".", "hasAttribute", "(", "'contenteditable'", ")", "?", "null", ":", "enlargeable", ";", "}" ]

[ "Ensures", "that", "returned", "element", "can", "be", "enlarged", "by", "selection", "null", "otherwise", "." ]

[ "function", "(", "mode", ",", "selectContents", ",", "shrinkOnBlockBoundary", ")", "{", "// Unable to shrink a collapsed range.", "if", "(", "!", "this", ".", "collapsed", ")", "{", "mode", "=", "mode", "||", "CKEDITOR", ".", "SHRINK_TEXT", ";", "var", "walkerRange", "=", "this", ".", "clone", "(", ")", ";", "var", "startContainer", "=", "this", ".", "startContainer", ",", "endContainer", "=", "this", ".", "endContainer", ",", "startOffset", "=", "this", ".", "startOffset", ",", "endOffset", "=", "this", ".", "endOffset", ";", "// Whether the start/end boundary is moveable.", "var", "moveStart", "=", "1", ",", "moveEnd", "=", "1", ";", "if", "(", "startContainer", "&&", "startContainer", ".", "type", "==", "CKEDITOR", ".", "NODE_TEXT", ")", "{", "if", "(", "!", "startOffset", ")", "walkerRange", ".", "setStartBefore", "(", "startContainer", ")", ";", "else", "if", "(", "startOffset", ">=", "startContainer", ".", "getLength", "(", ")", ")", "walkerRange", ".", "setStartAfter", "(", "startContainer", ")", ";", "else", "{", "// Enlarge the range properly to avoid walker making", "// DOM changes caused by triming the text nodes later.", "walkerRange", ".", "setStartBefore", "(", "startContainer", ")", ";", "moveStart", "=", "0", ";", "}", "}", "if", "(", "endContainer", "&&", "endContainer", ".", "type", "==", "CKEDITOR", ".", "NODE_TEXT", ")", "{", "if", "(", "!", "endOffset", ")", "walkerRange", ".", "setEndBefore", "(", "endContainer", ")", ";", "else", "if", "(", "endOffset", ">=", "endContainer", ".", "getLength", "(", ")", ")", "walkerRange", ".", "setEndAfter", "(", "endContainer", ")", ";", "else", "{", "walkerRange", ".", "setEndAfter", "(", "endContainer", ")", ";", "moveEnd", "=", "0", ";", "}", "}", "var", "walker", "=", "new", "CKEDITOR", ".", "dom", ".", "walker", "(", "walkerRange", ")", ",", "isBookmark", "=", "CKEDITOR", ".", "dom", ".", "walker", ".", "bookmark", "(", ")", ";", "walker", ".", "evaluator", "=", "function", "(", "node", ")", "{", "return", "node", ".", "type", "==", "(", "mode", "==", "CKEDITOR", ".", "SHRINK_ELEMENT", "?", "CKEDITOR", ".", "NODE_ELEMENT", ":", "CKEDITOR", ".", "NODE_TEXT", ")", ";", "}", ";", "var", "currentElement", ";", "walker", ".", "guard", "=", "function", "(", "node", ",", "movingOut", ")", "{", "if", "(", "isBookmark", "(", "node", ")", ")", "return", "true", ";", "// Stop when we're shrink in element mode while encountering a text node.", "if", "(", "mode", "==", "CKEDITOR", ".", "SHRINK_ELEMENT", "&&", "node", ".", "type", "==", "CKEDITOR", ".", "NODE_TEXT", ")", "return", "false", ";", "// Stop when we've already walked \"through\" an element.", "if", "(", "movingOut", "&&", "node", ".", "equals", "(", "currentElement", ")", ")", "return", "false", ";", "if", "(", "shrinkOnBlockBoundary", "===", "false", "&&", "node", ".", "type", "==", "CKEDITOR", ".", "NODE_ELEMENT", "&&", "node", ".", "isBlockBoundary", "(", ")", ")", "return", "false", ";", "// Stop shrinking when encountering an editable border.", "if", "(", "node", ".", "type", "==", "CKEDITOR", ".", "NODE_ELEMENT", "&&", "node", ".", "hasAttribute", "(", "'contenteditable'", ")", ")", "return", "false", ";", "if", "(", "!", "movingOut", "&&", "node", ".", "type", "==", "CKEDITOR", ".", "NODE_ELEMENT", ")", "currentElement", "=", "node", ";", "return", "true", ";", "}", ";", "if", "(", "moveStart", ")", "{", "var", "textStart", "=", "walker", "[", "mode", "==", "CKEDITOR", ".", "SHRINK_ELEMENT", "?", "'lastForward'", ":", "'next'", "]", "(", ")", ";", "textStart", "&&", "this", ".", "setStartAt", "(", "textStart", ",", "selectContents", "?", "CKEDITOR", ".", "POSITION_AFTER_START", ":", "CKEDITOR", ".", "POSITION_BEFORE_START", ")", ";", "}", "if", "(", "moveEnd", ")", "{", "walker", ".", "reset", "(", ")", ";", "var", "textEnd", "=", "walker", "[", "mode", "==", "CKEDITOR", ".", "SHRINK_ELEMENT", "?", "'lastBackward'", ":", "'previous'", "]", "(", ")", ";", "textEnd", "&&", "this", ".", "setEndAt", "(", "textEnd", ",", "selectContents", "?", "CKEDITOR", ".", "POSITION_BEFORE_END", ":", "CKEDITOR", ".", "POSITION_AFTER_END", ")", ";", "}", "return", "!", "!", "(", "moveStart", "||", "moveEnd", ")", ";", "}", "}" ]

[ "Descrease", "the", "range", "to", "make", "sure", "that", "boundaries", "always", "anchor", "beside", "text", "nodes", "or", "innermost", "element", "." ]

[ "function", "(", "node", ")", "{", "this", ".", "optimizeBookmark", "(", ")", ";", "this", ".", "trim", "(", "false", ",", "true", ")", ";", "var", "startContainer", "=", "this", ".", "startContainer", ";", "var", "startOffset", "=", "this", ".", "startOffset", ";", "var", "nextNode", "=", "startContainer", ".", "getChild", "(", "startOffset", ")", ";", "if", "(", "nextNode", ")", "node", ".", "insertBefore", "(", "nextNode", ")", ";", "else", "startContainer", ".", "append", "(", "node", ")", ";", "// Check if we need to update the end boundary.", "if", "(", "node", ".", "getParent", "(", ")", "&&", "node", ".", "getParent", "(", ")", ".", "equals", "(", "this", ".", "endContainer", ")", ")", "this", ".", "endOffset", "++", ";", "// Expand the range to embrace the new node.", "this", ".", "setStartBefore", "(", "node", ")", ";", "}" ]

[ "Inserts", "a", "node", "at", "the", "start", "of", "the", "range", ".", "The", "range", "will", "be", "expanded", "the", "contain", "the", "node", "." ]

[ "function", "(", "range", ")", "{", "this", ".", "setStart", "(", "range", ".", "startContainer", ",", "range", ".", "startOffset", ")", ";", "this", ".", "setEnd", "(", "range", ".", "endContainer", ",", "range", ".", "endOffset", ")", ";", "}" ]

[ "Moves", "the", "range", "to", "the", "exact", "position", "of", "the", "specified", "range", "." ]

[ "function", "(", "startNode", ",", "startOffset", ")", "{", "// W3C requires a check for the new position. If it is after the end", "// boundary, the range should be collapsed to the new start. It seams", "// we will not need this check for our use of this class so we can", "// ignore it for now.", "// Fixing invalid range start inside dtd empty elements.", "if", "(", "startNode", ".", "type", "==", "CKEDITOR", ".", "NODE_ELEMENT", "&&", "CKEDITOR", ".", "dtd", ".", "$empty", "[", "startNode", ".", "getName", "(", ")", "]", ")", "startOffset", "=", "startNode", ".", "getIndex", "(", ")", ",", "startNode", "=", "startNode", ".", "getParent", "(", ")", ";", "this", ".", "startContainer", "=", "startNode", ";", "this", ".", "startOffset", "=", "startOffset", ";", "if", "(", "!", "this", ".", "endContainer", ")", "{", "this", ".", "endContainer", "=", "startNode", ";", "this", ".", "endOffset", "=", "startOffset", ";", "}", "updateCollapsed", "(", "this", ")", ";", "}" ]

[ "Sets", "the", "start", "position", "of", "a", "range", "." ]

[ "function", "(", "endNode", ",", "endOffset", ")", "{", "// W3C requires a check for the new position. If it is before the start", "// boundary, the range should be collapsed to the new end. It seams we", "// will not need this check for our use of this class so we can ignore", "// it for now.", "// Fixing invalid range end inside dtd empty elements.", "if", "(", "endNode", ".", "type", "==", "CKEDITOR", ".", "NODE_ELEMENT", "&&", "CKEDITOR", ".", "dtd", ".", "$empty", "[", "endNode", ".", "getName", "(", ")", "]", ")", "endOffset", "=", "endNode", ".", "getIndex", "(", ")", "+", "1", ",", "endNode", "=", "endNode", ".", "getParent", "(", ")", ";", "this", ".", "endContainer", "=", "endNode", ";", "this", ".", "endOffset", "=", "endOffset", ";", "if", "(", "!", "this", ".", "startContainer", ")", "{", "this", ".", "startContainer", "=", "endNode", ";", "this", ".", "startOffset", "=", "endOffset", ";", "}", "updateCollapsed", "(", "this", ")", ";", "}" ]

[ "Sets", "the", "end", "position", "of", "a", "Range", "." ]

[ "function", "(", "toSplit", ")", "{", "if", "(", "!", "this", ".", "collapsed", ")", "return", "null", ";", "// Extract the contents of the block from the selection point to the end", "// of its contents.", "this", ".", "setEndAt", "(", "toSplit", ",", "CKEDITOR", ".", "POSITION_BEFORE_END", ")", ";", "var", "documentFragment", "=", "this", ".", "extractContents", "(", ")", ";", "// Duplicate the element after it.", "var", "clone", "=", "toSplit", ".", "clone", "(", "false", ")", ";", "// Place the extracted contents into the duplicated element.", "documentFragment", ".", "appendTo", "(", "clone", ")", ";", "clone", ".", "insertAfter", "(", "toSplit", ")", ";", "this", ".", "moveToPosition", "(", "toSplit", ",", "CKEDITOR", ".", "POSITION_AFTER_END", ")", ";", "return", "clone", ";", "}" ]

[ "Branch", "the", "specified", "element", "from", "the", "collapsed", "range", "position", "and", "place", "the", "caret", "between", "the", "two", "result", "branches", "." ]

[ "function", "(", ")", "{", "var", "walkerRange", "=", "this", ".", "clone", "(", ")", ";", "// Optimize and analyze the range to avoid DOM destructive nature of walker. (#5780)", "walkerRange", ".", "optimize", "(", ")", ";", "if", "(", "walkerRange", ".", "startContainer", ".", "type", "!=", "CKEDITOR", ".", "NODE_ELEMENT", "||", "walkerRange", ".", "endContainer", ".", "type", "!=", "CKEDITOR", ".", "NODE_ELEMENT", ")", "return", "null", ";", "var", "walker", "=", "new", "CKEDITOR", ".", "dom", ".", "walker", "(", "walkerRange", ")", ",", "isNotBookmarks", "=", "CKEDITOR", ".", "dom", ".", "walker", ".", "bookmark", "(", "false", ",", "true", ")", ",", "isNotWhitespaces", "=", "CKEDITOR", ".", "dom", ".", "walker", ".", "whitespaces", "(", "true", ")", ";", "walker", ".", "evaluator", "=", "function", "(", "node", ")", "{", "return", "isNotWhitespaces", "(", "node", ")", "&&", "isNotBookmarks", "(", "node", ")", ";", "}", ";", "var", "node", "=", "walker", ".", "next", "(", ")", ";", "walker", ".", "reset", "(", ")", ";", "return", "node", "&&", "node", ".", "equals", "(", "walker", ".", "previous", "(", ")", ")", "?", "node", ":", "null", ";", "}" ]

[ "Get", "the", "single", "node", "enclosed", "within", "the", "range", "if", "there", "s", "one", "." ]

[ "function", "(", ")", "{", "// The reference element contains a zero-width space to avoid", "// a premature removal. The view is to be scrolled with respect", "// to this element.", "var", "reference", "=", "new", "CKEDITOR", ".", "dom", ".", "element", ".", "createFromHtml", "(", "'<span>&nbsp;</span>'", ",", "this", ".", "document", ")", ",", "afterCaretNode", ",", "startContainerText", ",", "isStartText", ";", "var", "range", "=", "this", ".", "clone", "(", ")", ";", "// Work with the range to obtain a proper caret position.", "range", ".", "optimize", "(", ")", ";", "// Currently in a text node, so we need to split it into two", "// halves and put the reference between.", "if", "(", "isStartText", "=", "range", ".", "startContainer", ".", "type", "==", "CKEDITOR", ".", "NODE_TEXT", ")", "{", "// Keep the original content. It will be restored.", "startContainerText", "=", "range", ".", "startContainer", ".", "getText", "(", ")", ";", "// Split the startContainer at the this position.", "afterCaretNode", "=", "range", ".", "startContainer", ".", "split", "(", "range", ".", "startOffset", ")", ";", "// Insert the reference between two text nodes.", "reference", ".", "insertAfter", "(", "range", ".", "startContainer", ")", ";", "}", "// If not in a text node, simply insert the reference into the range.", "else", "{", "range", ".", "insertNode", "(", "reference", ")", ";", "}", "// Scroll with respect to the reference element.", "reference", ".", "scrollIntoView", "(", ")", ";", "// Get rid of split parts if \"in a text node\" case.", "// Revert the original text of the startContainer.", "if", "(", "isStartText", ")", "{", "range", ".", "startContainer", ".", "setText", "(", "startContainerText", ")", ";", "afterCaretNode", ".", "remove", "(", ")", ";", "}", "// Get rid of the reference node. It is no longer necessary.", "reference", ".", "remove", "(", ")", ";", "}" ]

[ "Scrolls", "the", "start", "of", "current", "range", "into", "view", "." ]

[ "function", "shallowEquals", "(", "objA", ",", "objB", ")", "{", "var", "returnVal", "=", "false", ";", "if", "(", "objA", "===", "objB", "||", "objA", "===", "null", "&&", "objB", "===", "null", ")", "{", "returnVal", "=", "true", ";", "}", "if", "(", "!", "returnVal", ")", "{", "var", "propsEqual", "=", "true", ";", "if", "(", "Object", ".", "keys", "(", "objA", ")", ".", "length", "===", "Object", ".", "keys", "(", "objB", ")", ".", "length", ")", "{", "for", "(", "var", "key", "in", "objA", ")", "{", "propsEqual", "=", "propsEqual", "&&", "objA", "[", "key", "]", "===", "objB", "[", "key", "]", ";", "}", "returnVal", "=", "propsEqual", ";", "}", "}", "return", "returnVal", ";", "}" ]

[ "Utility", "function", "which", "evaluates", "if", "the", "two", "provided", "instances", "have", "all", "of", "the", "same", "properties", "as", "each", "other", "and", "if", "all", "of", "the", "properties", "on", "each", "other", "are", "equal", "." ]

[ "function", "checkCommentForSuppress", "(", "node", ")", "{", "// Skip if types aren't provided or the comment is empty.", "if", "(", "!", "node", "||", "!", "node", ".", "value", "||", "node", ".", "value", ".", "length", "===", "0", ")", "{", "return", ";", "}", "const", "match", "=", "node", ".", "value", ".", "match", "(", "/", "@suppress \\{(.*?)\\}", "/", ")", ";", "if", "(", "match", "&&", "match", ".", "length", "===", "2", ")", "{", "if", "(", "!", "blacklistedTypes", "||", "blacklistedTypes", ".", "length", "===", "0", ")", "{", "// Array is not present or empty, so block all types.", "context", ".", "report", "(", "node", ",", "'@suppress not allowed for any types'", ")", ";", "}", "else", "{", "// Report which matched types are blocked.", "const", "matched", "=", "[", "]", ";", "const", "types", "=", "match", "[", "1", "]", ".", "split", "(", "'|'", ")", ";", "types", ".", "forEach", "(", "function", "(", "type", ")", "{", "if", "(", "blacklistedTypes", ".", "indexOf", "(", "type", ")", "!==", "-", "1", "&&", "matched", ".", "indexOf", "(", "type", ")", "===", "-", "1", ")", "{", "matched", ".", "push", "(", "type", ")", ";", "}", "}", ")", ";", "if", "(", "matched", ".", "length", ">", "0", ")", "{", "const", "typeString", "=", "matched", ".", "join", "(", "', '", ")", ";", "context", ".", "report", "(", "node", ",", "`", "${", "typeString", "}", "`", ")", ";", "}", "}", "}", "}" ]

[ "Reports", "a", "given", "comment", "if", "it", "contains", "blocked", "suppress", "types", "." ]

[ "function", "toBoolFunction", "(", "selector", ",", "condition", ")", "{", "if", "(", "arguments", ".", "length", "==", "2", ")", "{", "selector", "=", "toBoolFunction", "(", "selector", ")", ";", "condition", "=", "toBoolFunction", "(", "condition", ")", ";", "return", "function", "(", ")", "{", "return", "condition", "(", "selector", ".", "apply", "(", "this", ",", "arguments", ")", ")", ";", "}", ";", "}", "else", "{", "condition", "=", "selector", ";", "}", "var", "alternate", "=", "false", ";", "try", "{", "switch", "(", "type", "(", "condition", ")", ")", "{", "case", "'regexp'", ":", "alternate", "=", "regexpToFunction", "(", "condition", ")", ";", "break", ";", "case", "'string'", ":", "alternate", "=", "stringToFunction", "(", "condition", ")", ";", "break", ";", "case", "'function'", ":", "alternate", "=", "condition", ";", "break", ";", "case", "'object'", ":", "alternate", "=", "objectToFunction", "(", "condition", ")", ";", "break", ";", "}", "}", "catch", "(", "ex", ")", "{", "//ignore things that aren't valid functions", "}", "return", "function", "(", "val", ")", "{", "return", "(", "val", "===", "condition", ")", "||", "(", "alternate", "&&", "alternate", ".", "apply", "(", "this", ",", "arguments", ")", ")", ";", "}", "}" ]

[ "Convert", "various", "possible", "things", "into", "a", "match", "function" ]

[ "function", "objectToFunction", "(", "obj", ")", "{", "var", "fns", "=", "Object", ".", "keys", "(", "obj", ")", ".", "map", "(", "function", "(", "key", ")", "{", "return", "toBoolFunction", "(", "key", ",", "obj", "[", "key", "]", ")", ";", "}", ")", ";", "return", "function", "(", "o", ")", "{", "for", "(", "var", "i", "=", "0", ";", "i", "<", "fns", ".", "length", ";", "i", "++", ")", "{", "if", "(", "!", "fns", "[", "i", "]", "(", "o", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "}" ]

[ "Convert", "obj", "into", "a", "match", "function", "." ]

[ "function", "stringToFunction", "(", "str", ")", "{", "// immediate such as \"> 20\"", "if", "(", "/", "^ *\\W+", "/", ".", "test", "(", "str", ")", ")", "return", "new", "Function", "(", "'_'", ",", "'return _ '", "+", "str", ")", ";", "// properties such as \"name.first\" or \"age > 18\"", "var", "fn", "=", "new", "Function", "(", "'_'", ",", "'return _.'", "+", "str", ")", ";", "return", "fn", "}" ]

[ "Convert", "property", "str", "to", "a", "function", "." ]

[ "function", "(", "apiKey", ",", "host", ",", "port", ",", "reqOpts", ")", "{", "var", "iod", "=", "this", "if", "(", "_", ".", "isObject", "(", "host", ")", ")", "{", "reqOpts", "=", "host", "host", "=", "null", "}", "else", "if", "(", "_", ".", "isObject", "(", "port", ")", ")", "{", "reqOpts", "=", "port", "port", "=", "null", "}", "if", "(", "!", "apiKey", ")", "throw", "Error", "(", "'IOD apiKey is missing!'", ")", "else", "if", "(", "host", "&&", "!", "url", ".", "parse", "(", "host", ",", "false", ",", "true", ")", ".", "protocol", ")", "{", "throw", "Error", "(", "'Protocol not found on host: '", "+", "host", ")", "}", "var", "httpHost", "=", "'http://api.idolondemand.com'", "var", "httpsHost", "=", "'https://api.idolondemand.com'", "var", "httpPort", "=", "80", "var", "httpsPort", "=", "443", "// If Https port point to Https host and vice versa", "if", "(", "host", "==", "null", "&&", "port", "===", "httpsPort", ")", "host", "=", "httpsHost", "else", "if", "(", "host", "==", "null", "&&", "port", "===", "httpPort", ")", "host", "=", "httpHost", "else", "if", "(", "port", "==", "null", "&&", "host", "&&", "host", ".", "toLowerCase", "(", ")", "===", "httpsHost", ")", "port", "=", "httpsPort", "else", "if", "(", "port", "==", "null", "&&", "host", "&&", "host", ".", "toLowerCase", "(", ")", "===", "httpHost", ")", "port", "=", "httpPort", "iod", ".", "apiKey", "=", "apiKey", "iod", ".", "host", "=", "host", "||", "httpsHost", "iod", ".", "port", "=", "port", "||", "httpsPort", "iod", ".", "reqOpts", "=", "_", ".", "defaults", "(", "reqOpts", "||", "{", "}", ",", "{", "timeout", ":", "300000", "}", ")", "iod", ".", "ACTIONS", "=", "_", ".", "cloneDeep", "(", "CONSTANTS", ".", "ACTIONS", ")", "iod", ".", "eventEmitter", "=", "eventEmitter", "SchemaU", ".", "initSchemas", "(", "iod", ")", "_", ".", "bindAll", ".", "apply", "(", "_", ",", "[", "iod", "]", ".", "concat", "(", "_", ".", "functions", "(", "IOD", ".", "prototype", ")", ")", ")", "}" ]

[ "Creates", "a", "IOD", "object", "with", "specified", "apiKey", "host", "and", "port", "." ]

[ "function", "insert_token", "(", "item", ")", "{", "var", "$this_token", "=", "$", "(", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "tokenFormatter", "(", "item", ")", ")", ";", "var", "readonly", "=", "item", ".", "readonly", "===", "true", "?", "true", ":", "false", ";", "if", "(", "readonly", ")", "$this_token", ".", "addClass", "(", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "classes", ".", "tokenReadOnly", ")", ";", "$this_token", ".", "addClass", "(", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "classes", ".", "token", ")", ".", "insertBefore", "(", "input_token", ")", ";", "// The 'delete token' button", "if", "(", "!", "readonly", ")", "{", "$", "(", "\"<span>\"", "+", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "deleteText", "+", "\"</span>\"", ")", ".", "addClass", "(", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "classes", ".", "tokenDelete", ")", ".", "appendTo", "(", "$this_token", ")", ".", "click", "(", "function", "(", ")", "{", "if", "(", "!", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "disabled", ")", "{", "delete_token", "(", "$", "(", "this", ")", ".", "parent", "(", ")", ")", ";", "hidden_input", ".", "change", "(", ")", ";", "return", "false", ";", "}", "}", ")", ";", "}", "// Store data on the token", "var", "token_data", "=", "item", ";", "$", ".", "data", "(", "$this_token", ".", "get", "(", "0", ")", ",", "\"tokeninput\"", ",", "item", ")", ";", "// Save this token for duplicate checking", "saved_tokens", "=", "saved_tokens", ".", "slice", "(", "0", ",", "selected_token_index", ")", ".", "concat", "(", "[", "token_data", "]", ")", ".", "concat", "(", "saved_tokens", ".", "slice", "(", "selected_token_index", ")", ")", ";", "selected_token_index", "++", ";", "// Update the hidden input", "update_hidden_input", "(", "saved_tokens", ",", "hidden_input", ")", ";", "token_count", "+=", "1", ";", "// Check the token limit", "if", "(", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "tokenLimit", "!==", "null", "&&", "token_count", ">=", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "tokenLimit", ")", "{", "input_box", ".", "hide", "(", ")", ";", "hide_dropdown", "(", ")", ";", "}", "return", "$this_token", ";", "}" ]

[ "Inner", "function", "to", "a", "token", "to", "the", "list" ]

[ "function", "add_token", "(", "item", ")", "{", "var", "callback", "=", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "onAdd", ";", "// See if the token already exists and select it if we don't want duplicates", "if", "(", "token_count", ">", "0", "&&", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "preventDuplicates", ")", "{", "var", "found_existing_token", "=", "null", ";", "token_list", ".", "children", "(", ")", ".", "each", "(", "function", "(", ")", "{", "var", "existing_token", "=", "$", "(", "this", ")", ";", "var", "existing_data", "=", "$", ".", "data", "(", "existing_token", ".", "get", "(", "0", ")", ",", "\"tokeninput\"", ")", ";", "if", "(", "existing_data", "&&", "existing_data", "[", "settings", ".", "tokenValue", "]", "===", "item", "[", "settings", ".", "tokenValue", "]", ")", "{", "found_existing_token", "=", "existing_token", ";", "return", "false", ";", "}", "}", ")", ";", "if", "(", "found_existing_token", ")", "{", "select_token", "(", "found_existing_token", ")", ";", "input_token", ".", "insertAfter", "(", "found_existing_token", ")", ";", "focus_with_timeout", "(", "input_box", ")", ";", "return", ";", "}", "}", "// Squeeze input_box so we force no unnecessary line break", "input_box", ".", "width", "(", "1", ")", ";", "// Insert the new tokens", "if", "(", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "tokenLimit", "==", "null", "||", "token_count", "<", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "tokenLimit", ")", "{", "insert_token", "(", "item", ")", ";", "// Remove the placeholder so it's not seen after you've added a token", "input_box", ".", "attr", "(", "\"placeholder\"", ",", "null", ")", "checkTokenLimit", "(", ")", ";", "}", "// Clear input box", "input_box", ".", "val", "(", "\"\"", ")", ";", "// Don't show the help dropdown, they've got the idea", "hide_dropdown", "(", ")", ";", "// Execute the onAdd callback if defined", "if", "(", "$", ".", "isFunction", "(", "callback", ")", ")", "{", "callback", ".", "call", "(", "hidden_input", ",", "item", ")", ";", "}", "}" ]

[ "Add", "a", "token", "to", "the", "token", "list", "based", "on", "user", "input" ]

[ "function", "select_token", "(", "token", ")", "{", "if", "(", "!", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "disabled", ")", "{", "token", ".", "addClass", "(", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "classes", ".", "selectedToken", ")", ";", "selected_token", "=", "token", ".", "get", "(", "0", ")", ";", "// Hide input box", "input_box", ".", "val", "(", "\"\"", ")", ";", "// Hide dropdown if it is visible (eg if we clicked to select token)", "hide_dropdown", "(", ")", ";", "}", "}" ]

[ "Select", "a", "token", "in", "the", "token", "list" ]

[ "function", "deselect_token", "(", "token", ",", "position", ")", "{", "token", ".", "removeClass", "(", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "classes", ".", "selectedToken", ")", ";", "selected_token", "=", "null", ";", "if", "(", "position", "===", "POSITION", ".", "BEFORE", ")", "{", "input_token", ".", "insertBefore", "(", "token", ")", ";", "selected_token_index", "--", ";", "}", "else", "if", "(", "position", "===", "POSITION", ".", "AFTER", ")", "{", "input_token", ".", "insertAfter", "(", "token", ")", ";", "selected_token_index", "++", ";", "}", "else", "{", "input_token", ".", "appendTo", "(", "token_list", ")", ";", "selected_token_index", "=", "token_count", ";", "}", "// Show the input box and give it focus again", "focus_with_timeout", "(", "input_box", ")", ";", "}" ]

[ "Deselect", "a", "token", "in", "the", "token", "list" ]

[ "function", "toggle_select_token", "(", "token", ")", "{", "var", "previous_selected_token", "=", "selected_token", ";", "if", "(", "selected_token", ")", "{", "deselect_token", "(", "$", "(", "selected_token", ")", ",", "POSITION", ".", "END", ")", ";", "}", "if", "(", "previous_selected_token", "===", "token", ".", "get", "(", "0", ")", ")", "{", "deselect_token", "(", "token", ",", "POSITION", ".", "END", ")", ";", "}", "else", "{", "select_token", "(", "token", ")", ";", "}", "}" ]

[ "Toggle", "selection", "of", "a", "token", "in", "the", "token", "list" ]

[ "function", "delete_token", "(", "token", ")", "{", "// Remove the id from the saved list", "var", "token_data", "=", "$", ".", "data", "(", "token", ".", "get", "(", "0", ")", ",", "\"tokeninput\"", ")", ";", "var", "callback", "=", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "onDelete", ";", "var", "index", "=", "token", ".", "prevAll", "(", ")", ".", "length", ";", "if", "(", "index", ">", "selected_token_index", ")", "index", "--", ";", "// Delete the token", "token", ".", "remove", "(", ")", ";", "selected_token", "=", "null", ";", "// Show the input box and give it focus again", "focus_with_timeout", "(", "input_box", ")", ";", "// Remove this token from the saved list", "saved_tokens", "=", "saved_tokens", ".", "slice", "(", "0", ",", "index", ")", ".", "concat", "(", "saved_tokens", ".", "slice", "(", "index", "+", "1", ")", ")", ";", "if", "(", "saved_tokens", ".", "length", "==", "0", ")", "{", "input_box", ".", "attr", "(", "\"placeholder\"", ",", "settings", ".", "placeholder", ")", "}", "if", "(", "index", "<", "selected_token_index", ")", "selected_token_index", "--", ";", "// Update the hidden input", "update_hidden_input", "(", "saved_tokens", ",", "hidden_input", ")", ";", "token_count", "-=", "1", ";", "if", "(", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "tokenLimit", "!==", "null", ")", "{", "input_box", ".", "show", "(", ")", ".", "val", "(", "\"\"", ")", ";", "focus_with_timeout", "(", "input_box", ")", ";", "}", "// Execute the onDelete callback if defined", "if", "(", "$", ".", "isFunction", "(", "callback", ")", ")", "{", "callback", ".", "call", "(", "hidden_input", ",", "token_data", ")", ";", "}", "}" ]

[ "Delete", "a", "token", "from", "the", "token", "list" ]

[ "function", "update_hidden_input", "(", "saved_tokens", ",", "hidden_input", ")", "{", "var", "token_values", "=", "$", ".", "map", "(", "saved_tokens", ",", "function", "(", "el", ")", "{", "if", "(", "typeof", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "tokenValue", "==", "'function'", ")", "return", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "tokenValue", ".", "call", "(", "this", ",", "el", ")", ";", "return", "el", "[", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "tokenValue", "]", ";", "}", ")", ";", "hidden_input", ".", "val", "(", "token_values", ".", "join", "(", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "tokenDelimiter", ")", ")", ";", "}" ]

[ "Update", "the", "hidden", "input", "box", "value" ]

[ "function", "highlight_term", "(", "value", ",", "term", ")", "{", "return", "value", ".", "replace", "(", "new", "RegExp", "(", "\"(?![^&;]+;)(?!<[^<>]*)(\"", "+", "regexp_escape", "(", "term", ")", "+", "\")(?![^<>]*>)(?![^&;]+;)\"", ",", "\"gi\"", ")", ",", "function", "(", "match", ",", "p1", ")", "{", "return", "\"<b>\"", "+", "escapeHTML", "(", "p1", ")", "+", "\"</b>\"", ";", "}", ")", ";", "}" ]

[ "Highlight", "the", "query", "part", "of", "the", "search", "term" ]

[ "function", "excludeCurrent", "(", "results", ")", "{", "if", "(", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "excludeCurrent", ")", "{", "var", "currentTokens", "=", "$", "(", "input", ")", ".", "data", "(", "\"tokenInputObject\"", ")", ".", "getTokens", "(", ")", ",", "trimmedList", "=", "[", "]", ";", "if", "(", "currentTokens", ".", "length", ")", "{", "$", ".", "each", "(", "results", ",", "function", "(", "index", ",", "value", ")", "{", "var", "notFound", "=", "true", ";", "$", ".", "each", "(", "currentTokens", ",", "function", "(", "cIndex", ",", "cValue", ")", "{", "if", "(", "value", "[", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "propertyToSearch", "]", "==", "cValue", "[", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "propertyToSearch", "]", ")", "{", "notFound", "=", "false", ";", "return", "false", ";", "}", "}", ")", ";", "if", "(", "notFound", ")", "{", "trimmedList", ".", "push", "(", "value", ")", ";", "}", "}", ")", ";", "results", "=", "trimmedList", ";", "}", "}", "return", "results", ";", "}" ]

[ "exclude", "existing", "tokens", "from", "dropdown", "so", "the", "list", "is", "clearer" ]

[ "function", "populate_dropdown", "(", "query", ",", "results", ")", "{", "// exclude current tokens if configured", "results", "=", "excludeCurrent", "(", "results", ")", ";", "if", "(", "results", "&&", "results", ".", "length", ")", "{", "dropdown", ".", "empty", "(", ")", ";", "var", "dropdown_ul", "=", "$", "(", "\"<ul/>\"", ")", ".", "appendTo", "(", "dropdown", ")", ".", "mouseover", "(", "function", "(", "event", ")", "{", "select_dropdown_item", "(", "$", "(", "event", ".", "target", ")", ".", "closest", "(", "\"li\"", ")", ")", ";", "}", ")", ".", "mousedown", "(", "function", "(", "event", ")", "{", "add_token", "(", "$", "(", "event", ".", "target", ")", ".", "closest", "(", "\"li\"", ")", ".", "data", "(", "\"tokeninput\"", ")", ")", ";", "hidden_input", ".", "change", "(", ")", ";", "return", "false", ";", "}", ")", ".", "hide", "(", ")", ";", "if", "(", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "resultsLimit", "&&", "results", ".", "length", ">", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "resultsLimit", ")", "{", "results", "=", "results", ".", "slice", "(", "0", ",", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "resultsLimit", ")", ";", "}", "$", ".", "each", "(", "results", ",", "function", "(", "index", ",", "value", ")", "{", "var", "this_li", "=", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "resultsFormatter", "(", "value", ")", ";", "this_li", "=", "find_value_and_highlight_term", "(", "this_li", ",", "value", "[", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "propertyToSearch", "]", ",", "query", ")", ";", "this_li", "=", "$", "(", "this_li", ")", ".", "appendTo", "(", "dropdown_ul", ")", ";", "if", "(", "index", "%", "2", ")", "{", "this_li", ".", "addClass", "(", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "classes", ".", "dropdownItem", ")", ";", "}", "else", "{", "this_li", ".", "addClass", "(", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "classes", ".", "dropdownItem2", ")", ";", "}", "if", "(", "index", "===", "0", "&&", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "autoSelectFirstResult", ")", "{", "select_dropdown_item", "(", "this_li", ")", ";", "}", "$", ".", "data", "(", "this_li", ".", "get", "(", "0", ")", ",", "\"tokeninput\"", ",", "value", ")", ";", "}", ")", ";", "show_dropdown", "(", ")", ";", "if", "(", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "animateDropdown", ")", "{", "dropdown_ul", ".", "slideDown", "(", "\"fast\"", ")", ";", "}", "else", "{", "dropdown_ul", ".", "show", "(", ")", ";", "}", "}", "else", "{", "if", "(", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "noResultsText", ")", "{", "dropdown", ".", "html", "(", "\"<p>\"", "+", "escapeHTML", "(", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "noResultsText", ")", "+", "\"</p>\"", ")", ";", "show_dropdown", "(", ")", ";", "}", "}", "}" ]

[ "Populate", "the", "results", "dropdown", "with", "some", "results" ]

[ "function", "select_dropdown_item", "(", "item", ")", "{", "if", "(", "item", ")", "{", "if", "(", "selected_dropdown_item", ")", "{", "deselect_dropdown_item", "(", "$", "(", "selected_dropdown_item", ")", ")", ";", "}", "item", ".", "addClass", "(", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "classes", ".", "selectedDropdownItem", ")", ";", "selected_dropdown_item", "=", "item", ".", "get", "(", "0", ")", ";", "}", "}" ]

[ "Highlight", "an", "item", "in", "the", "results", "dropdown" ]

[ "function", "deselect_dropdown_item", "(", "item", ")", "{", "item", ".", "removeClass", "(", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "classes", ".", "selectedDropdownItem", ")", ";", "selected_dropdown_item", "=", "null", ";", "}" ]

[ "Remove", "highlighting", "from", "an", "item", "in", "the", "results", "dropdown" ]

[ "function", "computeURL", "(", ")", "{", "var", "url", "=", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "url", ";", "if", "(", "typeof", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "url", "==", "'function'", ")", "{", "url", "=", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ".", "url", ".", "call", "(", "$", "(", "input", ")", ".", "data", "(", "\"settings\"", ")", ")", ";", "}", "return", "url", ";", "}" ]

[ "compute", "the", "dynamic", "URL" ]

[ "function", "_matchAllFields", "(", "fields", ",", "matchAnyRegex", ")", "{", "var", "regExp", "=", "regExps", "?", "matchAnyRegex", "?", "regExps", ".", "any", ":", "regExps", ".", "all", ":", "null", ";", "if", "(", "regExp", ")", "{", "for", "(", "var", "i", "=", "0", ";", "i", "<", "fields", ".", "length", ";", "++", "i", ")", "{", "parentBuilder", ".", "field", "(", "fields", "[", "i", "]", ")", ".", "is", "(", "\"$regex\"", ",", "regExp", ")", ";", "}", "}", "return", "parentBuilder", ";", "}" ]

[ "Matches", "the", "given", "Regular", "expression", "with", "all", "the", "fields", "." ]

[ "function", "_matchAnyField", "(", "fields", ",", "matchAnyRegex", ")", "{", "var", "regExp", "=", "regExps", "?", "matchAnyRegex", "?", "regExps", ".", "any", ":", "regExps", ".", "all", ":", "null", ";", "if", "(", "regExp", ")", "{", "var", "orBuilder", "=", "parentBuilder", ".", "either", "(", ")", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "fields", ".", "length", ";", "++", "i", ")", "{", "orBuilder", "=", "orBuilder", ".", "or", "(", ")", ".", "field", "(", "fields", "[", "i", "]", ")", ".", "is", "(", "\"$regex\"", ",", "regExp", ")", ";", "}", "}", "return", "parentBuilder", ";", "}" ]

[ "Matches", "the", "given", "Regular", "expression", "with", "at", "least", "one", "of", "the", "fields", "." ]

[ "function", "(", "parentBuilder", ",", "field", ")", "{", "if", "(", "!", "dataUtils", ".", "isValidStr", "(", "field", ")", ")", "throw", "\"Invalid field, should be a string: \"", "+", "dataUtils", ".", "JSONstringify", "(", "field", ")", ";", "/**\n * Ensures a comparison of the field with the value.\n * @param {string} comparator e.g. \"$gt\", \"$gte\", etc.\n * @param {*} value\n * @returns {QueryBuilder} the parent Builder. Use .andField()\n * to chain further with this builder.\n */", "this", ".", "is", "=", "function", "(", "comparator", ",", "value", ")", "{", "return", "parentBuilder", ".", "_compare", "(", "field", ",", "comparator", ",", "value", ")", ";", "}", ";", "/**\n * Ensures that the field matches the given value. This is same\n * as calling matchAll([value]).\n * @param {*} value\n * @returns {QueryBuilder} the parent Builder. Use .andField()\n * to chain further with this builder.\n */", "this", ".", "matches", "=", "function", "(", "value", ")", "{", "return", "parentBuilder", ".", "_matchesAll", "(", "field", ",", "[", "value", "]", ")", ";", "}", ";", "/**\n * Ensures that the field matches all the values.\n * @param {Array.<*>} values\n * @returns {QueryBuilder} the parent Builder. Use .andField()\n * to chain further with this builder.\n */", "this", ".", "matchesAll", "=", "function", "(", "values", ")", "{", "return", "parentBuilder", ".", "_matchesAll", "(", "field", ",", "values", ")", ";", "}", ";", "/**\n * Ensures that the field matches at least one of the values.\n * @param {Array.<*>} values\n * @param {boolean} [addToExistingOr=false] If true, this will\n * be added to the existing OR list ($in), if any.\n * @returns {QueryBuilder} the parent Builder. Use .andField()\n * to chain further with this builder.\n */", "this", ".", "matchesAny", "=", "function", "(", "values", ",", "addToExistingOr", ")", "{", "return", "parentBuilder", ".", "_matchesAny", "(", "field", ",", "values", ",", "addToExistingOr", ")", ";", "}", ";", "}" ]

[ "This", "builder", "helps", "create", "efficient", "queries", "and", "expressions", "for", "document", "fields", "." ]

[ "function", "(", ")", "{", "var", "_orBuilder", "=", "this", ";", "var", "_queries", "=", "[", "]", ";", "var", "_currentChildBuilder", "=", "new", "ChildQueryBuilder", "(", "_orBuilder", ")", ";", "/**\n * Process the current OR entry, and continue adding to this OR\n * query group.\n * @returns {ChildQueryBuilder} A new {@link ChildQueryBuilder}\n * child in this OR group.\n */", "this", ".", "or", "=", "function", "(", ")", "{", "_orBuilder", ".", "flush", "(", ")", ";", "return", "_currentChildBuilder", ";", "}", ";", "/**\n * Returns the array of query objects generated by this\n * builder.\n * @returns {Array.<{}>} the array of query objects generated\n * by this builder.\n */", "this", ".", "flush", "=", "function", "(", ")", "{", "// save current builder", "var", "q", "=", "_currentChildBuilder", ".", "build", "(", ")", ";", "// only if the query is non-empty", "if", "(", "Object", ".", "keys", "(", "q", ")", ".", "length", ")", "{", "if", "(", "!", "dataUtils", ".", "arrayContainsValue", "(", "_queries", ",", "q", ")", ")", "_queries", ".", "push", "(", "q", ")", ";", "// renew current builder", "_currentChildBuilder", "=", "new", "ChildQueryBuilder", "(", "_orBuilder", ")", ";", "}", "return", "_queries", ";", "}", ";", "}" ]

[ "This", "builder", "helps", "create", "efficient", "OR", "queries", "and", "expressions", "." ]

[ "function", "init", "(", "configuration", ")", "{", "var", "self", "=", "{", "config", ":", "configuration", ",", "adapters", ":", "[", "]", ",", "getWhenCurrentWritesDone", ":", "getWhenCurrentWritesDone", "}", ";", "_", ".", "each", "(", "self", ".", "config", ".", "adapters", ",", "function", "(", "adapter", ")", "{", "var", "adapterInstance", ";", "try", "{", "adapterInstance", "=", "require", "(", "'./adapters/'", "+", "adapter", ".", "type", ")", ".", "init", "(", "adapter", ")", ";", "}", "catch", "(", "e", ")", "{", "console", ".", "log", "(", "chalk", ".", "red", "(", "'Initialization Error: '", ")", ",", "e", ")", ";", "throw", "e", ";", "}", "adapterInstance", ".", "writeQueue", "=", "BB", ".", "resolve", "(", ")", ";", "self", ".", "adapters", ".", "push", "(", "adapterInstance", ")", ";", "}", ")", ";", "[", "'error'", ",", "'info'", ",", "'debug'", ",", "'warn'", ",", "'trace'", ",", "'critical'", "]", ".", "forEach", "(", "function", "(", "type", ")", "{", "/**\n * Create a TYPE log entry\n * @param category Categorize your error with a user defined label\n * @param args Include your customized messages. This should be a comma separated list just like `console.log`\n */", "self", "[", "type", "]", "=", "function", "(", ")", "{", "// If we are still logging and there are messages to write", "if", "(", "arguments", ".", "length", ">", "0", ")", "{", "var", "category", "=", "(", "arguments", ".", "length", ">", "1", "&&", "_", ".", "isString", "(", "arguments", "[", "0", "]", ")", ")", "?", "arguments", "[", "0", "]", ":", "''", ",", "startIdx", "=", "(", "arguments", ".", "length", ">", "1", ")", "?", "1", ":", "0", ";", "_write", ".", "call", "(", "self", ",", "type", ",", "category", ",", "Array", ".", "prototype", ".", "slice", ".", "call", "(", "arguments", ",", "startIdx", ")", ")", ";", "}", "}", ";", "}", ")", ";", "return", "self", ";", "}" ]

[ "Public", "method", "required", "to", "load", "in", "all", "of", "the", "configuration", "info", "for", "adapters", ".", "Init", "initialize", "and", "reinitializes", "so", "the", "list", "of", "adapters", "is", "set", "to", "empty", "before", "it", "runs", "." ]

[ "function", "initWithFile", "(", "configPath", ")", "{", "var", "configString", "=", "fs", ".", "readFileSync", "(", "path", ".", "resolve", "(", "configPath", ")", ")", ";", "this", ".", "config", "=", "JSON", ".", "parse", "(", "configString", ")", ";", "this", ".", "init", "(", "this", ".", "config", ")", ";", "return", "this", ";", "}" ]

[ "Method", "that", "will", "load", "configuration", "info", "for", "your", "adapters", "from", "a", "file", ".", "Method", "that", "will", "load", "configuration", "info", "for", "your", "adapters", "from", "a", "file", "." ]

[ "function", "_write", "(", "type", ",", "category", ",", "message", ")", "{", "var", "config", "=", "this", ".", "config", ";", "this", ".", "adapters", ".", "forEach", "(", "function", "(", "adapter", ")", "{", "//Check configuration to see if we should continue.", "if", "(", "adapter", ".", "config", ".", "filter", "&&", "(", "adapter", ".", "config", ".", "filter", ".", "indexOf", "(", "type", ")", ">", "-", "1", ")", ")", "{", "return", ";", "}", "//We are not filtering this out. Continue", "adapter", ".", "write", "(", "type", ",", "category", ",", "message", ")", ";", "}", ")", ";", "}" ]

[ "Local", "method", "to", "load", "up", "a", "write", "job", ".", "We", "create", "a", "tracker", "so", "that", "the", "async", "callbacks", "stay", "in", "order", "and", "then", "we", "kick", "off", "the", "adapterWrite", "method", "which", "recursively", "loads", "the", "adapters", "and", "write", "per", "their", "write", "method", ".", "It", "will", "also", "load", "in", "the", "configuration", "for", "the", "adapter", "each", "time", "so", "you", "can", "have", "the", "same", "type", "of", "adapters", "with", "different", "settings", "." ]

[ "function", "clone", "(", "args", ",", "baseDir", ",", "privKey", ",", "cb", ")", "{", "run", "(", "baseDir", ",", "privKey", ",", "\"git clone \"", "+", "args", ",", "cb", ")", "}" ]

[ "convenience", "wrapper", "for", "clone", ".", "maybe", "add", "more", "later", "." ]

[ "function", "(", "spec", ")", "{", "spec", ".", "addMatchers", "(", "{", "/**\n * Array contains all elements of another array\n * @param needles another array\n * @returns {Boolean} true/false\n */", "toContainAll", ":", "function", "(", "needles", ")", "{", "var", "haystack", "=", "this", ".", "actual", ";", "return", "needles", ".", "every", "(", "function", "(", "elem", ")", "{", "return", "haystack", ".", "some", "(", "function", "(", "sackElem", ")", "{", "return", "spec", ".", "env", ".", "equals_", "(", "elem", ",", "sackElem", ")", ";", "}", ")", ";", "}", ")", ";", "}", "}", ")", ";", "}" ]

[ "call", "this", "in", "beforeEach", "method", "to", "add", "more", "available", "matchers" ]

[ "function", "(", "data", ")", "{", "var", "filePath", "=", "data", ".", "filePath", ";", "var", "noExtensionFilePath", "=", "data", ".", "noExtensionFilePath", ";", "var", "fileName", "=", "data", ".", "fileName", ";", "var", "noExtensionFileName", "=", "data", ".", "noExtensionFileName", ";", "return", "[", "\"describe('\"", "+", "noExtensionFilePath", "+", "\"', function() {\"", ",", "\"});\"", ",", "]", ".", "join", "(", "'\\n'", ")", ";", "}" ]

[ "get", "test", "code", "template" ]

[ "function", "extract", "(", "query", ")", "{", "var", "toSplice", "=", "[", "]", "var", "extracted", "=", "[", "]", "return", "function", "(", "prev", ",", "curr", ",", "index", ",", "array", ")", "{", "if", "(", "prev", "!==", "extracted", ")", "{", "if", "(", "testValue", "(", "prev", ",", "query", ")", ")", "{", "extracted", ".", "push", "(", "prev", ")", "toSplice", ".", "push", "(", "index", "-", "1", ")", "}", "}", "if", "(", "testValue", "(", "curr", ",", "query", ")", ")", "{", "extracted", ".", "push", "(", "curr", ")", "toSplice", ".", "push", "(", "index", ")", "}", "if", "(", "index", "===", "array", ".", "length", "-", "1", ")", "{", "toSplice", ".", "reverse", "(", ")", "for", "(", "var", "i", "=", "0", ";", "i", "<", "toSplice", ".", "length", ";", "i", "++", ")", "{", "array", ".", "splice", "(", "toSplice", "[", "i", "]", ",", "1", ")", "}", "}", "return", "extracted", "}", "}" ]

[ "Removes", "items", "from", "array", "which", "satisfy", "the", "query", ".", "Modifies", "the", "input", "array", "returns", "the", "extracted", "." ]

[ "function", "getNewRouteInfo", "(", "that", ",", "newRoutePath", ",", "path", ",", "pathToEmit", ")", "{", "var", "indexes", "=", "getDivergenceIndexes", "(", "that", ".", "currentPath", ",", "path", ",", "newRoutePath", ")", "if", "(", "indexes", "===", "undefined", ")", "{", "return", "undefined", "}", "var", "routeDivergenceIndex", "=", "indexes", ".", "routeIndex", "var", "pathDivergenceIndex", "=", "indexes", ".", "pathIndex", "var", "lastRoute", "=", "newRoutePath", "[", "routeDivergenceIndex", "-", "1", "]", ".", "route", "var", "newPathSegment", "=", "path", ".", "slice", "(", "pathDivergenceIndex", ")", "// routing", "var", "newRoutes", "=", "traverseRoute", "(", "that", ",", "lastRoute", ",", "newPathSegment", ",", "pathDivergenceIndex", ")", "if", "(", "newRoutes", "===", "undefined", ")", "{", "var", "pathAdditions", "=", "[", "]", "for", "(", "var", "n", "=", "routeDivergenceIndex", "-", "1", ";", "n", ">=", "0", ";", "n", "--", ")", "{", "// go in reverse and take the closest default handler", "if", "(", "that", ".", "currentRoutes", "[", "n", "]", ".", "route", ".", "defaultHandler", "!==", "undefined", ")", "{", "var", "defaultHandler", "=", "that", ".", "currentRoutes", "[", "n", "]", ".", "route", ".", "defaultHandler", "break", ";", "}", "else", "{", "pathAdditions", "=", "that", ".", "currentRoutes", "[", "n", "]", ".", "route", ".", "pathSegment", ".", "concat", "(", "pathAdditions", ")", "}", "}", "if", "(", "defaultHandler", "!==", "undefined", ")", "{", "var", "handlerParameters", "=", "[", "getPathSegementToOutput", "(", "that", ".", "transform", ",", "pathAdditions", ".", "concat", "(", "newPathSegment", ")", ")", "]", "var", "subroute", "=", "new", "Route", "(", "newPathSegment", ",", "that", ".", "transform", ",", "true", ")", "defaultHandler", ".", "apply", "(", "subroute", ",", "handlerParameters", ")", "var", "pathIndexEnd", "=", "pathDivergenceIndex", "+", "newPathSegment", ".", "length", "if", "(", "newPathSegment", ".", "length", "!==", "0", ")", "{", "pathIndexEnd", "--", "}", "newRoutes", "=", "[", "{", "route", ":", "subroute", ",", "pathIndexes", ":", "{", "start", ":", "pathDivergenceIndex", ",", "end", ":", "pathIndexEnd", "}", "}", "]", "}", "else", "{", "throw", "new", "Error", "(", "\"No route matched path: \"", "+", "JSON", ".", "stringify", "(", "getPathToOutput", "(", "that", ".", "transform", ",", "path", ")", ")", ")", "}", "}", "else", "{", "var", "newRouteInfo", "=", "getRedirectRoute", "(", "that", ",", "path", ",", "newRoutePath", ",", "newRoutes", ",", "routeDivergenceIndex", ")", "if", "(", "newRouteInfo", "!==", "false", ")", "{", "return", "newRouteInfo", "}", "}", "return", "{", "newRoutes", ":", "newRoutes", ",", "divergenceIndex", ":", "routeDivergenceIndex", ",", "pathToEmit", ":", "pathToEmit", "}", "}" ]

[ "returns", "an", "object", "with", "the", "properties", "newRoutes", "-", "an", "array", "of", "Route", "objects", ";", "the", "list", "of", "new", "routes", "to", "enter", "divergenceIndex", "-", "the", "route", "divergence", "index", "pathToEmit", "-", "the", "path", "to", "use", "when", "emitting", "the", "change", "event", "or", "undefined", "-", "if", "the", "paths", "are", "the", "same" ]

[ "function", "loopThroughHandlers", "(", "lastFuture", ",", "n", ")", "{", "if", "(", "n", "<", "routes", ".", "length", ")", "{", "var", "route", "=", "routes", "[", "n", "]", ".", "route", "var", "handler", "=", "route", "[", "handlerProperty", "]", "if", "(", "direction", "===", "-", "1", ")", "{", "var", "originalIndexFromCurrentRoutes", "=", "currentRoutes", ".", "length", "-", "n", "-", "1", "var", "distance", "=", "routes", ".", "length", "-", "n", "// divergenceDistance", "}", "else", "{", "var", "originalIndexFromCurrentRoutes", "=", "routeVergenceIndex", "+", "n", "var", "distance", "=", "undefined", "// no more leafDistance: routes.length - n - 1 // leafDistance", "}", "return", "lastFuture", ".", "then", "(", "function", "(", ")", "{", "if", "(", "handler", "!==", "undefined", ")", "{", "if", "(", "originalIndexFromCurrentRoutes", ">", "0", ")", "{", "var", "parentRoute", "=", "currentRoutes", "[", "originalIndexFromCurrentRoutes", "-", "1", "]", "var", "lastValue", "=", "parentRoute", ".", "route", ".", "lastValue", "}", "var", "nextFuture", "=", "handler", ".", "call", "(", "route", ",", "lastValue", ",", "distance", ")", "if", "(", "nextFuture", "!==", "undefined", ")", "{", "nextFuture", ".", "then", "(", "function", "(", "value", ")", "{", "route", ".", "lastValue", "=", "value", "}", ")", "// no done because nextFuture's errors are handled elsewhere", "}", "}", "if", "(", "nextFuture", "===", "undefined", ")", "{", "nextFuture", "=", "Future", "(", "undefined", ")", "}", "return", "loopThroughHandlers", "(", "nextFuture", ",", "n", "+", "1", ")", "}", ")", ".", "catch", "(", "function", "(", "e", ")", "{", "return", "handleError", "(", "currentRoutes", ",", "originalIndexFromCurrentRoutes", ",", "type", ",", "e", ",", "[", "]", ")", ".", "then", "(", "function", "(", ")", "{", "if", "(", "direction", "===", "1", ")", "{", "return", "Future", "(", "n", "+", "routeVergenceIndex", ")", "}", "else", "{", "// -1 exit handlers", "return", "loopThroughHandlers", "(", "Future", "(", "undefined", ")", ",", "n", "+", "1", ")", "// continue executing the parent exit handlers", "}", "}", ")", "}", ")", "}", "else", "{", "return", "lastFuture", ".", "then", "(", "function", "(", ")", "{", "return", "Future", "(", "n", "+", "routeVergenceIndex", ")", "}", ")", ".", "catch", "(", "function", "(", "e", ")", "{", "throw", "e", "// propagate the error not the value", "}", ")", "}", "}" ]

[ "returns", "a", "future", "that", "resolves", "to", "the", "maximum", "depth", "that", "succeeded" ]

[ "function", "urlToId", "(", "hypemUrl", ")", "{", "var", "trimmedUrl", "=", "_", ".", "trim", "(", "hypemUrl", ")", ";", "if", "(", "_", ".", "startsWith", "(", "trimmedUrl", ",", "HYPEM_TRACK_URL", ")", ")", "{", "var", "parsedUrl", "=", "url", ".", "parse", "(", "hypemUrl", ")", ";", "var", "pathname", "=", "parsedUrl", ".", "pathname", ";", "// '/trach/31jfi/...'", "var", "hypemId", "=", "pathname", ".", "split", "(", "\"/\"", ")", "[", "2", "]", ";", "return", "hypemId", ";", "}", "return", "\"\"", ";", "}" ]

[ "Extract", "the", "hypem", "id", "from", "a", "song", "s", "url", "." ]

[ "function", "getById", "(", "hypemId", ",", "callback", ")", "{", "var", "options", "=", "{", "method", ":", "'HEAD'", ",", "url", ":", "HYPEM_GO_URL", "+", "hypemId", ",", "followRedirect", ":", "false", ",", "timeout", ":", "FIVE_SECONDS_IN_MILLIS", "}", ";", "request", "(", "options", ",", "function", "(", "error", ",", "response", ")", "{", "if", "(", "error", "||", "response", ".", "statusCode", "!==", "302", ")", "{", "callback", "(", "error", ",", "null", ")", ";", "return", ";", "}", "var", "songUrl", "=", "response", ".", "headers", ".", "location", ";", "if", "(", "isSoundcloudUrl", "(", "songUrl", ")", ")", "{", "var", "soundcloudUrl", "=", "getNormalizedSoundcloudUrl", "(", "songUrl", ")", ";", "callback", "(", "null", ",", "soundcloudUrl", ")", ";", "}", "else", "{", "requestHypemKey", "(", "hypemId", ",", "function", "(", "error", ",", "hypemKey", ")", "{", "if", "(", "error", ")", "{", "callback", "(", "error", ",", "null", ")", ";", "return", ";", "}", "requestMp3Url", "(", "hypemId", ",", "hypemKey", ",", "callback", ")", ";", "}", ")", ";", "}", "}", ")", ";", "}" ]

[ "Get", "the", "soundcloud", "or", "mp3", "url", "from", "a", "song", "s", "id", "." ]

[ "function", "requestHypemKey", "(", "hypemId", ",", "callback", ")", "{", "var", "options", "=", "{", "method", ":", "\"GET\"", ",", "url", ":", "HYPEM_TRACK_URL", "+", "hypemId", ",", "headers", ":", "{", "\"Cookie\"", ":", "COOKIE", "}", ",", "timeout", ":", "FIVE_SECONDS_IN_MILLIS", "}", ";", "request", "(", "options", ",", "function", "(", "error", ",", "response", ")", "{", "if", "(", "!", "error", "&&", "response", ".", "statusCode", "===", "200", ")", "{", "var", "bodyLines", "=", "response", ".", "body", ".", "split", "(", "'\\n'", ")", ";", "_", ".", "forIn", "(", "bodyLines", ",", "function", "(", "bodyLine", ")", "{", "if", "(", "bodyLine", ".", "indexOf", "(", "'key'", ")", "!==", "-", "1", ")", "{", "// first hit should be the correct one", "// fix if hypem changes that", "try", "{", "var", "key", "=", "JSON", ".", "parse", "(", "bodyLine", ".", "replace", "(", "'</script>'", ",", "''", ")", ")", ".", "tracks", "[", "0", "]", ".", "key", ";", "callback", "(", "null", ",", "key", ")", ";", "}", "catch", "(", "error", ")", "{", "// if an error happen here do nothing and parse", "// the rest of the document", "}", "}", "}", ")", ";", "}", "else", "{", "callback", "(", "new", "Error", "(", "\"Nothing found: \"", "+", "options", ".", "url", ")", ",", "null", ")", ";", "}", "}", ")", ";", "}" ]

[ "Get", "the", "key", "for", "hypem", ".", "The", "key", "is", "necessary", "to", "request", "the", "hypem", "serve", "url", "which", "gives", "us", "the", "mp3", "url", ".", "We", "dont", "need", "a", "key", "if", "the", "song", "is", "hosted", "on", "soundcloud", "." ]

[ "function", "requestMp3Url", "(", "hypemId", ",", "hypemKey", ",", "callback", ")", "{", "var", "options", "=", "{", "method", ":", "\"GET\"", ",", "url", ":", "HYPEM_SERVE_URL", "+", "hypemId", "+", "\"/\"", "+", "hypemKey", ",", "headers", ":", "{", "\"Cookie\"", ":", "COOKIE", "}", ",", "timeout", ":", "FIVE_SECONDS_IN_MILLIS", "}", ";", "request", "(", "options", ",", "function", "(", "error", ",", "response", ")", "{", "if", "(", "!", "error", "&&", "response", ".", "statusCode", "===", "200", ")", "{", "try", "{", "// the request got a json from hypem", "// where the link to the mp3 file is saved", "var", "jsonBody", "=", "JSON", ".", "parse", "(", "response", ".", "body", ")", ";", "var", "mp3Url", "=", "jsonBody", ".", "url", ";", "callback", "(", "null", ",", "mp3Url", ")", ";", "}", "catch", "(", "error", ")", "{", "callback", "(", "error", ",", "null", ")", ";", "}", "}", "else", "{", "callback", "(", "new", "Error", "(", "\"Nothing found: \"", "+", "options", ".", "url", ")", ",", "null", ")", ";", "}", "}", ")", ";", "}" ]

[ "Get", "the", "mp3", "url", "of", "the", "song", "s", "id", "with", "a", "given", "key", "." ]

[ "function", "getNormalizedSoundcloudUrl", "(", "soundcloudUrl", ")", "{", "var", "parsedUrl", "=", "url", ".", "parse", "(", "soundcloudUrl", ")", ";", "var", "protocol", "=", "parsedUrl", ".", "protocol", ";", "var", "host", "=", "parsedUrl", ".", "host", ";", "var", "pathname", "=", "parsedUrl", ".", "pathname", ";", "var", "splitHostname", "=", "pathname", ".", "split", "(", "'/'", ")", ";", "var", "normalizedUrl", "=", "protocol", "+", "\"//\"", "+", "host", "+", "\"/\"", "+", "splitHostname", "[", "1", "]", "+", "\"/\"", "+", "splitHostname", "[", "2", "]", ";", "return", "normalizedUrl", ";", "}" ]

[ "Get", "the", "normalized", "soundcloud", "url", ".", "This", "means", "that", "every", "parameter", "or", "path", "which", "is", "not", "necessary", "gets", "removed", "." ]

[ "function", "(", "options", ")", "{", "this", ".", "DelOptions", "=", "$", ".", "extend", "(", "{", "}", ",", "defaults", ",", "this", ".", "DelOptions", ",", "options", ")", ";", "this", ".", "dName", "=", "this", ".", "DelOptions", ".", "dName", "||", "this", ".", "_name", ";", "this", ".", "selector", "=", "this", ".", "selector", "||", "'.'", "+", "this", ".", "dName", ";", "this", ".", "namespace", "=", "this", ".", "DelOptions", ".", "namespace", "||", "this", ".", "dName", ";", "this", ".", "initEl", "(", ")", ";", "}" ]

[ "Init", "del", "module" ]

[ "function", "(", "el", ")", "{", "return", "(", "el", "instanceof", "$", "?", "el", ":", "$", "(", "el", ")", ")", ".", "find", "(", "this", ".", "makeSelector", ".", "apply", "(", "this", ",", "[", "]", ".", "slice", ".", "call", "(", "arguments", ",", "1", ")", ")", ")", ";", "}" ]

[ "Find", "element", "in", "other", "el" ]

[ "function", "parse", "(", "code", ")", "{", "Object", ".", "keys", "(", "syntax", ")", ".", "forEach", "(", "(", "s", ")", "=>", "{", "code", "=", "code", ".", "replace", "(", "syntax", "[", "s", "]", ",", "(", "_", ",", "m", ")", "=>", "{", "// ensure if the regex only matches part of the string that we keep the leftover", "let", "leftOver", "=", "_", ".", "replace", "(", "m", ",", "''", ")", "// encode the string and class", "let", "parsed", "=", "`", "${", "s", "}", "${", "encode", "(", "m", ")", "}", "`", "if", "(", "s", "===", "'function'", "&&", "leftOver", ")", "{", "// we want to parse sub commands and the easiest way to do that is to", "// run over the leftOver portion of the function call with the same regex", "let", "startingParenthesis", "=", "leftOver", ".", "indexOf", "(", "'('", ")", "let", "endingParenthesis", "=", "leftOver", ".", "lastIndexOf", "(", "')'", ")", "let", "endingComma", "=", "leftOver", ".", "lastIndexOf", "(", "';'", ")", "// since we don't want to create a new string for every operation", "// we can simply walk the string and replace the character that needs it", "let", "subFunction", "=", "leftOver", ".", "replace", "(", "/", ".", "/", "g", ",", "(", "c", ",", "i", ")", "=>", "{", "// we can define a waterfall case that only replaces the three positions with nothing", "// leaving the other characters in their place", "switch", "(", "i", ")", "{", "case", "startingParenthesis", ":", "case", "endingParenthesis", ":", "case", "endingComma", ":", "return", "''", "default", ":", "return", "c", "}", "}", ")", "leftOver", "=", "`", "${", "parse", "(", "subFunction", ")", "}", "${", "endingComma", ">", "-", "1", "?", "';'", ":", "''", "}", "`", "}", "return", "parsed", "+", "leftOver", "}", ")", "}", ")", "return", "code", "}" ]

[ "walks", "through", "the", "syntaxes", "that", "we", "have", "and", "tokenizes", "the", "entities", "that", "correspond" ]

[ "function", "encode", "(", "str", ")", "{", "return", "str", ".", "split", "(", "''", ")", ".", "map", "(", "(", "s", ")", "=>", "{", "if", "(", "s", ".", "charCodeAt", "(", "0", ")", ">", "127", ")", "return", "s", "return", "String", ".", "fromCharCode", "(", "s", ".", "charCodeAt", "(", "0", ")", "+", "0x2800", ")", "}", ")", ".", "join", "(", "' '", ")", "}" ]

[ "encode", "utf8", "string", "to", "braile" ]

[ "function", "decode", "(", "str", ")", "{", "return", "str", ".", "trim", "(", ")", ".", "split", "(", "' '", ")", ".", "map", "(", "(", "s", ")", "=>", "{", "if", "(", "s", ".", "charCodeAt", "(", "0", ")", "-", "0x2800", ">", "127", ")", "return", "s", "return", "String", ".", "fromCharCode", "(", "s", ".", "charCodeAt", "(", "0", ")", "-", "0x2800", ")", "}", ")", ".", "join", "(", "''", ")", "}" ]

[ "decode", "brail", "back", "to", "utf8" ]

[ "function", "runBrowsersBail", "(", "location", ",", "remote", ",", "platforms", ",", "options", ")", "{", "var", "throttle", "=", "options", ".", "throttle", "||", "function", "(", "fn", ")", "{", "return", "fn", "(", ")", ";", "}", ";", "var", "results", "=", "[", "]", ";", "results", ".", "passedBrowsers", "=", "[", "]", ";", "results", ".", "failedBrowsers", "=", "[", "]", ";", "return", "new", "Promise", "(", "function", "(", "resolve", ")", "{", "function", "next", "(", "i", ")", "{", "if", "(", "i", ">=", "platforms", ".", "length", ")", "{", "return", "resolve", "(", "results", ")", ";", "}", "var", "platform", "=", "platforms", "[", "i", "]", ";", "if", "(", "options", ".", "onQueue", ")", "options", ".", "onQueue", "(", "platform", ")", ";", "throttle", "(", "function", "(", ")", "{", "if", "(", "options", ".", "onStart", ")", "options", ".", "onStart", "(", "platform", ")", ";", "return", "runSingleBrowser", "(", "location", ",", "remote", ",", "platform", ",", "{", "name", ":", "options", ".", "name", ",", "capabilities", ":", "options", ".", "capabilities", ",", "debug", ":", "options", ".", "debug", ",", "httpDebug", ":", "options", ".", "httpDebug", ",", "jobInfo", ":", "options", ".", "jobInfo", ",", "allowExceptions", ":", "options", ".", "allowExceptions", ",", "testComplete", ":", "options", ".", "testComplete", ",", "testPassed", ":", "options", ".", "testPassed", ",", "timeout", ":", "options", ".", "timeout", "}", ")", ";", "}", ")", ".", "done", "(", "function", "(", "result", ")", "{", "Object", ".", "keys", "(", "platform", ")", ".", "forEach", "(", "function", "(", "key", ")", "{", "result", "[", "key", "]", "=", "platform", "[", "key", "]", ";", "}", ")", ";", "results", ".", "push", "(", "result", ")", ";", "if", "(", "options", ".", "onResult", ")", "options", ".", "onResult", "(", "result", ")", ";", "if", "(", "result", ".", "passed", ")", "{", "results", ".", "passedBrowsers", ".", "push", "(", "result", ")", ";", "next", "(", "i", "+", "1", ")", ";", "}", "else", "{", "results", ".", "failedBrowsers", "=", "[", "result", "]", ";", "resolve", "(", "results", ")", ";", "}", "}", ",", "function", "(", "err", ")", "{", "var", "result", "=", "{", "passed", ":", "false", ",", "duration", ":", "err", ".", "duration", ",", "err", ":", "err", "}", ";", "Object", ".", "keys", "(", "platform", ")", ".", "forEach", "(", "function", "(", "key", ")", "{", "result", "[", "key", "]", "=", "platform", "[", "key", "]", ";", "}", ")", ";", "results", ".", "push", "(", "result", ")", ";", "if", "(", "options", ".", "onResult", ")", "options", ".", "onResult", "(", "result", ")", ";", "results", ".", "failedBrowsers", "=", "[", "result", "]", ";", "resolve", "(", "results", ")", ";", "}", ")", ";", "}", "next", "(", "0", ")", ";", "}", ")", ";", "}" ]

[ "Run", "a", "test", "in", "a", "series", "of", "browsers", "one", "at", "at", "time", "until", "one", "of", "them", "fails" ]

[ "function", "(", ")", "{", "var", "bear", "=", "this", ";", "// don't bind until we're ready", "var", "srv", "=", "bear", ".", "ready", ".", "then", "(", "function", "(", ")", "{", "var", "dfd", "=", "_", ".", "Deferred", "(", ")", ";", "// only make once", "if", "(", "!", "bear", ".", "githInstance", ")", "{", "bear", ".", "githInstance", "=", "bear", ".", "gith", "(", "{", "repo", ":", "bear", ".", "settings", ".", "repo", ",", "}", ")", ".", "on", "(", "'all'", ",", "bear", ".", "_processPayload", ".", "bind", "(", "bear", ")", ")", ";", "}", "dfd", ".", "resolve", "(", "bear", ".", "githInstance", ")", ";", "return", "dfd", ".", "promise", "(", ")", ";", "}", ")", ";", "return", "srv", ";", "}" ]

[ "but", "this", "is", "where", "the", "gold", "is" ]

[ "function", "(", "payload", ")", "{", "var", "bear", "=", "this", ";", "var", "dfd", "=", "_", ".", "Deferred", "(", ")", ";", "var", "action", "=", "dfd", ".", "promise", "(", ")", ";", "// ok to launch live?", "if", "(", "payload", ".", "branch", "===", "bear", ".", "settings", ".", "liveBranch", ")", "{", "// can we just upload master without worrying about tags?", "if", "(", "!", "bear", ".", "settings", ".", "deployOnTag", ")", "{", "action", "=", "action", ".", "then", "(", "function", "(", ")", "{", "return", "bear", ".", "live", "(", "bear", ".", "settings", ".", "liveBranch", ")", ";", "}", ")", ";", "}", "else", "if", "(", "payload", ".", "tag", ")", "{", "// since we tagged and that's required, only launch at that sha", "action", "=", "action", ".", "then", "(", "function", "(", ")", "{", "return", "bear", ".", "live", "(", "bear", ".", "settings", ".", "liveBranch", ",", "payload", ".", "sha", ")", ";", "}", ")", ";", "}", "}", "// either way, setup the staging version", "action", "=", "action", ".", "then", "(", "function", "(", ")", "{", "return", "bear", ".", "stage", "(", "payload", ".", "branch", ")", ";", "}", ")", ";", "// if we assigned a callback, fire it when these are done", "if", "(", "bear", ".", "settings", ".", "githCallback", ")", "{", "action", ".", "done", "(", "function", "(", ")", "{", "bear", ".", "settings", ".", "githCallback", ".", "call", "(", "bear", ",", "payload", ")", ";", "}", ")", ";", "}", "// start us off", "dfd", ".", "resolve", "(", ")", ";", "}" ]

[ "process", "the", "payload", "gith", "emitted" ]

[ "function", "(", ")", "{", "return", "dexec", "(", "'cd '", "+", "this", ".", "settings", ".", "git", "+", "'; npm install'", ")", ".", "done", "(", "function", "(", "stdout", ",", "stderr", ")", "{", "log", "(", "'npm install successful'", ")", ";", "log", ".", "extra", "(", "stdout", ",", "stderr", ")", ";", "}", ")", ";", "}" ]

[ "hook", "into", "our", "process" ]

[ "function", "textStream", "(", ")", "{", "var", "start", "=", "randomInt", "(", "0", ",", "config", ".", "size", "-", "bufferSize", ")", "return", "fs", ".", "createReadStream", "(", "dictPath", ",", "{", "encoding", ":", "config", ".", "encoding", ",", "start", ":", "start", ",", "end", ":", "start", "+", "bufferSize", "}", ")", "}" ]

[ "read", "dictionary", "with", "stream" ]

[ "function", "SocketioHandler", "(", "io", ",", "options", ")", "{", "/**\n * Emit 'data' to all sockets for the provided User or array of Users.\n * \n * @param {*} channelName \n * @param {*} users \n * @param {*} data \n */", "function", "emitToUsers", "(", "users", ",", "channelName", ",", "data", ")", "{", "const", "usersArray", "=", "Array", ".", "isArray", "(", "users", ")", "?", "users", ":", "[", "users", "]", ";", "usersArray", ".", "map", "(", "function", "(", "user", ")", "{", "Object", ".", "keys", "(", "io", ".", "sockets", ".", "sockets", ")", ".", "filter", "(", "function", "(", "key", ")", "{", "return", "io", ".", "sockets", ".", "sockets", "[", "key", "]", ".", "transomUser", ".", "_id", ".", "toString", "(", ")", "===", "user", ".", "_id", ".", "toString", "(", ")", ";", "}", ")", ".", "map", "(", "function", "(", "socketKey", ")", "{", "io", ".", "sockets", ".", "sockets", "[", "socketKey", "]", ".", "emit", "(", "channelName", ",", "data", ")", ";", "}", ")", ";", "}", ")", ";", "}", "/**\n * Emit 'data' to all sockets for the authenticated Users.\n * \n * @param {*} channelName \n * @param {*} data \n */", "function", "emitToEveryone", "(", "channelName", ",", "data", ")", "{", "Object", ".", "keys", "(", "io", ".", "sockets", ".", "sockets", ")", ".", "filter", "(", "function", "(", "key", ")", "{", "return", "!", "!", "io", ".", "sockets", ".", "sockets", "[", "key", "]", ".", "transomUser", ";", "}", ")", ".", "map", "(", "function", "(", "socketKey", ")", "{", "io", ".", "sockets", ".", "sockets", "[", "socketKey", "]", ".", "emit", "(", "channelName", ",", "data", ")", ";", "}", ")", ";", "}", "return", "{", "emitToUsers", ",", "emitToEveryone", ",", "// simple getter that allows access to io, while dis-allowing updates.", "get", "io", "(", ")", "{", "return", "io", ";", "}", "}", ";", "}" ]

[ "Module", "for", "the", "socket", "handler", ".", "Exports", "this", "function", "that", "creates", "the", "instance", "of", "the", "handler", ".", "which", "is", "added", "to", "the", "server", "registry", "as", "transomMessageClient" ]

[ "function", "emitToUsers", "(", "users", ",", "channelName", ",", "data", ")", "{", "const", "usersArray", "=", "Array", ".", "isArray", "(", "users", ")", "?", "users", ":", "[", "users", "]", ";", "usersArray", ".", "map", "(", "function", "(", "user", ")", "{", "Object", ".", "keys", "(", "io", ".", "sockets", ".", "sockets", ")", ".", "filter", "(", "function", "(", "key", ")", "{", "return", "io", ".", "sockets", ".", "sockets", "[", "key", "]", ".", "transomUser", ".", "_id", ".", "toString", "(", ")", "===", "user", ".", "_id", ".", "toString", "(", ")", ";", "}", ")", ".", "map", "(", "function", "(", "socketKey", ")", "{", "io", ".", "sockets", ".", "sockets", "[", "socketKey", "]", ".", "emit", "(", "channelName", ",", "data", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Emit", "data", "to", "all", "sockets", "for", "the", "provided", "User", "or", "array", "of", "Users", "." ]

[ "function", "emitToEveryone", "(", "channelName", ",", "data", ")", "{", "Object", ".", "keys", "(", "io", ".", "sockets", ".", "sockets", ")", ".", "filter", "(", "function", "(", "key", ")", "{", "return", "!", "!", "io", ".", "sockets", ".", "sockets", "[", "key", "]", ".", "transomUser", ";", "}", ")", ".", "map", "(", "function", "(", "socketKey", ")", "{", "io", ".", "sockets", ".", "sockets", "[", "socketKey", "]", ".", "emit", "(", "channelName", ",", "data", ")", ";", "}", ")", ";", "}" ]

[ "Emit", "data", "to", "all", "sockets", "for", "the", "authenticated", "Users", "." ]

[ "function", "updatePos", "(", "pos", ",", "prop", ",", "val", ")", "{", "floatSpace", ".", "setStyle", "(", "prop", ",", "pixelate", "(", "val", ")", ")", ";", "floatSpace", ".", "setStyle", "(", "'position'", ",", "pos", ")", ";", "}" ]

[ "Update", "the", "float", "space", "position", "." ]

[ "function", "changeMode", "(", "newMode", ")", "{", "var", "editorPos", "=", "editable", ".", "getDocumentPosition", "(", ")", ";", "switch", "(", "newMode", ")", "{", "case", "'top'", ":", "updatePos", "(", "'absolute'", ",", "'top'", ",", "editorPos", ".", "y", "-", "spaceHeight", "-", "dockedOffsetY", ")", ";", "break", ";", "case", "'pin'", ":", "updatePos", "(", "'fixed'", ",", "'top'", ",", "pinnedOffsetY", ")", ";", "break", ";", "case", "'bottom'", ":", "updatePos", "(", "'absolute'", ",", "'top'", ",", "editorPos", ".", "y", "+", "(", "editorRect", ".", "height", "||", "editorRect", ".", "bottom", "-", "editorRect", ".", "top", ")", "+", "dockedOffsetY", ")", ";", "break", ";", "}", "mode", "=", "newMode", ";", "}" ]

[ "Change", "the", "current", "mode", "and", "update", "float", "space", "position", "accordingly", "." ]

[ "function", "(", "e", ")", "{", "e", "=", "e", "||", "window", ".", "event", ";", "e", ".", "preventDefault", "?", "e", ".", "preventDefault", "(", ")", ":", "(", "e", ".", "returnValue", "=", "false", ")", ";", "var", "eTarget", "=", "e", ".", "target", "||", "e", ".", "srcElement", ";", "// find root element of slide", "var", "clickedListItem", "=", "closest", "(", "eTarget", ",", "function", "(", "el", ")", "{", "//console.log(el.getAttribute('ui-gallery-item'));", "return", "el", ".", "getAttribute", "(", "'ui-gallery-item'", ")", "!=", "null", ";", "}", ")", ";", "if", "(", "!", "clickedListItem", ")", "{", "return", ";", "}", "var", "parentNode", "=", "closest", "(", "eTarget", ",", "function", "(", "el", ")", "{", "return", "el", ".", "getAttribute", "(", "'ui-gallery'", ")", "!=", "null", ";", "}", ")", ";", "if", "(", "!", "parentNode", ")", "{", "return", ";", "}", "var", "childNodes", "=", "parentNode", ".", "querySelectorAll", "(", "'[ui-gallery-item]'", ")", ";", "// find index of clicked item by looping through all child nodes", "// alternatively, you may define index via data- attribute", "var", "clickedGallery", "=", "parentNode", ",", "numChildNodes", "=", "childNodes", ".", "length", ",", "nodeIndex", "=", "0", ",", "index", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "numChildNodes", ";", "i", "++", ")", "{", "if", "(", "childNodes", "[", "i", "]", ".", "nodeType", "!==", "1", ")", "{", "continue", ";", "}", "if", "(", "childNodes", "[", "i", "]", "===", "clickedListItem", ")", "{", "index", "=", "nodeIndex", ";", "break", ";", "}", "nodeIndex", "++", ";", "}", "if", "(", "index", ">=", "0", ")", "{", "// open PhotoSwipe if valid index found", "openPhotoSwipe", "(", "index", ",", "clickedGallery", ")", ";", "}", "return", "false", ";", "}" ]

[ "triggers", "when", "user", "clicks", "on", "thumbnail" ]

[ "function", "handleUncaughtExceptions", "(", "error", ")", "{", "if", "(", "!", "error", "||", "!", "error", ".", "stack", ")", "{", "console", ".", "log", "(", "'Uncaught exception:'", ",", "error", ")", ";", "process", ".", "exit", "(", ")", ";", "}", "var", "match", "=", "/", "\\n at [^(]+ \\((.*):(\\d+):(\\d+)\\)", "/", ".", "exec", "(", "error", ".", "stack", ")", ";", "if", "(", "match", ")", "{", "var", "cache", "=", "{", "}", ";", "var", "position", "=", "mapSourcePosition", "(", "cache", ",", "{", "source", ":", "match", "[", "1", "]", ",", "line", ":", "match", "[", "2", "]", ",", "column", ":", "match", "[", "3", "]", "}", ")", ";", "if", "(", "fs", ".", "existsSync", "(", "position", ".", "source", ")", ")", "{", "var", "contents", "=", "fs", ".", "readFileSync", "(", "position", ".", "source", ",", "'utf8'", ")", ";", "var", "line", "=", "contents", ".", "split", "(", "/", "(?:\\r\\n|\\r|\\n)", "/", ")", "[", "position", ".", "line", "-", "1", "]", ";", "if", "(", "line", ")", "{", "console", ".", "log", "(", "'\\n'", "+", "position", ".", "source", "+", "':'", "+", "position", ".", "line", ")", ";", "console", ".", "log", "(", "line", ")", ";", "console", ".", "log", "(", "new", "Array", "(", "+", "position", ".", "column", ")", ".", "join", "(", "' '", ")", "+", "'^'", ")", ";", "}", "}", "}", "console", ".", "log", "(", "error", ".", "stack", ")", ";", "process", ".", "exit", "(", ")", ";", "}" ]

[ "Mimic", "node", "s", "stack", "trace", "printing", "when", "an", "exception", "escapes", "the", "process" ]

[ "function", "broadcastMonitors", "(", "records", ",", "moduleId", ",", "msg", ")", "{", "msg", "=", "protocol", ".", "composeRequest", "(", "null", ",", "moduleId", ",", "msg", ")", ";", "if", "(", "records", "instanceof", "Array", ")", "{", "for", "(", "let", "i", "=", "0", ",", "l", "=", "records", ".", "length", ";", "i", "<", "l", ";", "i", "++", ")", "{", "const", "socket", "=", "records", "[", "i", "]", ".", "socket", ";", "doSend", "(", "socket", ",", "'monitor'", ",", "msg", ")", ";", "}", "}", "else", "{", "for", "(", "const", "id", "in", "records", ")", "{", "if", "(", "records", ".", "hasOwnProperty", "(", "id", ")", ")", "{", "const", "socket", "=", "records", "[", "id", "]", ".", "socket", ";", "doSend", "(", "socket", ",", "'monitor'", ",", "msg", ")", ";", "}", "}", "}", "}" ]

[ "broadcast", "msg", "to", "monitor" ]

[ "function", "getChar", "(", "bits", ")", "{", "var", "index", "=", "parseInt", "(", "bits", ",", "2", ")", ";", "if", "(", "isNaN", "(", "index", ")", "||", "index", "<", "0", "||", "index", ">", "63", ")", "throw", "new", "Error", "(", "'baseURL#getChar: Need valid bitString'", ")", ";", "return", "ALPHABET", "[", "index", "]", ";", "}" ]

[ "Get", "baseURL", "char", "from", "given", "6bit", "bitstring" ]

[ "function", "indexOfBits", "(", "char", ")", "{", "var", "index", "=", "ALPHABET", ".", "indexOf", "(", "char", ")", ";", "if", "(", "index", "<", "0", ")", "throw", "new", "Error", "(", "'baseURL#indexOfBits: Need valid baseURL char'", ")", ";", "return", "bitString", ".", "pad", "(", "index", ".", "toString", "(", "2", ")", ",", "6", ")", ";", "}" ]

[ "Get", "6bit", "bitstring", "given", "a", "baseURL", "char" ]

[ "function", "encode", "(", "bits", ")", "{", "if", "(", "!", "bitString", ".", "isValid", "(", "bits", ")", ")", "throw", "new", "Error", "(", "'baseURL#encode: bits not valid bitstring'", ")", ";", "if", "(", "bits", ".", "length", "%", "6", "!==", "0", ")", "throw", "new", "Error", "(", "'baseURL#encode: bits must be a multiple of 6'", ")", ";", "var", "result", "=", "''", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "bits", ".", "length", ";", "i", "=", "i", "+", "6", ")", "{", "result", "+=", "getChar", "(", "bits", ".", "slice", "(", "i", ",", "i", "+", "6", ")", ")", ";", "}", "return", "result", ";", "}" ]

[ "Encode", "a", "mod", "6", "bitstring", "into", "a", "baseURL", "string" ]

[ "function", "decode", "(", "str", ")", "{", "if", "(", "!", "isValid", "(", "str", ")", ")", "throw", "new", "Error", "(", "'baseURL#decode: str not valid baseURL string'", ")", ";", "var", "bits", "=", "''", ";", "// Decode", "for", "(", "var", "i", "=", "0", ";", "i", "<", "str", ".", "length", ";", "i", "++", ")", "{", "bits", "+=", "indexOfBits", "(", "str", "[", "i", "]", ")", ";", "}", "return", "bits", ";", "}" ]

[ "Decode", "a", "baseURL", "string", "to", "a", "mod", "6", "bitstring" ]

[ "function", "simpleComponent", "(", "elementName", ",", "elementClass", ",", "elementClassToExtend", ")", "{", "elementClass", "=", "elementClass", "||", "{", "}", "elementClassToExtend", "=", "elementClassToExtend", "||", "HTMLElement", "elementClass", ".", "prototype", "=", "Object", ".", "create", "(", "elementClassToExtend", ".", "prototype", ")", "assign", "(", "elementClass", ".", "prototype", ",", "elementClass", ")", "elementClass", ".", "__template", "=", "template", "(", "elementName", ")", "if", "(", "elementClass", ".", "prototype", ".", "createdCallback", ")", "{", "elementClass", ".", "prototype", ".", "__originalCreatedCallback", "=", "elementClass", ".", "prototype", ".", "createdCallback", "}", "elementClass", ".", "prototype", ".", "createdCallback", "=", "function", "(", ")", "{", "fill", "(", "this", ",", "elementClass", ".", "__template", ")", "if", "(", "elementClass", ".", "prototype", ".", "__originalCreatedCallback", ")", "{", "elementClass", ".", "prototype", ".", "__originalCreatedCallback", ".", "call", "(", "this", ")", "}", "}", "document", ".", "registerElement", "(", "elementName", ",", "elementClass", ")", "}" ]

[ "Define", "a", "stateless", "custom", "element", "with", "no", "behaviors", ".", "Give", "the", "element", "s", "template", "an", "ID", "attribute", "with", "the", "-", "template", "suffix", "." ]

[ "function", "fill", "(", "toElement", ",", "templateElement", ")", "{", "var", "templateContentClone", "=", "templateElement", ".", "content", ".", "cloneNode", "(", "true", ")", "var", "slot", "var", "i", "if", "(", "toElement", ".", "childNodes", ".", "length", ")", "{", "slot", "=", "templateContentClone", ".", "querySelector", "(", "'slot'", ")", "if", "(", "slot", ")", "{", "while", "(", "toElement", ".", "childNodes", ".", "length", ")", "{", "slot", ".", "appendChild", "(", "toElement", ".", "firstChild", ")", "}", "}", "}", "toElement", ".", "appendChild", "(", "templateContentClone", ")", "}" ]

[ "Attach", "a", "template", "s", "content", "to", "an", "element", "." ]

[ "function", "makeRequire", "(", "m", ",", "self", ")", "{", "function", "_require", "(", "_path", ")", "{", "return", "m", ".", "require", "(", "_path", ")", ";", "}", "_require", ".", "resolve", "=", "function", "(", "request", ")", "{", "return", "_module", ".", "_resolveFilename", "(", "request", ",", "self", ")", ";", "}", ";", "_require", ".", "cache", "=", "_module", ".", "_cache", ";", "_require", ".", "extensions", "=", "_module", ".", "_extensions", ";", "return", "_require", ";", "}" ]

[ "Basically", "takes", "the", "place", "of", "Module", ".", "prototype", ".", "_compile", "with", "some", "features", "stripped", "out" ]

[ "function", "_connectionFailureHandler", "(", "self", ")", "{", "return", "function", "(", ")", "{", "if", "(", "this", ".", "_connectionFailHandled", ")", "return", ";", "this", ".", "_connectionFailHandled", "=", "true", ";", "// Destroy the connection", "this", ".", "destroy", "(", ")", ";", "// Count down the number of reconnects", "self", ".", "retriesLeft", "=", "self", ".", "retriesLeft", "-", "1", ";", "// How many retries are left", "if", "(", "self", ".", "retriesLeft", "<=", "0", ")", "{", "// Destroy the instance", "self", ".", "destroy", "(", ")", ";", "// Emit close event", "self", ".", "emit", "(", "'reconnectFailed'", ",", "new", "MongoNetworkError", "(", "f", "(", "'failed to reconnect after %s attempts with interval %s ms'", ",", "self", ".", "options", ".", "reconnectTries", ",", "self", ".", "options", ".", "reconnectInterval", ")", ")", ")", ";", "}", "else", "{", "self", ".", "reconnectId", "=", "setTimeout", "(", "attemptReconnect", "(", "self", ")", ",", "self", ".", "options", ".", "reconnectInterval", ")", ";", "}", "}", ";", "}" ]

[ "If", "we", "have", "failure", "schedule", "a", "retry" ]

[ "function", "_connectHandler", "(", "self", ")", "{", "return", "function", "(", ")", "{", "// Assign", "var", "connection", "=", "this", ";", "// Pool destroyed stop the connection", "if", "(", "self", ".", "state", "===", "DESTROYED", "||", "self", ".", "state", "===", "DESTROYING", ")", "{", "return", "connection", ".", "destroy", "(", ")", ";", "}", "// Clear out all handlers", "handlers", ".", "forEach", "(", "function", "(", "event", ")", "{", "connection", ".", "removeAllListeners", "(", "event", ")", ";", "}", ")", ";", "// Reset reconnect id", "self", ".", "reconnectId", "=", "null", ";", "// Apply pool connection handlers", "connection", ".", "on", "(", "'error'", ",", "connectionFailureHandler", "(", "self", ",", "'error'", ")", ")", ";", "connection", ".", "on", "(", "'close'", ",", "connectionFailureHandler", "(", "self", ",", "'close'", ")", ")", ";", "connection", ".", "on", "(", "'timeout'", ",", "connectionFailureHandler", "(", "self", ",", "'timeout'", ")", ")", ";", "connection", ".", "on", "(", "'parseError'", ",", "connectionFailureHandler", "(", "self", ",", "'parseError'", ")", ")", ";", "// Apply any auth to the connection", "reauthenticate", "(", "self", ",", "this", ",", "function", "(", ")", "{", "// Reset retries", "self", ".", "retriesLeft", "=", "self", ".", "options", ".", "reconnectTries", ";", "// Push to available connections", "self", ".", "availableConnections", ".", "push", "(", "connection", ")", ";", "// Set the reconnectConnection to null", "self", ".", "reconnectConnection", "=", "null", ";", "// Emit reconnect event", "self", ".", "emit", "(", "'reconnect'", ",", "self", ")", ";", "// Trigger execute to start everything up again", "_execute", "(", "self", ")", "(", ")", ";", "}", ")", ";", "}", ";", "}" ]

[ "Got", "a", "connect", "handler" ]

[ "function", "authenticateStragglers", "(", "self", ",", "connection", ",", "callback", ")", "{", "// Get any non authenticated connections", "var", "connections", "=", "self", ".", "nonAuthenticatedConnections", ".", "slice", "(", "0", ")", ";", "var", "nonAuthenticatedConnections", "=", "self", ".", "nonAuthenticatedConnections", ";", "self", ".", "nonAuthenticatedConnections", "=", "[", "]", ";", "// Establish if the connection need to be authenticated", "// Add to authentication list if", "// 1. we were in an authentication process when the operation was executed", "// 2. our current authentication timestamp is from the workItem one, meaning an auth has happened", "if", "(", "connection", ".", "workItems", ".", "length", "===", "1", "&&", "(", "connection", ".", "workItems", "[", "0", "]", ".", "authenticating", "===", "true", "||", "(", "typeof", "connection", ".", "workItems", "[", "0", "]", ".", "authenticatingTimestamp", "===", "'number'", "&&", "connection", ".", "workItems", "[", "0", "]", ".", "authenticatingTimestamp", "!==", "self", ".", "authenticatingTimestamp", ")", ")", ")", "{", "// Add connection to the list", "connections", ".", "push", "(", "connection", ")", ";", "}", "// No connections need to be re-authenticated", "if", "(", "connections", ".", "length", "===", "0", ")", "{", "// Release the connection back to the pool", "moveConnectionBetween", "(", "connection", ",", "self", ".", "inUseConnections", ",", "self", ".", "availableConnections", ")", ";", "// Finish", "return", "callback", "(", ")", ";", "}", "// Apply re-authentication to all connections before releasing back to pool", "var", "connectionCount", "=", "connections", ".", "length", ";", "// Authenticate all connections", "for", "(", "var", "i", "=", "0", ";", "i", "<", "connectionCount", ";", "i", "++", ")", "{", "reauthenticate", "(", "self", ",", "connections", "[", "i", "]", ",", "function", "(", ")", "{", "connectionCount", "=", "connectionCount", "-", "1", ";", "if", "(", "connectionCount", "===", "0", ")", "{", "// Put non authenticated connections in available connections", "self", ".", "availableConnections", "=", "self", ".", "availableConnections", ".", "concat", "(", "nonAuthenticatedConnections", ")", ";", "// Release the connection back to the pool", "moveConnectionBetween", "(", "connection", ",", "self", ".", "inUseConnections", ",", "self", ".", "availableConnections", ")", ";", "// Return", "callback", "(", ")", ";", "}", "}", ")", ";", "}", "}" ]

[ "Authenticate", "any", "straggler", "connections" ]

[ "function", "authenticateLiveConnections", "(", "self", ",", "args", ",", "cb", ")", "{", "// Get the current viable connections", "var", "connections", "=", "self", ".", "allConnections", "(", ")", ";", "// Allow nothing else to use the connections while we authenticate them", "self", ".", "availableConnections", "=", "[", "]", ";", "self", ".", "inUseConnections", "=", "[", "]", ";", "self", ".", "connectingConnections", "=", "[", "]", ";", "var", "connectionsCount", "=", "connections", ".", "length", ";", "var", "error", "=", "null", ";", "// No connections available, return", "if", "(", "connectionsCount", "===", "0", ")", "{", "self", ".", "authenticating", "=", "false", ";", "return", "callback", "(", "null", ")", ";", "}", "// Authenticate the connections", "for", "(", "var", "i", "=", "0", ";", "i", "<", "connections", ".", "length", ";", "i", "++", ")", "{", "authenticate", "(", "self", ",", "args", ",", "connections", "[", "i", "]", ",", "function", "(", "err", ",", "result", ")", "{", "connectionsCount", "=", "connectionsCount", "-", "1", ";", "// Store the error", "if", "(", "err", ")", "error", "=", "err", ";", "// Processed all connections", "if", "(", "connectionsCount", "===", "0", ")", "{", "// Auth finished", "self", ".", "authenticating", "=", "false", ";", "// Add the connections back to available connections", "self", ".", "availableConnections", "=", "self", ".", "availableConnections", ".", "concat", "(", "connections", ")", ";", "// We had an error, return it", "if", "(", "error", ")", "{", "// Log the error", "if", "(", "self", ".", "logger", ".", "isError", "(", ")", ")", "{", "self", ".", "logger", ".", "error", "(", "f", "(", "'[%s] failed to authenticate against server %s:%s'", ",", "self", ".", "id", ",", "self", ".", "options", ".", "host", ",", "self", ".", "options", ".", "port", ")", ")", ";", "}", "return", "cb", "(", "error", ",", "result", ")", ";", "}", "cb", "(", "null", ",", "result", ")", ";", "}", "}", ")", ";", "}", "}" ]

[ "Authenticate", "all", "live", "connections" ]

[ "function", "waitForLogout", "(", "self", ",", "cb", ")", "{", "if", "(", "!", "self", ".", "loggingout", ")", "return", "cb", "(", ")", ";", "setTimeout", "(", "function", "(", ")", "{", "waitForLogout", "(", "self", ",", "cb", ")", ";", "}", ",", "1", ")", ";", "}" ]

[ "Wait", "for", "a", "logout", "in", "process", "to", "happen" ]

[ "function", "(", "_connection", ")", "{", "return", "function", "(", ")", "{", "// Destroyed state return", "if", "(", "self", ".", "state", "===", "DESTROYED", "||", "self", ".", "state", "===", "DESTROYING", ")", "{", "// Remove the connection from the list", "removeConnection", "(", "self", ",", "_connection", ")", ";", "return", "_connection", ".", "destroy", "(", ")", ";", "}", "// Destroy all event emitters", "handlers", ".", "forEach", "(", "function", "(", "e", ")", "{", "_connection", ".", "removeAllListeners", "(", "e", ")", ";", "}", ")", ";", "// Add the final handlers", "_connection", ".", "once", "(", "'close'", ",", "connectionFailureHandler", "(", "self", ",", "'close'", ")", ")", ";", "_connection", ".", "once", "(", "'error'", ",", "connectionFailureHandler", "(", "self", ",", "'error'", ")", ")", ";", "_connection", ".", "once", "(", "'timeout'", ",", "connectionFailureHandler", "(", "self", ",", "'timeout'", ")", ")", ";", "_connection", ".", "once", "(", "'parseError'", ",", "connectionFailureHandler", "(", "self", ",", "'parseError'", ")", ")", ";", "// Signal", "reauthenticate", "(", "self", ",", "_connection", ",", "function", "(", "err", ")", "{", "if", "(", "self", ".", "state", "===", "DESTROYED", "||", "self", ".", "state", "===", "DESTROYING", ")", "{", "return", "_connection", ".", "destroy", "(", ")", ";", "}", "// Remove the connection from the connectingConnections list", "removeConnection", "(", "self", ",", "_connection", ")", ";", "// Handle error", "if", "(", "err", ")", "{", "return", "_connection", ".", "destroy", "(", ")", ";", "}", "// If we are c at the moment", "// Do not automatially put in available connections", "// As we need to apply the credentials first", "if", "(", "self", ".", "authenticating", ")", "{", "self", ".", "nonAuthenticatedConnections", ".", "push", "(", "_connection", ")", ";", "}", "else", "{", "// Push to available", "self", ".", "availableConnections", ".", "push", "(", "_connection", ")", ";", "// Execute any work waiting", "_execute", "(", "self", ")", "(", ")", ";", "}", "}", ")", ";", "}", ";", "}" ]

[ "Handle", "successful", "connection" ]

[ "function", "Miscue", "(", "code", ",", "data", ")", "{", "if", "(", "!", "(", "this", "instanceof", "Miscue", ")", ")", "return", "new", "Miscue", "(", "code", ",", "data", ")", ";", "return", "this", ".", "initialize", "(", "code", ",", "data", ")", ";", "}" ]

[ "Creates", "a", "new", "Miscue", "object" ]

[ "function", "createLint", "(", "inPath", ",", "opts", "=", "{", "}", ")", "{", "if", "(", "!", "inPath", ")", "{", "throw", "new", "Error", "(", "'Input path argument is required'", ")", ";", "}", "return", "function", "lint", "(", ")", "{", "return", "gulp", ".", "src", "(", "inPath", ")", ".", "pipe", "(", "eslint", "(", "opts", ")", ")", ".", "pipe", "(", "eslint", ".", "format", "(", ")", ")", ".", "pipe", "(", "eslint", ".", "failAfterError", "(", ")", ")", ";", "}", ";", "}" ]

[ "Higher", "order", "function", "to", "create", "gulp", "function", "that", "lints", "files", "using", "eslint", "." ]

[ "function", "getStartEndRowsFromBoardSize", "(", "boardSize", ")", "{", "const", "endRow", "=", "boardSize", ".", "y", "-", "1", ";", "return", "{", "white", ":", "getStartEndRow", "(", "endRow", ",", "false", ")", ",", "black", ":", "getStartEndRow", "(", "endRow", ",", "true", ")", "}", ";", "}" ]

[ "Takes", "a", "boardSize", "and", "return", "START", "and", "END", "rows", "for", "WHITE", "and", "BLACK", "." ]

[ "function", "getJumpPosition", "(", "from", ",", "toJump", ",", "board", ")", "{", "const", "jumpXY", "=", "getJumpXY", "(", "from", ",", "toJump", ")", ";", "if", "(", "!", "hasPosition", "(", "board", ",", "jumpXY", ")", ")", "return", ";", "const", "jumpPosition", "=", "getPositionFromBoard", "(", "board", ",", "jumpXY", ")", ";", "if", "(", "Position", ".", "hasPiece", "(", "jumpPosition", ")", ")", "return", ";", "return", "jumpPosition", ";", "}" ]

[ "Returns", "the", "target", "board", "position", "from", "a", "jump", "if", "this", "position", "exists", "and", "is", "empty", "." ]

[ "function", "isValid", "(", "path", ",", "entry", ")", "{", "var", "isValid", "=", "valid", "(", "path", ")", "if", "(", "isValid", ")", "{", "log", ".", "verbose", "(", "'extracted file from tarball'", ",", "path", ")", "extractCount", "++", "}", "else", "{", "// invalid", "log", ".", "silly", "(", "'ignoring from tarball'", ",", "path", ")", "}", "return", "isValid", "}" ]

[ "checks", "if", "a", "file", "to", "be", "extracted", "from", "the", "tarball", "is", "valid", ".", "only", ".", "h", "header", "files", "and", "the", "gyp", "files", "get", "extracted" ]

[ "function", "get", "(", "path", ")", "{", "var", "conf", "=", "this", ";", "if", "(", "typeof", "path", "!==", "'string'", ")", "{", "throw", "new", "Error", "(", "'path should be a string!'", ")", ";", "}", "else", "if", "(", "path", ".", "length", "===", "0", ")", "{", "throw", "new", "Error", "(", "'path cannot be empty!'", ")", ";", "}", "var", "result", "=", "baseGet", "(", "conf", ",", "getPathArray", "(", "path", ")", ")", ";", "if", "(", "result", "===", "undefined", ")", "{", "throw", "new", "Error", "(", "'the value is undefined!'", ")", ";", "}", "else", "{", "bindGetMethod", "(", "result", ")", ";", "// eslint-disable-line", "}", "return", "result", ";", "}" ]

[ "Gets", "the", "property", "value", "at", "path", "of", "config", ".", "If", "the", "resolved", "value", "is", "undefined", "it", "will", "throw", "an", "error", "." ]