Datasets:

CM

/

codexglue_code2text_javascript

like 11

[ "function", "(", "plugin", ")", "{", "var", "ns", "=", "plugin", ",", "plugins", "=", "this", ".", "_plugins", ";", "if", "(", "L", ".", "isFunction", "(", "plugin", ")", ")", "{", "ns", "=", "plugin", ".", "NS", ";", "if", "(", "ns", "&&", "(", "!", "plugins", "[", "ns", "]", "||", "plugins", "[", "ns", "]", "!==", "plugin", ")", ")", "{", "ns", "=", "null", ";", "}", "}", "if", "(", "ns", ")", "{", "if", "(", "this", "[", "ns", "]", ")", "{", "this", "[", "ns", "]", ".", "destroy", "(", ")", ";", "delete", "this", "[", "ns", "]", ";", "}", "if", "(", "plugins", "[", "ns", "]", ")", "{", "delete", "plugins", "[", "ns", "]", ";", "}", "}", "}" ]

[ "Unplugs", "and", "destroys", "a", "plugin", "already", "instantiated", "with", "the", "host", "." ]

[ "function", "(", ")", "{", "var", "str", "=", "this", "[", "UID", "]", "+", "': not bound to a node'", ",", "node", "=", "this", ".", "_node", ",", "attrs", ",", "id", ",", "className", ";", "if", "(", "node", ")", "{", "attrs", "=", "node", ".", "attributes", ";", "id", "=", "(", "attrs", "&&", "attrs", ".", "id", ")", "?", "node", ".", "getAttribute", "(", "'id'", ")", ":", "null", ";", "className", "=", "(", "attrs", "&&", "attrs", ".", "className", ")", "?", "node", ".", "getAttribute", "(", "'className'", ")", ":", "null", ";", "str", "=", "node", "[", "NODE_NAME", "]", ";", "if", "(", "id", ")", "{", "str", "+=", "'#'", "+", "id", ";", "}", "if", "(", "className", ")", "{", "str", "+=", "'.'", "+", "className", ".", "replace", "(", "' '", ",", "'.'", ")", ";", "}", "// TODO: add yuid?", "str", "+=", "' '", "+", "this", "[", "UID", "]", ";", "}", "return", "str", ";", "}" ]

[ "The", "method", "called", "when", "outputting", "Node", "instances", "as", "strings" ]

[ "function", "(", "attr", ")", "{", "var", "attrConfig", "=", "Y_Node", ".", "ATTRS", "[", "attr", "]", ",", "val", ";", "if", "(", "attrConfig", "&&", "attrConfig", ".", "getter", ")", "{", "val", "=", "attrConfig", ".", "getter", ".", "call", "(", "this", ")", ";", "}", "else", "if", "(", "Y_Node", ".", "re_aria", ".", "test", "(", "attr", ")", ")", "{", "val", "=", "this", ".", "_node", ".", "getAttribute", "(", "attr", ",", "2", ")", ";", "}", "else", "{", "val", "=", "Y_Node", ".", "DEFAULT_GETTER", ".", "apply", "(", "this", ",", "arguments", ")", ";", "}", "return", "val", ";", "}" ]

[ "Helper", "method", "for", "get", "." ]

[ "function", "(", "attrMap", ")", "{", "if", "(", "this", ".", "_setAttrs", ")", "{", "// use Attribute imple", "this", ".", "_setAttrs", "(", "attrMap", ")", ";", "}", "else", "{", "// use setters inline", "Y", ".", "Object", ".", "each", "(", "attrMap", ",", "function", "(", "v", ",", "n", ")", "{", "this", ".", "set", "(", "n", ",", "v", ")", ";", "}", ",", "this", ")", ";", "}", "return", "this", ";", "}" ]

[ "Sets", "multiple", "attributes", "." ]

[ "function", "(", "attrs", ")", "{", "var", "ret", "=", "{", "}", ";", "if", "(", "this", ".", "_getAttrs", ")", "{", "// use Attribute imple", "this", ".", "_getAttrs", "(", "attrs", ")", ";", "}", "else", "{", "// use setters inline", "Y", ".", "Array", ".", "each", "(", "attrs", ",", "function", "(", "v", ",", "n", ")", "{", "ret", "[", "v", "]", "=", "this", ".", "get", "(", "v", ")", ";", "}", ",", "this", ")", ";", "}", "return", "ret", ";", "}" ]

[ "Returns", "an", "object", "containing", "the", "values", "for", "the", "requested", "attributes", "." ]

[ "function", "(", "doc", ")", "{", "var", "node", "=", "this", ".", "_node", ";", "doc", "=", "(", "doc", ")", "?", "doc", ".", "_node", "||", "doc", ":", "node", "[", "OWNER_DOCUMENT", "]", ";", "if", "(", "doc", ".", "documentElement", ")", "{", "return", "Y_DOM", ".", "contains", "(", "doc", ".", "documentElement", ",", "node", ")", ";", "}", "}" ]

[ "Determines", "whether", "the", "node", "is", "appended", "to", "the", "document", "." ]

[ "function", "(", "fn", ",", "testSelf", ")", "{", "return", "Y", ".", "one", "(", "Y_DOM", ".", "ancestor", "(", "this", ".", "_node", ",", "_wrapFn", "(", "fn", ")", ",", "testSelf", ")", ")", ";", "}" ]

[ "Returns", "the", "nearest", "ancestor", "that", "passes", "the", "test", "applied", "by", "supplied", "boolean", "method", "." ]

[ "function", "(", "fn", ",", "all", ")", "{", "return", "Y", ".", "one", "(", "Y_DOM", ".", "elementByAxis", "(", "this", ".", "_node", ",", "'previousSibling'", ",", "_wrapFn", "(", "fn", ")", ",", "all", ")", ")", ";", "}" ]

[ "Returns", "the", "previous", "matching", "sibling", ".", "Returns", "the", "nearest", "element", "node", "sibling", "if", "no", "method", "provided", "." ]

[ "function", "(", "content", ",", "where", ")", "{", "var", "node", "=", "this", ".", "_node", ";", "if", "(", "content", ")", "{", "if", "(", "typeof", "where", "===", "'number'", ")", "{", "// allow index", "where", "=", "this", ".", "_node", ".", "childNodes", "[", "where", "]", ";", "}", "else", "if", "(", "where", "&&", "where", ".", "_node", ")", "{", "// Node", "where", "=", "where", ".", "_node", ";", "}", "if", "(", "typeof", "content", "!==", "'string'", ")", "{", "// allow Node or NodeList/Array instances", "if", "(", "content", ".", "_node", ")", "{", "// Node", "content", "=", "content", ".", "_node", ";", "}", "else", "if", "(", "content", ".", "_nodes", "||", "(", "!", "content", ".", "nodeType", "&&", "content", ".", "length", ")", ")", "{", "// NodeList or Array", "content", "=", "Y", ".", "all", "(", "content", ")", ";", "Y", ".", "each", "(", "content", ".", "_nodes", ",", "function", "(", "n", ")", "{", "Y_DOM", ".", "addHTML", "(", "node", ",", "n", ",", "where", ")", ";", "}", ")", ";", "return", "this", ";", "// NOTE: early return", "}", "}", "Y_DOM", ".", "addHTML", "(", "node", ",", "content", ",", "where", ")", ";", "}", "else", "{", "}", "return", "this", ";", "}" ]

[ "Inserts", "the", "content", "before", "the", "reference", "node", "." ]

[ "function", "(", "content", ")", "{", "if", "(", "content", ")", "{", "if", "(", "content", ".", "_node", ")", "{", "// map to DOMNode", "content", "=", "content", ".", "_node", ";", "}", "else", "if", "(", "content", ".", "_nodes", ")", "{", "// convert DOMNodeList to documentFragment", "content", "=", "Y_DOM", ".", "_nl2frag", "(", "content", ".", "_nodes", ")", ";", "}", "}", "Y_DOM", ".", "addHTML", "(", "this", ".", "_node", ",", "content", ",", "'replace'", ")", ";", "return", "this", ";", "}" ]

[ "Replaces", "the", "node", "s", "current", "content", "with", "the", "content", "." ]

[ "function", "(", "fn", ",", "context", ")", "{", "var", "instance", "=", "this", ";", "return", "Y", ".", "Array", ".", "some", "(", "this", ".", "_nodes", ",", "function", "(", "node", ",", "index", ")", "{", "node", "=", "Y", ".", "one", "(", "node", ")", ";", "context", "=", "context", "||", "node", ";", "return", "fn", ".", "call", "(", "context", ",", "node", ",", "index", ",", "instance", ")", ";", "}", ")", ";", "}" ]

[ "Executes", "the", "function", "once", "for", "each", "node", "until", "a", "true", "value", "is", "returned", "." ]

[ "function", "(", ")", "{", "var", "doc", ",", "nodes", "=", "this", ".", "_nodes", ",", "query", "=", "this", ".", "_query", ",", "root", "=", "this", ".", "_queryRoot", ";", "if", "(", "query", ")", "{", "if", "(", "!", "root", ")", "{", "if", "(", "nodes", "&&", "nodes", "[", "0", "]", "&&", "nodes", "[", "0", "]", ".", "ownerDocument", ")", "{", "root", "=", "nodes", "[", "0", "]", ".", "ownerDocument", ";", "}", "}", "this", ".", "_nodes", "=", "Y", ".", "Selector", ".", "query", "(", "query", ",", "root", ")", ";", "}", "return", "this", ";", "}" ]

[ "Reruns", "the", "initial", "query", "when", "created", "using", "a", "selector", "query" ]

[ "function", "(", "type", ",", "fn", ",", "context", ")", "{", "return", "Y", ".", "on", ".", "apply", "(", "Y", ",", "this", ".", "_prepEvtArgs", ".", "apply", "(", "this", ",", "arguments", ")", ")", ";", "}" ]

[ "Applies", "an", "event", "listener", "to", "each", "Node", "bound", "to", "the", "NodeList", "." ]

[ "function", "(", "s", ",", "reviver", ")", "{", "// Replace certain Unicode characters that are otherwise handled", "// incorrectly by some browser implementations.", "// NOTE: This modifies the input if such characters are found!", "s", "=", "s", ".", "replace", "(", "_UNICODE_EXCEPTIONS", ",", "_escapeException", ")", ";", "// Test for any remaining invalid characters", "if", "(", "!", "_UNSAFE", ".", "test", "(", "s", ".", "replace", "(", "_ESCAPES", ",", "'@'", ")", ".", "replace", "(", "_VALUES", ",", "']'", ")", ".", "replace", "(", "_BRACKETS", ",", "''", ")", ")", ")", "{", "// Eval the text into a JavaScript data structure, apply any", "// reviver function, and return", "return", "_revive", "(", "_eval", "(", "'('", "+", "s", "+", "')'", ")", ",", "reviver", ")", ";", "}", "throw", "new", "SyntaxError", "(", "'JSON.parse'", ")", ";", "}" ]

[ "Alias", "to", "native", "browser", "implementation", "of", "the", "JSON", "object", "if", "available", "." ]

[ "function", "(", "s", ")", "{", "return", "s", ".", "replace", "(", "re_NewLine", ",", "NewLine", ")", ".", "replace", "(", "re_quot", ",", "quot", ")", ".", "replace", "(", "re_apos", ",", "apos", ")", ".", "replace", "(", "re_acute", ",", "acute", ")", ".", "replace", "(", "re_sbquo", ",", "sbquo", ")", ".", "replace", "(", "re_bdquo", ",", "bdquo", ")", ".", "replace", "(", "re_hellip", ",", "hellip", ")", ".", "replace", "(", "re_dagger", ",", "dagger", ")", ".", "replace", "(", "re_Dagger", ",", "Dagger", ")", ".", "replace", "(", "re_lsquo", ",", "lsquo", ")", ".", "replace", "(", "re_rsquo", ",", "rsquo", ")", ".", "replace", "(", "re_ldquo", ",", "ldquo", ")", ".", "replace", "(", "re_rdquo", ",", "rdquo", ")", ".", "replace", "(", "re_bull", ",", "bull", ")", ".", "replace", "(", "re_ndash", ",", "ndash", ")", ".", "replace", "(", "re_mdash", ",", "mdash", ")", ".", "replace", "(", "re_copy", ",", "copyright_mark", ")", ".", "replace", "(", "re_nbsp", ",", "nbsp", ")", ".", "replace", "(", "re_laquo", ",", "laquo", ")", ".", "replace", "(", "re_raquo", ",", "raquo", ")", ";", "}" ]

[ "HTML_UTIL", "5", "entity", "and", "utility", "methods" ]

[ "function", "(", "options", ")", "{", "poolId", "++", ";", "return", "new", "Pool", "(", "options", ".", "name", "?", "options", ".", "name", "+", "' (pool #'", "+", "poolId", "+", "')'", ":", "'pool #'", "+", "poolId", ",", "options", ".", "factory", ",", "options", ".", "initialize", "||", "noop", ",", "options", ".", "firstAllocationNumber", "||", "20", ",", "options", ".", "allocationNumber", "||", "1", ")", ";", "}" ]

[ "Create", "an", "object", "pool" ]

[ "function", "RelayStream", "(", "option", ")", "{", "Stream", ".", "apply", "(", "this", ",", "arguments", ")", ";", "this", ".", "writable", "=", "true", ";", "this", ".", "readable", "=", "true", ";", "this", ".", "store", "=", "[", "]", ";", "this", ".", "paused", "=", "!", "!", "option", ".", "paused", ";", "this", ".", "closed", "=", "false", ";", "}" ]

[ "This", "constructor", "will", "simply", "relay", "data", "by", "purpose", "this", "do", "not", "support", ".", "end", "or", ".", "close" ]

[ "function", "validate", "(", "cmd", ",", "args", ",", "info", ")", "{", "info", "=", "info", "||", "{", "}", ";", "var", "conf", "=", "info", ".", "conf", "||", "{", "}", ",", "authrequired", "=", "typeof", "conf", ".", "requirepass", "===", "'string'", ",", "db", "=", "info", ".", "db", ",", "result", ";", "// handle quit command special case", "if", "(", "cmd", "===", "COMMANDS", ".", "QUIT", ")", "{", "// reply with an object that mimics succesful validation", "info", ".", "command", "=", "{", "cmd", ":", "cmd", ",", "args", ":", "args", ",", "def", ":", "Constants", ".", "MAP", ".", "quit", ",", "arity", ":", "true", "}", ";", "return", "info", ";", "// validate command is known", "}", "else", "{", "info", ".", "command", "=", "validators", ".", "command", "(", "cmd", ",", "args", ",", "info", ")", ";", "}", "// check args length (arity)", "info", ".", "command", ".", "arity", "=", "validators", ".", "arity", "(", "cmd", ",", "args", ",", "info", ")", ";", "// handle authentication requests", "if", "(", "cmd", "===", "COMMANDS", ".", "AUTH", ")", "{", "info", ".", "conn", ".", "authenticated", "=", "validators", ".", "auth", "(", "cmd", ",", "args", ",", "info", ")", ";", "// handle unauthenticated requests when auth is enabled", "}", "else", "if", "(", "authrequired", "&&", "!", "info", ".", "conn", ".", "authenticated", ")", "{", "throw", "AuthRequired", ";", "}", "// check operation on the correct type of value", "// this validation extracts keys, looks up the values", "// to determine the type of the existing value", "// the val array (or null) is assigned to the command", "// info object so that calling code may re-use it and", "// save looking up keys and values again where necessary", "info", ".", "command", ".", "value", "=", "validators", ".", "type", "(", "cmd", ",", "args", ",", "info", ")", ";", "return", "info", ";", "}" ]

[ "Performs", "complete", "validation", "for", "an", "incoming", "command", "." ]

[ "function", "indexOf", "(", "match", ")", "{", "var", "i", "=", "matches", ".", "length", ";", "while", "(", "i", "--", ")", "{", "if", "(", "matches", "[", "i", "]", "===", "match", ")", "{", "return", "i", ";", "}", "}", "return", "-", "1", ";", "}" ]

[ "Returns", "the", "index", "of", "a", "specific", "match", "object", "or", "-", "1", "if", "it", "isn", "t", "found", "." ]

[ "function", "filter", "(", "callback", ")", "{", "var", "filteredMatches", "=", "[", "]", ";", "each", "(", "function", "(", "match", ",", "i", ")", "{", "if", "(", "callback", "(", "match", ",", "i", ")", ")", "{", "filteredMatches", ".", "push", "(", "match", ")", ";", "}", "}", ")", ";", "matches", "=", "filteredMatches", ";", "/*jshint validthis:true*/", "return", "this", ";", "}" ]

[ "Filters", "the", "matches", ".", "If", "the", "callback", "returns", "true", "it", "stays", "if", "not", "it", "gets", "removed", "." ]

[ "function", "each", "(", "callback", ")", "{", "for", "(", "var", "i", "=", "0", ",", "l", "=", "matches", ".", "length", ";", "i", "<", "l", ";", "i", "++", ")", "{", "if", "(", "callback", "(", "matches", "[", "i", "]", ",", "i", ")", "===", "false", ")", "{", "break", ";", "}", "}", "/*jshint validthis:true*/", "return", "this", ";", "}" ]

[ "Executes", "the", "specified", "callback", "for", "each", "match", "." ]

[ "function", "find", "(", "regex", ",", "data", ")", "{", "if", "(", "text", "&&", "regex", ".", "global", ")", "{", "while", "(", "(", "m", "=", "regex", ".", "exec", "(", "text", ")", ")", ")", "{", "matches", ".", "push", "(", "createMatch", "(", "m", ",", "data", ")", ")", ";", "}", "}", "return", "this", ";", "}" ]

[ "Finds", "the", "specified", "regexp", "and", "adds", "them", "to", "the", "matches", "collection", "." ]

[ "function", "unwrap", "(", "match", ")", "{", "var", "i", ",", "elements", "=", "getWrappersByIndex", "(", "match", "?", "indexOf", "(", "match", ")", ":", "null", ")", ";", "i", "=", "elements", ".", "length", ";", "while", "(", "i", "--", ")", "{", "unwrapElement", "(", "elements", "[", "i", "]", ")", ";", "}", "return", "this", ";", "}" ]

[ "Unwraps", "the", "specified", "match", "object", "or", "all", "matches", "if", "unspecified", "." ]

[ "function", "add", "(", "start", ",", "length", ",", "data", ")", "{", "matches", ".", "push", "(", "{", "start", ":", "start", ",", "end", ":", "start", "+", "length", ",", "text", ":", "text", ".", "substr", "(", "start", ",", "length", ")", ",", "data", ":", "data", "}", ")", ";", "return", "this", ";", "}" ]

[ "Adds", "match", "the", "specified", "range", "for", "example", "a", "grammar", "line", "." ]

[ "function", "rangeFromMatch", "(", "match", ")", "{", "var", "wrappers", "=", "getWrappersByIndex", "(", "indexOf", "(", "match", ")", ")", ";", "var", "rng", "=", "editor", ".", "dom", ".", "createRng", "(", ")", ";", "rng", ".", "setStartBefore", "(", "wrappers", "[", "0", "]", ")", ";", "rng", ".", "setEndAfter", "(", "wrappers", "[", "wrappers", ".", "length", "-", "1", "]", ")", ";", "return", "rng", ";", "}" ]

[ "Returns", "a", "DOM", "range", "for", "the", "specified", "match", "." ]

[ "function", "replace", "(", "match", ",", "text", ")", "{", "var", "rng", "=", "rangeFromMatch", "(", "match", ")", ";", "rng", ".", "deleteContents", "(", ")", ";", "if", "(", "text", ".", "length", ">", "0", ")", "{", "rng", ".", "insertNode", "(", "editor", ".", "dom", ".", "doc", ".", "createTextNode", "(", "text", ")", ")", ";", "}", "return", "rng", ";", "}" ]

[ "Replaces", "the", "specified", "match", "with", "the", "specified", "text", "." ]

[ "function", "markErrors", "(", "data", ")", "{", "var", "suggestions", ";", "if", "(", "data", ".", "words", ")", "{", "hasDictionarySupport", "=", "!", "!", "data", ".", "dictionary", ";", "suggestions", "=", "data", ".", "words", ";", "}", "else", "{", "// Fallback to old format", "suggestions", "=", "data", ";", "}", "editor", ".", "setProgressState", "(", "false", ")", ";", "if", "(", "isEmpty", "(", "suggestions", ")", ")", "{", "var", "message", "=", "editor", ".", "translate", "(", "'No misspellings found.'", ")", ";", "editor", ".", "notificationManager", ".", "open", "(", "{", "text", ":", "message", ",", "type", ":", "'info'", "}", ")", ";", "started", "=", "false", ";", "return", ";", "}", "lastSuggestions", "=", "suggestions", ";", "getTextMatcher", "(", ")", ".", "find", "(", "getWordCharPattern", "(", ")", ")", ".", "filter", "(", "function", "(", "match", ")", "{", "return", "!", "!", "suggestions", "[", "match", ".", "text", "]", ";", "}", ")", ".", "wrap", "(", "function", "(", "match", ")", "{", "return", "editor", ".", "dom", ".", "create", "(", "'span'", ",", "{", "\"class\"", ":", "'mce-spellchecker-word'", ",", "\"data-mce-bogus\"", ":", "1", ",", "\"data-mce-word\"", ":", "match", ".", "text", "}", ")", ";", "}", ")", ";", "started", "=", "true", ";", "editor", ".", "fire", "(", "'SpellcheckStart'", ")", ";", "}" ]

[ "Find", "the", "specified", "words", "and", "marks", "them", ".", "It", "will", "also", "show", "suggestions", "for", "those", "words", "." ]

[ "function", "(", "filter", ",", "context", ")", "{", "var", "element", "=", "this", ",", "originalName", ",", "name", ";", "context", "=", "element", ".", "getFilterContext", "(", "context", ")", ";", "// Do not process elements with data-cke-processor attribute set to off.", "if", "(", "context", ".", "off", ")", "return", "true", ";", "// Filtering if it's the root node.", "if", "(", "!", "element", ".", "parent", ")", "filter", ".", "onRoot", "(", "context", ",", "element", ")", ";", "while", "(", "true", ")", "{", "originalName", "=", "element", ".", "name", ";", "if", "(", "!", "(", "name", "=", "filter", ".", "onElementName", "(", "context", ",", "originalName", ")", ")", ")", "{", "this", ".", "remove", "(", ")", ";", "return", "false", ";", "}", "element", ".", "name", "=", "name", ";", "if", "(", "!", "(", "element", "=", "filter", ".", "onElement", "(", "context", ",", "element", ")", ")", ")", "{", "this", ".", "remove", "(", ")", ";", "return", "false", ";", "}", "// New element has been returned - replace current one", "// and process it (stop processing this and return false, what", "// means that element has been removed).", "if", "(", "element", "!==", "this", ")", "{", "this", ".", "replaceWith", "(", "element", ")", ";", "return", "false", ";", "}", "// If name has been changed - continue loop, so in next iteration", "// filters for new name will be applied to this element.", "// If name hasn't been changed - stop.", "if", "(", "element", ".", "name", "==", "originalName", ")", "break", ";", "// If element has been replaced with something of a", "// different type, then make the replacement filter itself.", "if", "(", "element", ".", "type", "!=", "CKEDITOR", ".", "NODE_ELEMENT", ")", "{", "this", ".", "replaceWith", "(", "element", ")", ";", "return", "false", ";", "}", "// This indicate that the element has been dropped by", "// filter but not the children.", "if", "(", "!", "element", ".", "name", ")", "{", "this", ".", "replaceWithChildren", "(", ")", ";", "return", "false", ";", "}", "}", "var", "attributes", "=", "element", ".", "attributes", ",", "a", ",", "value", ",", "newAttrName", ";", "for", "(", "a", "in", "attributes", ")", "{", "newAttrName", "=", "a", ";", "value", "=", "attributes", "[", "a", "]", ";", "// Loop until name isn't modified.", "// A little bit senseless, but IE would do that anyway", "// because it iterates with for-in loop even over properties", "// created during its run.", "while", "(", "true", ")", "{", "if", "(", "!", "(", "newAttrName", "=", "filter", ".", "onAttributeName", "(", "context", ",", "a", ")", ")", ")", "{", "delete", "attributes", "[", "a", "]", ";", "break", ";", "}", "else", "if", "(", "newAttrName", "!=", "a", ")", "{", "delete", "attributes", "[", "a", "]", ";", "a", "=", "newAttrName", ";", "continue", ";", "}", "else", "{", "break", ";", "}", "}", "if", "(", "newAttrName", ")", "{", "if", "(", "(", "value", "=", "filter", ".", "onAttribute", "(", "context", ",", "element", ",", "newAttrName", ",", "value", ")", ")", "===", "false", ")", "delete", "attributes", "[", "newAttrName", "]", ";", "else", "attributes", "[", "newAttrName", "]", "=", "value", ";", "}", "}", "if", "(", "!", "element", ".", "isEmpty", ")", "this", ".", "filterChildren", "(", "filter", ",", "false", ",", "context", ")", ";", "return", "true", ";", "}" ]

[ "Filters", "this", "element", "and", "its", "children", "with", "the", "given", "filter", "." ]

[ "function", "(", "writer", ",", "filter", ")", "{", "if", "(", "filter", ")", "this", ".", "filter", "(", "filter", ")", ";", "var", "name", "=", "this", ".", "name", ",", "attribsArray", "=", "[", "]", ",", "attributes", "=", "this", ".", "attributes", ",", "attrName", ",", "attr", ",", "i", ",", "l", ";", "// Open element tag.", "writer", ".", "openTag", "(", "name", ",", "attributes", ")", ";", "// Copy all attributes to an array.", "for", "(", "attrName", "in", "attributes", ")", "attribsArray", ".", "push", "(", "[", "attrName", ",", "attributes", "[", "attrName", "]", "]", ")", ";", "// Sort the attributes by name.", "if", "(", "writer", ".", "sortAttributes", ")", "attribsArray", ".", "sort", "(", "sortAttribs", ")", ";", "// Send the attributes.", "for", "(", "i", "=", "0", ",", "l", "=", "attribsArray", ".", "length", ";", "i", "<", "l", ";", "i", "++", ")", "{", "attr", "=", "attribsArray", "[", "i", "]", ";", "writer", ".", "attribute", "(", "attr", "[", "0", "]", ",", "attr", "[", "1", "]", ")", ";", "}", "// Close the tag.", "writer", ".", "openTagClose", "(", "name", ",", "this", ".", "isEmpty", ")", ";", "this", ".", "writeChildrenHtml", "(", "writer", ")", ";", "// Close the element.", "if", "(", "!", "this", ".", "isEmpty", ")", "writer", ".", "closeTag", "(", "name", ")", ";", "}" ]

[ "Writes", "the", "element", "HTML", "to", "the", "CKEDITOR", ".", "htmlWriter", "." ]

[ "function", "(", ")", "{", "var", "children", "=", "this", ".", "children", ";", "for", "(", "var", "i", "=", "children", ".", "length", ";", "i", ";", ")", "children", "[", "--", "i", "]", ".", "insertAfter", "(", "this", ")", ";", "this", ".", "remove", "(", ")", ";", "}" ]

[ "Replaces", "this", "element", "with", "its", "children", "." ]

[ "function", "(", "condition", ")", "{", "if", "(", "!", "condition", ")", "return", "this", ".", "children", ".", "length", "?", "this", ".", "children", "[", "0", "]", ":", "null", ";", "if", "(", "typeof", "condition", "!=", "'function'", ")", "condition", "=", "nameCondition", "(", "condition", ")", ";", "for", "(", "var", "i", "=", "0", ",", "l", "=", "this", ".", "children", ".", "length", ";", "i", "<", "l", ";", "++", "i", ")", "{", "if", "(", "condition", "(", "this", ".", "children", "[", "i", "]", ")", ")", "return", "this", ".", "children", "[", "i", "]", ";", "}", "return", "null", ";", "}" ]

[ "Gets", "this", "element", "s", "first", "child", ".", "If", "condition", "is", "given", "this", "method", "returns", "the", "first", "child", "which", "satisfies", "that", "condition", "." ]

[ "function", "(", "html", ")", "{", "var", "children", "=", "this", ".", "children", "=", "CKEDITOR", ".", "htmlParser", ".", "fragment", ".", "fromHtml", "(", "html", ")", ".", "children", ";", "for", "(", "var", "i", "=", "0", ",", "l", "=", "children", ".", "length", ";", "i", "<", "l", ";", "++", "i", ")", "children", "[", "i", "]", ".", "parent", "=", "this", ";", "}" ]

[ "Sets", "this", "element", "s", "inner", "HTML", "." ]

[ "function", "(", "index", ")", "{", "var", "cloneChildren", "=", "this", ".", "children", ".", "splice", "(", "index", ",", "this", ".", "children", ".", "length", "-", "index", ")", ",", "clone", "=", "this", ".", "clone", "(", ")", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "cloneChildren", ".", "length", ";", "++", "i", ")", "cloneChildren", "[", "i", "]", ".", "parent", "=", "clone", ";", "clone", ".", "children", "=", "cloneChildren", ";", "if", "(", "cloneChildren", "[", "0", "]", ")", "cloneChildren", "[", "0", "]", ".", "previous", "=", "null", ";", "if", "(", "index", ">", "0", ")", "this", ".", "children", "[", "index", "-", "1", "]", ".", "next", "=", "null", ";", "this", ".", "parent", ".", "add", "(", "clone", ",", "this", ".", "getIndex", "(", ")", "+", "1", ")", ";", "return", "clone", ";", "}" ]

[ "Splits", "this", "element", "at", "the", "given", "index", "." ]

[ "function", "(", "className", ")", "{", "var", "classes", "=", "this", ".", "attributes", "[", "'class'", "]", ";", "if", "(", "!", "classes", ")", "return", ";", "// We can safely assume that className won't break regexp.", "// http://stackoverflow.com/questions/448981/what-characters-are-valid-in-css-class-names", "classes", "=", "CKEDITOR", ".", "tools", ".", "trim", "(", "classes", ".", "replace", "(", "new", "RegExp", "(", "'(?:\\\\s+|^)'", "+", "className", "+", "'(?:\\\\s+|$)'", ")", ",", "' '", ")", ")", ";", "if", "(", "classes", ")", "this", ".", "attributes", "[", "'class'", "]", "=", "classes", ";", "else", "delete", "this", ".", "attributes", "[", "'class'", "]", ";", "}" ]

[ "Removes", "a", "class", "name", "from", "the", "list", "of", "classes", "." ]

[ "function", "(", "outname", ",", "imagedata", ")", "{", "var", "frames", "=", "[", "]", ";", "var", "animations", "=", "{", "}", ";", "// first pass: set up frame for each image, ensure an animation array is present", "imagedata", ".", "forEach", "(", "function", "(", "im", ")", "{", "var", "ox", "=", "Math", ".", "floor", "(", "im", ".", "width", "/", "2", ")", ";", "var", "oy", "=", "Math", ".", "floor", "(", "im", ".", "height", "/", "2", ")", ";", "im", ".", "frame", "=", "frames", ".", "length", ";", "frames", ".", "push", "(", "[", "im", ".", "x", ",", "im", ".", "y", ",", "im", ".", "width", ",", "im", ".", "height", ",", "0", ",", "im", ".", "ox", ",", "im", ".", "oy", "]", ")", ";", "if", "(", "!", "animations", "[", "im", ".", "animname", "]", ")", "{", "animations", "[", "im", ".", "animname", "]", "=", "{", "frames", ":", "[", "]", "}", ";", "}", "}", ")", ";", "// re-sort the images to frame order and then push their frame indices", "// into the respective arrays.", "imagedata", ".", "sort", "(", "function", "(", "a", ",", "b", ")", "{", "return", "a", ".", "animidx", "-", "b", ".", "animidx", ";", "}", ")", ";", "imagedata", ".", "forEach", "(", "function", "(", "im", ")", "{", "animations", "[", "im", ".", "animname", "]", ".", "frames", ".", "push", "(", "im", ".", "frame", ")", ";", "}", ")", ";", "// put all the data in its appropriate groups and JSONify", "var", "data", "=", "{", "frames", ":", "frames", ",", "animations", ":", "animations", ",", "images", ":", "[", "outname", "+", "\".png\"", "]", "}", ";", "return", "JSON", ".", "stringify", "(", "data", ",", "null", ",", "2", ")", ";", "}" ]

[ "format", "for", "CreateJS", "framework" ]

[ "function", "phaserShim", "(", "source", ")", "{", "this", ".", "cacheable", "&&", "this", ".", "cacheable", "(", ")", ";", "source", "=", "source", ".", "replace", "(", "/", "\"object\"==typeof exports", "/", ",", "'false'", ")", ".", "replace", "(", "/", "(var\\s+\\w+\\s*=\\s*)Phaser(\\s*\\|\\|\\s*\\{)", "/", ",", "'var PIXI = exports.PIXI; $1Phaser$2'", ")", ".", "replace", "(", "/", "typeof module !== 'undefined' && module\\.exports", "/", "g", ",", "\"false /* typeof module !== 'undefined' && module.exports */\"", ")", ".", "replace", "(", "/", "require\\('nw\\.gui'\\)", "/", "g", ",", "\"undefined /* require('nw.gui') */\"", ")", ".", "replace", "(", "/", "(p2\\.Body\\.prototype)", "/", ",", "'var Phaser = require(\"Phaser\").Phaser; var p2 = require(\"p2\"); $1'", ")", ";", "source", "=", "'var document = global.document;\\n\\n'", "+", "source", ";", "return", "source", ";", "}" ]

[ "phaser", "-", "webpack", "-", "loader" ]

[ "function", "(", "providerObject", ")", "{", "const", "fixedProviderObject", "=", "Object", ".", "assign", "(", "{", "}", ",", "providerObject", ")", ";", "const", "oldGetAccountsMethod", "=", "providerObject", ".", "getAccounts", ";", "// fix get accounts", "if", "(", "typeof", "fixedProviderObject", ".", "getAccounts", "!==", "'undefined'", ")", "{", "fixedProviderObject", ".", "getAccounts", "=", "function", "(", "getAccountsCallback", ")", "{", "const", "oldCallback", "=", "getAccountsCallback", ";", "// build fixed callback with lowercased accounts", "const", "fixedCallback", "=", "function", "(", "accountsError", ",", "accountsResult", ")", "{", "const", "fixedAccountsResult", "=", "accountsResult", ".", "slice", "(", "0", ")", ";", "// if no error, fixed result", "if", "(", "!", "accountsError", ")", "{", "fixedAccountsResult", ".", "map", "(", "function", "(", "item", ")", "{", "return", "String", "(", "item", ".", "toLowerCase", "(", ")", ")", ";", "}", ")", ";", "}", "// fire oldd callback with new fix", "oldCallback", "(", "accountsError", ",", "fixedAccountsResult", ")", ";", "}", "// fire get accounts method", "oldGetAccountsMethod", "(", "fixedCallback", ")", ";", "}", ";", "}", "// return fixed provider object", "return", "fixedProviderObject", ";", "}" ]

[ "fix", "getAccounts", "method" ]

[ "function", "(", "accountsError", ",", "accountsResult", ")", "{", "const", "fixedAccountsResult", "=", "accountsResult", ".", "slice", "(", "0", ")", ";", "// if no error, fixed result", "if", "(", "!", "accountsError", ")", "{", "fixedAccountsResult", ".", "map", "(", "function", "(", "item", ")", "{", "return", "String", "(", "item", ".", "toLowerCase", "(", ")", ")", ";", "}", ")", ";", "}", "// fire oldd callback with new fix", "oldCallback", "(", "accountsError", ",", "fixedAccountsResult", ")", ";", "}" ]

[ "build", "fixed", "callback", "with", "lowercased", "accounts" ]

[ "function", "(", "rawTx", ")", "{", "const", "rawTxMutation", "=", "Object", ".", "assign", "(", "{", "}", ",", "rawTx", ")", ";", "// fix rawTx gaslimit", "if", "(", "typeof", "rawTxMutation", ".", "gas", "!==", "'undefined'", ")", "{", "rawTxMutation", ".", "gasLimit", "=", "rawTxMutation", ".", "gas", ";", "delete", "rawTxMutation", ".", "gas", ";", "}", "// fix data by prefixing it with zero", "if", "(", "typeof", "rawTxMutation", ".", "data", "!==", "'undefined'", "&&", "rawTxMutation", ".", "data", ".", "slice", "(", "0", ",", "2", ")", "!==", "'0x'", ")", "{", "rawTxMutation", ".", "data", "=", "'0x'", "+", "rawTxMutation", ".", "data", ";", "}", "// return new mutated raw tx object", "return", "rawTxMutation", ";", "}" ]

[ "fix", "ethereumjs", "-", "tx", "rawTx", "object" ]

[ "function", "(", "providerObject", ")", "{", "const", "fixedProviderObject", "=", "Object", ".", "assign", "(", "{", "}", ",", "providerObject", ")", ";", "// object has signTransaction", "if", "(", "typeof", "fixedProviderObject", ".", "signTransaction", "!==", "'undefined'", ")", "{", "// store old sign transaction method", "const", "oldSignTransactionMethod", "=", "fixedProviderObject", ".", "signTransaction", ";", "// build new provider object signTransaciton method", "fixedProviderObject", ".", "signTransaction", "=", "function", "(", "rawTx", ",", "cb", ")", "{", "// fire old callback", "oldSignTransactionMethod", "(", "fixEthereumJSTxObject", "(", "rawTx", ")", ",", "cb", ")", ";", "}", ";", "}", "// return fixed provider object", "return", "fixedProviderObject", ";", "}" ]

[ "fix", "signTransaction", "method", "with", "rawTx", "fix" ]

[ "function", "(", "xmlString", ")", "{", "var", "error", ",", "parser", ",", "xmlDoc", ";", "if", "(", "(", "typeof", "Ti", "!==", "\"undefined\"", "&&", "Ti", "!==", "null", ")", "&&", "Ti", ".", "XML", ")", "{", "try", "{", "xmlDoc", "=", "Ti", ".", "XML", ".", "parseString", "(", "xmlString", ")", ";", "}", "catch", "(", "_error", ")", "{", "error", "=", "_error", ";", "xmlDoc", "=", "null", ";", "}", "return", "xmlDoc", ";", "}", "else", "if", "(", "window", ".", "DOMParser", "!=", "null", ")", "{", "try", "{", "parser", "=", "new", "window", ".", "DOMParser", "(", ")", ";", "xmlDoc", "=", "parser", ".", "parseFromString", "(", "xmlString", ",", "\"text/xml\"", ")", ";", "}", "catch", "(", "_error", ")", "{", "error", "=", "_error", ";", "xmlDoc", "=", "null", ";", "}", "return", "xmlDoc", ";", "}", "else", "if", "(", "window", ".", "ActiveXObject", "&&", "window", ".", "GetObject", ")", "{", "xmlDoc", "=", "new", "ActiveXObject", "(", "\"Microsoft.XMLDOM\"", ")", ";", "xmlDoc", ".", "async", "=", "\"false\"", ";", "try", "{", "xmlDoc", ".", "loadXML", "(", "xmlString", ")", ";", "}", "catch", "(", "_error", ")", "{", "error", "=", "_error", ";", "xmlDoc", "=", "null", ";", "}", "return", "xmlDoc", ";", "}", "else", "{", "throw", "new", "Error", "(", "\"No XML parser available\"", ")", ";", "}", "}" ]

[ "Turns", "the", "provided", "XML", "string", "into", "an", "XML", "DOM", "Document", "using", "whatever", "native", "means", "of", "doing", "so", "is", "available" ]

[ "function", "(", "xmlNode", ")", "{", "var", "noNativeXml", ",", "noXMLSerializer", ";", "if", "(", "(", "typeof", "Ti", "!==", "\"undefined\"", "&&", "Ti", "!==", "null", ")", "&&", "Ti", ".", "XML", ")", "{", "return", "Ti", ".", "XML", ".", "serializeToString", "(", "xmlNode", ")", ";", "}", "else", "{", "try", "{", "return", "(", "new", "XMLSerializer", "(", ")", ")", ".", "serializeToString", "(", "xmlNode", ")", ";", "}", "catch", "(", "_error", ")", "{", "noXMLSerializer", "=", "_error", ";", "try", "{", "return", "xmlNode", ".", "xml", ";", "}", "catch", "(", "_error", ")", "{", "noNativeXml", "=", "_error", ";", "throw", "new", "Error", "(", "\"No XML serialization support\"", ")", ";", "}", "}", "}", "}" ]

[ "Turns", "the", "provided", "XML", "DOM", "Node", "into", "an", "XML", "string", "using", "whatever", "native", "means", "of", "doing", "so", "is", "available" ]

[ "function", "(", "space", ",", "type", ",", "path", ",", "value", ",", "index", ")", "{", "// console.log('context.notifyUpstream : ', space, type, path, value, index);", "for", "(", "var", "i", "=", "0", ",", "len", "=", "space", ".", "_upstreams", ".", "length", ";", "i", "<", "len", ";", "++", "i", ")", "{", "var", "upstream", "=", "space", ".", "_upstreams", "[", "i", "]", ";", "if", "(", "!", "upstream", ")", "{", "// maybe it's because upstreams length has change so update it", "// (probably a (or more) previous listener has removed some listeners through cascade)", "len", "=", "space", ".", "_upstreams", ".", "length", ";", "continue", ";", "}", "// path is local to notified node. value is the modified value. index is the one from modification point.", "upstream", ".", "call", "(", "this", ",", "value", ",", "type", ",", "path", ",", "index", ")", ";", "}", "}" ]

[ "notification", "from", "root", "to", "modification", "point", ".", "Normaly", "for", "internal", "use", "." ]

[ "function", "random", "(", "seed", ")", "{", "/**\n * Creates a subgenerator from the current one\n *\n * @param {string} key Key of the subgenerator\n * @param {...number} params Parameters affecting the subgenerator's seed\n */", "function", "subgen", "(", "key", ",", "...", "params", ")", "{", "return", "random", "(", "createSeed", "(", "[", "...", "seed", ",", "keygen", "(", "key", ")", ",", "...", "params", "]", ",", "seed", ".", "length", ")", ")", "}", "/**\n * Retrieves a value from the random generator\n *\n * **Warning:** keys are cached indefinitely, keep them constant\n *\n * @param {string} key Key of the random value\n * @param {...number} params Parameters affecting the value\n */", "function", "value", "(", "key", ",", "...", "params", ")", "{", "return", "murmur", "(", "[", "...", "seed", ",", "keygen", "(", "key", ")", ",", "...", "params", "]", ")", "}", "return", "{", "seed", ",", "subgen", ",", "value", ",", "util", "}", "}" ]

[ "Creates", "a", "deterministic", "random", "generator" ]

[ "function", "subgen", "(", "key", ",", "...", "params", ")", "{", "return", "random", "(", "createSeed", "(", "[", "...", "seed", ",", "keygen", "(", "key", ")", ",", "...", "params", "]", ",", "seed", ".", "length", ")", ")", "}" ]

[ "Creates", "a", "subgenerator", "from", "the", "current", "one" ]

[ "function", "logout", "(", "mongoClient", ",", "dbName", ",", "callback", ")", "{", "mongoClient", ".", "topology", ".", "logout", "(", "dbName", ",", "err", "=>", "{", "if", "(", "err", ")", "return", "callback", "(", "err", ")", ";", "callback", "(", "null", ",", "true", ")", ";", "}", ")", ";", "}" ]

[ "Logout", "user", "from", "server", "fire", "off", "on", "all", "connections", "and", "remove", "all", "auth", "info", "." ]

[ "function", "validOptions", "(", "options", ")", "{", "const", "_validOptions", "=", "validOptionNames", ".", "concat", "(", "legacyOptionNames", ")", ";", "for", "(", "const", "name", "in", "options", ")", "{", "if", "(", "ignoreOptionNames", ".", "indexOf", "(", "name", ")", "!==", "-", "1", ")", "{", "continue", ";", "}", "if", "(", "_validOptions", ".", "indexOf", "(", "name", ")", "===", "-", "1", "&&", "options", ".", "validateOptions", ")", "{", "return", "new", "MongoError", "(", "`", "${", "name", "}", "`", ")", ";", "}", "else", "if", "(", "_validOptions", ".", "indexOf", "(", "name", ")", "===", "-", "1", ")", "{", "console", ".", "warn", "(", "`", "${", "name", "}", "`", ")", ";", "}", "if", "(", "legacyOptionNames", ".", "indexOf", "(", "name", ")", "!==", "-", "1", ")", "{", "console", ".", "warn", "(", "`", "`", "+", "`", "${", "validOptionNames", "}", "`", ")", ";", "}", "}", "}" ]

[ "Validate", "options", "object" ]

[ "function", "Converter", "(", ")", "{", "// Validate arguments", "if", "(", "arguments", ".", "length", "===", "1", ")", "{", "this", ".", "_bl", "=", "2", ";", "if", "(", "typeof", "arguments", "[", "0", "]", "!==", "\"function\"", ")", "throw", "new", "TypeError", "(", "\"Converter requires at least a callback function\"", ")", ";", "else", "this", ".", "_fx", "=", "arguments", "[", "0", "]", ";", "}", "else", "if", "(", "arguments", ".", "length", ">=", "2", ")", "{", "this", ".", "_bl", "=", "arguments", "[", "0", "]", ";", "if", "(", "this", ".", "_bl", "!==", "1", "&&", "this", ".", "_bl", "!==", "2", "&&", "this", ".", "_bl", "!==", "4", ")", "throw", "new", "TypeError", "(", "\"Prefix length must be 1, 2 or 4\"", ")", ";", "if", "(", "typeof", "arguments", "[", "1", "]", "!==", "\"function\"", ")", "throw", "new", "TypeError", "(", "\"Converter requires a callback function\"", ")", ";", "else", "this", ".", "_fx", "=", "arguments", "[", "1", "]", ";", "}", "else", "{", "throw", "new", "Error", "(", "\"cannot construct a converter without a callback\"", ")", ";", "}", "this", ".", "flush", "(", ")", ";", "}" ]

[ "Takes", "in", "a", "series", "of", "Buffers", "and", "calls", "back", "whenever", "a", "fixed", "-", "length", "message", "has", "been", "completely", "processed", "." ]

[ "function", "getCommonActions", "(", "device", ")", "{", "const", "actions", "=", "[", "]", "actions", ".", "push", "(", "new", "BackAction", "(", "device", ")", ")", "actions", ".", "push", "(", "new", "HomeAction", "(", "device", ")", ")", "actions", ".", "push", "(", "new", "MenuAction", "(", "device", ")", ")", "actions", ".", "push", "(", ")", "return", "actions", "}" ]

[ "back", "home", "menu", "actions" ]

[ "function", "mutation", "(", "target", ",", "handler", ")", "{", "target", ".", "addEventListener", "(", "\"mutation\"", ",", "function", "(", "evt", ")", "{", "handler", ".", "call", "(", "this", ",", "this", ",", "evt", ".", "mutations", ")", ";", "}", ")", ";", "}" ]

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

[ "function", "Request", "(", "reqBytes", ")", "{", "var", "parsed", ";", "var", "err", "try", "{", "parsed", "=", "types", ".", "Request", ".", "decode", "(", "reqBytes", ")", ";", "}", "catch", "(", "e", ")", "{", "err", "=", "e", ";", "}", "//Check for request errors here", "if", "(", "err", ")", "{", "this", ".", "BadRequest", "=", "true", ";", "this", ".", "errCode", "=", "types", ".", "CodeType", ".", "EncodingError", ";", "this", ".", "errMsg", "=", "\"The request failed to be decoded\"", "}", "else", "if", "(", "!", "types", ".", "methodLookup", "[", "parsed", ".", "type", "]", ")", "{", "//Request type not recognized", "//Make a request object for the error", "this", ".", "BadRequest", "=", "true", ";", "this", ".", "errCode", "=", "types", ".", "CodeType", ".", "UnknownRequest", ";", "this", ".", "errMsg", "=", "\"The request type was not understood\"", "}", "else", "{", "this", ".", "BadRequest", "=", "false", ";", "this", ".", "type", "=", "parsed", ".", "type", ";", "this", ".", "method", "=", "types", ".", "methodLookup", "[", "this", ".", "type", "]", ";", "this", ".", "data", "=", "parsed", ".", "data", ".", "buffer", ".", "slice", "(", "parsed", ".", "data", ".", "offset", ")", ";", "this", ".", "dataLength", "=", "parsed", ".", "data", ".", "limit", "-", "parsed", ".", "data", ".", "offset", ";", "this", ".", "dataLittle", "=", "parsed", ".", "data", ".", "littleEndian", ";", "this", ".", "key", "=", "parsed", ".", "key", ";", "this", ".", "value", "=", "parsed", ".", "value", ";", "}", "}" ]

[ "The", "Request", "object", "unlike", "in", "http", "requests", "is", "static", "So", "this", "stream", "is", "built", "to", "return", "it", "rather", "then", "the", "standard", "buffer", ".", "this", "means", "any", "consumer", "of", "this", "stream", "would", "need", "to", "take", "account", "of", "this", "fact" ]

[ "function", "fire", "(", "event", ",", "$el", ",", "evt", ")", "{", "var", "handler", "=", "$el", ".", "data", "(", "'dragon-opts'", ")", "[", "event", "]", ";", "// Patch the proxied Event Object", "evt", ".", "target", "=", "$el", "[", "0", "]", ";", "if", "(", "handler", ")", "{", "handler", "(", "evt", ")", ";", "}", "$el", ".", "trigger", "(", "event", ")", ";", "}" ]

[ "Yep", "you", "only", "get", "to", "bind", "one", "event", "handler", ".", "Much", "faster", "this", "way", "." ]

[ "function", "ComponentModel", "(", "key", ",", "impl", ",", "cfg", ")", "{", "this", ".", "key", "=", "key", "/**\n * @property {Any} impl The implementation to use for `resolve`\n * */", "this", ".", "impl", "=", "impl", "this", ".", "_cfg", "=", "cfg", "||", "{", "}", "/**\n * @property {Array} inject The {String} dependencies array a service may declare\n * */", "this", ".", "inject", "=", "(", "this", ".", "impl", ".", "inject", "||", "[", "]", ")", "/**\n * @property {String} initializable The method to invoke on an resolved service just after resolution, but before returning\n * injecting any dependencies found on that method\n * */", "this", ".", "initializable", "=", "(", "this", ".", "impl", ".", "initializable", "||", "false", ")", "/**\n * @property {String} startable The method to invoke on an resolved services when started. Usually during an app bootstrap.\n * */", "this", ".", "startable", "=", "(", "this", ".", "impl", ".", "startable", "||", "false", ")", "}" ]

[ "Describes", "the", "model", "for", "resolving", "a", "service" ]

[ "function", "fetchLogs", "(", "root", ",", "msg", ",", "callback", ")", "{", "const", "number", "=", "msg", ".", "number", ";", "const", "logfile", "=", "msg", ".", "logfile", ";", "const", "serverId", "=", "msg", ".", "serverId", ";", "const", "filePath", "=", "path", ".", "join", "(", "root", ",", "getLogFileName", "(", "logfile", ",", "serverId", ")", ")", ";", "const", "endLogs", "=", "[", "]", ";", "exec", "(", "`", "${", "number", "}", "${", "filePath", "}", "`", ",", "(", "error", ",", "output", ")", "=>", "{", "const", "endOut", "=", "[", "]", ";", "output", "=", "output", ".", "replace", "(", "/", "^\\s+|\\s+$", "/", "g", ",", "''", ")", ".", "split", "(", "/", "\\s+", "/", ")", ";", "for", "(", "let", "i", "=", "5", ";", "i", "<", "output", ".", "length", ";", "i", "+=", "6", ")", "{", "endOut", ".", "push", "(", "output", "[", "i", "]", ")", ";", "}", "const", "endLength", "=", "endOut", ".", "length", ";", "for", "(", "let", "j", "=", "0", ";", "j", "<", "endLength", ";", "j", "++", ")", "{", "const", "map", "=", "{", "}", ";", "let", "json", ";", "try", "{", "json", "=", "JSON", ".", "parse", "(", "endOut", "[", "j", "]", ")", ";", "}", "catch", "(", "e", ")", "{", "logger", ".", "error", "(", "`", "${", "e", "}", "`", ")", ";", "continue", ";", "// eslint-disable-line", "}", "map", ".", "time", "=", "json", ".", "time", ";", "map", ".", "route", "=", "json", ".", "route", "||", "json", ".", "service", ";", "map", ".", "serverId", "=", "serverId", ";", "map", ".", "timeUsed", "=", "json", ".", "timeUsed", ";", "map", ".", "params", "=", "endOut", "[", "j", "]", ";", "endLogs", ".", "push", "(", "map", ")", ";", "}", "callback", "(", "{", "logfile", ":", "logfile", ",", "dataArray", ":", "endLogs", "}", ")", ";", "}", ")", ";", "}" ]

[ "get", "the", "latest", "logs" ]

[ "function", "(", "parser", ")", "{", "return", "highland", ".", "map", "(", "function", "(", "item", ")", "{", "if", "(", "_", ".", "isFunction", "(", "parser", ")", ")", "{", "return", "parser", "(", "item", ")", ";", "}", "if", "(", "_", ".", "isObject", "(", "parser", ")", "&&", "(", "parser", ".", "parse", "!=", "null", ")", ")", "{", "return", "parser", ".", "parse", "(", "item", ")", ";", "}", "return", "item", ";", "}", ")", ";", "}" ]

[ "Builder", ";", "returns", "a", "function", "which", "can", "be", "used", "to", "map", "a", "stream", "with", "a", "given", "parser", "." ]

[ "function", "(", "done", ")", "{", "var", "p", ",", "parser", ",", "stream", ",", "_i", ",", "_len", ";", "parser", "=", "this", ".", "parser", "(", ")", ";", "stream", "=", "highland", "(", "this", ".", "source", "(", ")", ")", ";", "if", "(", "_", ".", "isArray", "(", "parser", ")", ")", "{", "for", "(", "_i", "=", "0", ",", "_len", "=", "parser", ".", "length", ";", "_i", "<", "_len", ";", "_i", "++", ")", "{", "p", "=", "parser", "[", "_i", "]", ";", "stream", "=", "this", ".", "_mapWith", "(", "p", ")", "(", "stream", ")", ".", "flatten", "(", ")", ".", "compact", "(", ")", ";", "}", "}", "else", "{", "stream", "=", "this", ".", "_mapWith", "(", "parser", ")", "(", "stream", ")", ".", "flatten", "(", ")", ".", "compact", "(", ")", ";", "}", "stream", "=", "stream", ".", "reduce", "(", "{", "}", ",", "_", ".", "merge", ")", ";", "if", "(", "done", "==", "null", ")", "{", "return", "stream", ";", "}", "stream", ".", "pull", "(", "done", ")", ";", "return", "this", ";", "}" ]

[ "Loads", "all", "the", "sources", "and", "parses", "with", "a", "given", "parser", "and", "merges", "the", "results", "together", "." ]

[ "function", "mergeInto", "(", "target", ",", "source", ")", "{", "var", "a", "=", "target", ";", "var", "b", "=", "source", ";", "if", "(", "a", "&&", "b", ")", "{", "for", "(", "var", "key", "in", "b", ")", "{", "if", "(", "!", "(", "key", "in", "a", ")", ")", "{", "continue", ";", "}", "if", "(", "typeof", "b", "[", "key", "]", "===", "'object'", "&&", "!", "Array", ".", "isArray", "(", "b", "[", "key", "]", ")", "&&", "b", "[", "key", "]", "!==", "null", ")", "{", "mergeInto", "(", "a", "[", "key", "]", ",", "b", "[", "key", "]", ")", ";", "}", "else", "{", "a", "[", "key", "]", "=", "b", "[", "key", "]", ";", "}", "}", "}", "return", "a", ";", "}" ]

[ "Merges", "properties", "from", "source", "into", "target", ".", "target", "will", "be", "modified", "as", "a", "result", "of", "this", "function", "." ]

[ "function", "tryWatch", "(", "target", ",", "callback", ")", "{", "if", "(", "!", "target", ")", "{", "return", "logger", ".", "halt", "(", "'invalid watch target'", ")", "}", "if", "(", "!", "callback", "||", "typeof", "callback", "!==", "'function'", ")", "{", "return", "logger", ".", "halt", "(", "'invalid watch callback'", ")", "}", "return", "fs", ".", "watch", "(", "target", ",", "{", "persistent", ":", "true", ",", "recursive", ":", "true", "}", ",", "function", "(", "e", ",", "file", ")", "{", "// todo: exact watch", "callback", "(", "e", ",", "file", ")", "}", ")", "}" ]

[ "try", "to", "watch", "with", "custom", "callback" ]

[ "function", "getBabelConfig", "(", "env", ")", "{", "var", "babelrcPath", "=", "path", ".", "join", "(", "__dirname", ",", "'.babelrc'", ")", "var", "babelrc", "=", "JSON", ".", "parse", "(", "fs", ".", "readFileSync", "(", "babelrcPath", ")", ")", "babelrc", ".", "presets", "=", "resolve", "(", "babelrc", ".", "presets", ".", "map", "(", "preset", "=>", "'babel-preset-'", "+", "preset", ")", ")", "if", "(", "!", "babelrc", ".", "plugins", ")", "babelrc", ".", "plugins", "=", "[", "]", "return", "babelrc", "}" ]

[ "get", "babel", "config" ]

[ "function", "isNested", "(", "obj", ")", "{", "if", "(", "getType", "(", "obj", ")", "===", "'object'", ")", "{", "for", "(", "let", "tag", "in", "obj", ")", "{", "if", "(", "tag", "!=", "TEXT", "&&", "!", "ATTRTAG", ".", "test", "(", "tag", ")", ")", "{", "return", "true", ";", "}", "}", "}", "}" ]

[ "test", "if", "object", "contains", "nested", "elements" ]

[ "function", "getAttributes", "(", "obj", ")", "{", "let", "attrString", "=", "''", ";", "let", "attrArray", "=", "Object", ".", "keys", "(", "obj", ")", ";", "for", "(", "let", "tag", "of", "attrArray", ")", "{", "if", "(", "tag", "!=", "ATTR", "&&", "ATTRTAG", ".", "test", "(", "tag", ")", ")", "{", "attrString", "+=", "`", "${", "tag", ".", "replace", "(", "'_'", ",", "''", ")", "}", "${", "obj", "[", "tag", "]", "}", "`", ";", "}", "}", "if", "(", "ATTR", "in", "obj", ")", "{", "attrString", "+=", "' '", "+", "obj", "[", "ATTR", "]", ";", "}", "return", "attrString", ";", "}" ]

[ "return", "attribute", "string" ]

[ "function", "getType", "(", "obj", ")", "{", "let", "typeStr", "=", "typeof", "(", "obj", ")", ";", "if", "(", "obj", ")", "{", "return", "Array", ".", "isArray", "(", "obj", ")", "?", "'array'", ":", "typeStr", ";", "}", "else", "{", "switch", "(", "typeStr", ")", "{", "case", "'number'", ":", "return", "obj", "===", "0", "?", "'number'", ":", "'NaN'", ";", "case", "'object'", ":", "return", "'null'", ";", "default", ":", "return", "typeStr", ";", "}", "}", "}" ]

[ "returns", "type", "of", "obj", "specifying", "array", "NaN", "&", "null", "values" ]

[ "function", "injectWatcher", "(", "handler", ")", "{", "return", "function", "(", "module", ",", "filename", ")", "{", "fs", ".", "watchFile", "(", "filename", ",", "watcher", ")", ";", "handler", "(", "module", ",", "filename", ")", ";", "}", ";", "}" ]

[ "hijack", "each", "module", "extension", "handler", "and", "watch", "the", "file" ]

[ "function", "loadNext", "(", ")", "{", "var", "script", ";", "if", "(", "(", "script", "=", "pending", "[", "0", "]", ")", ")", "this", ".", "load", "(", "script", ".", "scriptUrl", ",", "script", ".", "callback", ",", "CKEDITOR", ",", "0", ")", ";", "}" ]

[ "Loads", "the", "very", "first", "script", "from", "queue", "and", "removes", "it", "." ]

[ "function", "callbackWrapper", "(", ")", "{", "callback", "&&", "callback", ".", "apply", "(", "this", ",", "arguments", ")", ";", "// Removed the just loaded script from the queue.", "pending", ".", "shift", "(", ")", ";", "loadNext", ".", "call", "(", "that", ")", ";", "}" ]

[ "This", "callback", "calls", "the", "standard", "callback", "for", "the", "script", "and", "loads", "the", "very", "next", "script", "from", "pending", "list", "." ]

[ "function", "Lexer", "(", "sourcetext", ",", "filename", ",", "options", ")", "{", "options", "=", "options", "||", "{", "}", ";", "this", ".", "options", "=", "options", "||", "{", "}", ";", "this", ".", "dialects", "=", "[", "]", ";", "// the \"stack\" dialects are pushed/popped from", "if", "(", "filename", ")", "{", "this", ".", "filename", "=", "filename", ";", "this", ".", "fileext", "=", "utils", ".", "getFileExt", "(", "filename", ",", "\"sugar\"", ")", ";", "}", "this", ".", "set_source_text", "(", "sourcetext", ")", ";", "}" ]

[ "A", "Lexer", "for", "the", "source", "text", "we", "are", "scanning" ]

[ "function", "regexes_for_category", "(", "lexer", ",", "category", ")", "{", "var", "REs", "=", "[", "]", ";", "var", "done", "=", "false", ";", "for", "(", "var", "i", "=", "0", ";", "!", "done", "&&", "i", "<", "lexer", ".", "dialects", ".", "length", ";", "i", "++", ")", "{", "var", "dialect", "=", "lexer", ".", "dialects", "[", "i", "]", ";", "if", "(", "dialect", ".", "lextab", ")", "{", "var", "categoryentry", "=", "dialect", ".", "lextab", ".", "find", "(", "function", "(", "lextabentry", ")", "{", "return", "lextabentry", ".", "category", "==", "category", ";", "}", ")", ";", "if", "(", "categoryentry", ")", "{", "REs", ".", "push", "(", "categoryentry", ".", "match", ")", ";", "// if they've set entry.replace=true this dialect's", "// entry replaces other dialects' entries:", "done", "=", "categoryentry", ".", "replace", ";", "}", "}", "}", "return", "REs", ";", "}" ]

[ "utility", "function", "accumulates", "all", "the", "regular", "expressions", "for", "a", "given", "token", "category", "and", "returns", "them", "in", "an", "array" ]

[ "function", "oncharincategory", "(", "lexer", ",", "lookahead", ",", "categoryREs", ")", "{", "var", "c", "=", "lexer", ".", "peek_char", "(", "lookahead", ")", ";", "return", "categoryREs", ".", "find", "(", "function", "(", "re", ")", "{", "// because we're matching a single char...", "re", ".", "lastIndex", "=", "0", ";", "// make sure we start from the start", "return", "re", ".", "test", "(", "c", ")", ";", "}", ")", ";", "}" ]

[ "is", "the", "source", "sitting", "on", "a", "char", "matching", "a", "specified", "token", "category?" ]

[ "function", "next_lextab_token", "(", "lexer", ")", "{", "var", "token", ";", "if", "(", "lexer", ".", "eos", "(", ")", ")", "{", "return", "undefined", ";", "}", "// skip leading whitespace or comments...", "lexer", ".", "skip_filler", "(", ")", ";", "var", "previouslyPeeked", "=", "lexer", ".", "getPeekedToken", "(", ")", ";", "if", "(", "previouslyPeeked", ")", "{", "return", "previouslyPeeked", ";", "}", "lexer", ".", "mark_token_start", "(", ")", ";", "trace", "(", "lexer", ".", "message_src_loc", "(", "\"\"", ",", "lexer", ",", "{", "file", ":", "false", "}", ")", ")", ";", "// try and match all token categories except punctuation (and", "// the default handler). Note that single character punctuation", "// should take a back seat to longer symbols e.g. '...' should", "// match before '.'.", "token", "=", "match_in_lextabs", "(", "lexer", ",", "{", "omit", ":", "[", "'punctuation'", ",", "'default'", "]", "}", ")", ";", "if", "(", "!", "token", ")", "{", "// okay now try again matching punctuation characters.", "token", "=", "match_in_lextabs", "(", "lexer", ",", "{", "include", ":", "[", "'punctuation'", "]", "}", ")", ";", "}", "if", "(", "!", "token", ")", "{", "// ok go ahead and try any default handler(s)", "token", "=", "match_in_lextabs", "(", "lexer", ",", "{", "include", ":", "[", "'default'", "]", "}", ")", ";", "}", "// we expect they will use an explicit default lextab entry, but JIC:", "if", "(", "!", "token", ")", "{", "trace", "(", "'their lextab has no default handler - defaulting to next word'", ")", ";", "token", "=", "lexer", ".", "next_word_token", "(", ")", ";", "if", "(", "token", ")", "{", "token", ".", "category", "=", "'symbol'", ";", "}", "}", "return", "token", ";", "}" ]

[ "Get", "the", "next", "token", "under", "the", "current", "source", "position", "according", "to", "the", "lextab", "entries", "of", "the", "current", "dialects", "." ]

[ "function", "match_in_lextabs", "(", "lexer", ",", "options", ")", "{", "options", "=", "options", "||", "{", "}", ";", "var", "token", ";", "var", "replaced", "=", "{", "}", ";", "// for each dialect's lextab...", "for", "(", "var", "d", "=", "0", ";", "!", "token", "&&", "d", "<", "lexer", ".", "dialects", ".", "length", ";", "d", "++", ")", "{", "var", "dialect", "=", "lexer", ".", "dialects", "[", "d", "]", ";", "if", "(", "!", "dialect", ".", "lextab", ")", "{", "continue", ";", "// no lextab for the dialect so move on", "}", "// check each entry in order...", "// NOTE I AM IGNORING THE 'PRIORITY' PROPERTY RIGHT NOW - MAYBE I CAN DELETE THEM!?", "debug", "(", "'matching in '", "+", "dialect", ".", "name", "+", "' lextable'", ")", ";", "for", "(", "var", "l", "=", "0", ";", "!", "token", "&&", "l", "<", "dialect", ".", "lextab", ".", "length", ";", "l", "++", ")", "{", "var", "entry", "=", "dialect", ".", "lextab", "[", "l", "]", ";", "// we don't match tokens against \"replaced\" categories", "if", "(", "!", "replaced", "[", "entry", ".", "category", "]", "&&", "// and if they've specified categories to include...", "(", "!", "options", ".", "include", "||", "// only consider those", "(", "options", ".", "include", ".", "contains", "(", "entry", ".", "category", ")", "||", "(", "options", ".", "include", ".", "contains", "(", "\"default\"", ")", "&&", "entry", ".", "default", ")", ")", ")", "&&", "// or if they've specified categories to omit...", "(", "!", "options", ".", "omit", "||", "// make sure we skip over those", "(", "(", "!", "options", ".", "omit", ".", "contains", "(", "entry", ".", "category", ")", "&&", "!", "(", "options", ".", "omit", ".", "contains", "(", "\"default\"", ")", "&&", "entry", ".", "default", ")", ")", ")", ")", ")", "{", "// most functions \"match\" (with a regex)", "// but they can also just \"read\" (with a function)", "if", "(", "typeof", "entry", ".", "read", "!==", "'function'", ")", "{", "// are we on a token matching this entry's pattern?", "//trace('matching ' + entry.category + ' pattern');", "var", "matchedText", "=", "lexer", ".", "on", "(", "entry", ".", "match", ")", ";", "if", "(", "matchedText", ")", "{", "trace", "(", "'matched '", "+", "entry", ".", "category", "+", "' pattern'", ")", ";", "// advance the current position", "lexer", ".", "next_char", "(", "matchedText", ".", "length", ")", ";", "// create and return the token object (including line/col info)", "token", "=", "lexer", ".", "create_token", "(", "matchedText", ",", "entry", ".", "category", ")", ";", "}", "}", "else", "{", "// note we use a \"read\" function for our default entry", "// used when nothing else matches. Such entries can", "// still set a token category, but they should set", "// \"default: true\" (so we know to consider them last).", "trace", "(", "'invoking '", "+", "entry", ".", "category", "+", "' read function'", ")", ";", "token", "=", "entry", ".", "read", "(", "lexer", ")", ";", "if", "(", "token", ")", "{", "trace", "(", "'read from '", "+", "entry", ".", "category", "+", "' read function'", ")", ";", "token", ".", "category", "=", "entry", ".", "category", ";", "}", "}", "}", "if", "(", "entry", ".", "replace", ")", "{", "// remember that this category has been replaced", "replaced", "[", "entry", ".", "category", "]", "=", "true", ";", "}", "}", "}", "return", "token", ";", "}" ]

[ "Helper", "function", "returns", "a", "token", "for", "the", "source", "text", "under", "the", "current", "position", "based", "on", "the", "nearest", "match", "in", "the", "active", "dialect", "s", "lextabs", "." ]

[ "function", "formatTokenDump", "(", "tokens", ",", "formatter", ",", "resultPrefix", ",", "resultSuffix", ")", "{", "var", "tokensSexpStr", "=", "\"\"", ";", "var", "currentLine", "=", "-", "999", ";", "tokens", ".", "forEach", "(", "function", "(", "token", ",", "index", ")", "{", "// skip the wrapping () it's annoying in the dump", "if", "(", "!", "(", "(", "index", "===", "0", "&&", "token", ".", "text", "===", "\"(\"", ")", "||", "(", "index", "===", "tokens", ".", "length", "-", "1", "&&", "token", ".", "text", "===", "\")\"", ")", ")", ")", "{", "// add a return if this starts a different line:", "if", "(", "currentLine", "!==", "-", "999", "&&", "token", ".", "line", "!==", "currentLine", ")", "{", "tokensSexpStr", "+=", "'\\n'", ";", "}", "tokensSexpStr", "+=", "formatter", "(", "token", ")", ";", "currentLine", "=", "token", ".", "line", ";", "}", "}", ")", ";", "return", "(", "resultPrefix", "?", "resultPrefix", ":", "\"\"", ")", "+", "tokensSexpStr", "+", "(", "resultSuffix", "?", "resultSuffix", ":", "\"\"", ")", ";", "}" ]

[ "format", "the", "token", "dump", "into", "a", "string" ]

[ "function", "Suite", "(", "name", ",", "fn", ")", "{", "if", "(", "!", "(", "this", "instanceof", "Suite", ")", ")", "return", "new", "Suite", "(", "name", ",", "fn", ")", ";", "return", "this", ".", "initialize", "(", "name", ",", "fn", ")", ";", "}" ]

[ "Suite", "constructor", "." ]

[ "function", "generateNamedFieldExtractors", "(", "input", ")", "{", "var", "names", "=", "input", ".", "filter", "(", "function", "(", "matcher", ",", "index", ",", "array", ")", "{", "// has a name?", "return", "matcher", ".", "name", ";", "}", ")", ";", "// has duplicates?", "names", ".", "forEach", "(", "function", "(", "matcher", ",", "index", ",", "array", ")", "{", "var", "isDuplicate", "=", "array", ".", "slice", "(", "0", ",", "index", ")", ".", "some", "(", "function", "(", "previousMatcher", ")", "{", "return", "previousMatcher", ".", "name", "==", "matcher", ".", "name", ";", "}", ")", ";", "if", "(", "isDuplicate", ")", "{", "throw", "new", "Error", "(", "\"duplicate named field '\"", "+", "matcher", ".", "name", "+", "\"'\"", ")", ";", "}", "}", ")", ";", "return", "names", ";", "}" ]

[ "this", "will", "flatten", "the", "input", "into", "a", "list", "of", "named", "field", "extractors", "should", "be", "run", "over", "output", "of", "generateMatchers" ]

[ "function", "extractNamedFields", "(", "fields", ",", "input", ")", "{", "var", "output", "=", "Object", ".", "create", "(", "null", ")", ";", "fields", ".", "forEach", "(", "function", "(", "field", ")", "{", "var", "subObject", "=", "input", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "field", ".", "path", ".", "length", ";", "i", "+=", "1", ")", "{", "if", "(", "subObject", "==", "undefined", ")", "{", "throw", "new", "Error", "(", "\"Unreachable: matched input will always have fields\"", ")", ";", "}", "subObject", "=", "subObject", "[", "field", ".", "path", "[", "i", "]", "]", ";", "}", "switch", "(", "field", ".", "typeShortcut", ")", "{", "// type matcher:", "case", "1", ":", "subObject", "=", "global", "[", "field", ".", "type", "]", "(", "subObject", ")", ";", "break", ";", "// literal matcher:", "case", "3", ":", "subObject", "=", "field", ".", "object", ";", "break", ";", "}", "output", "[", "field", ".", "name", "]", "=", "subObject", ";", "}", ")", ";", "return", "output", ";", "}" ]

[ "extract", "out", "the", "named", "fields", "from", "an", "input" ]

[ "function", "rawContent", "(", "tagName", ",", "string", ",", "templ", ",", "innerTemplate", ")", "{", "var", "index", "=", "string", ".", "indexOf", "(", "'</'", "+", "tagName", "+", "'>'", ")", ",", "raw", ";", "if", "(", "index", "===", "-", "1", ")", "throw", "new", "Error", "(", "tagName", "+", "' tag badly closed.'", ")", ";", "if", "(", "index", ")", "{", "// more than 0", "raw", "=", "string", ".", "substring", "(", "0", ",", "index", ")", ";", "if", "(", "tagName", "===", "'templ'", ")", "// produce local api-like handler", "{", "innerTemplate", ".", "templFunc", "=", "new", "Function", "(", "raw", ")", ";", "}", "else", "innerTemplate", ".", "raw", "(", "raw", ")", ";", "}", "return", "string", ".", "substring", "(", "index", "+", "tagName", ".", "length", "+", "3", ")", ";", "}" ]

[ "raw", "inner", "content", "of", "tag" ]

[ "function", "(", "markupList", ")", "{", "(", "\"production\"", "!==", "\"development\"", "?", "invariant", "(", "ExecutionEnvironment", ".", "canUseDOM", ",", "'dangerouslyRenderMarkup(...): Cannot render markup in a worker '", "+", "'thread. Make sure `window` and `document` are available globally '", "+", "'before requiring React when unit testing or use '", "+", "'React.renderToString for server rendering.'", ")", ":", "invariant", "(", "ExecutionEnvironment", ".", "canUseDOM", ")", ")", ";", "var", "nodeName", ";", "var", "markupByNodeName", "=", "{", "}", ";", "// Group markup by `nodeName` if a wrap is necessary, else by '*'.", "for", "(", "var", "i", "=", "0", ";", "i", "<", "markupList", ".", "length", ";", "i", "++", ")", "{", "(", "\"production\"", "!==", "\"development\"", "?", "invariant", "(", "markupList", "[", "i", "]", ",", "'dangerouslyRenderMarkup(...): Missing markup.'", ")", ":", "invariant", "(", "markupList", "[", "i", "]", ")", ")", ";", "nodeName", "=", "getNodeName", "(", "markupList", "[", "i", "]", ")", ";", "nodeName", "=", "getMarkupWrap", "(", "nodeName", ")", "?", "nodeName", ":", "'*'", ";", "markupByNodeName", "[", "nodeName", "]", "=", "markupByNodeName", "[", "nodeName", "]", "||", "[", "]", ";", "markupByNodeName", "[", "nodeName", "]", "[", "i", "]", "=", "markupList", "[", "i", "]", ";", "}", "var", "resultList", "=", "[", "]", ";", "var", "resultListAssignmentCount", "=", "0", ";", "for", "(", "nodeName", "in", "markupByNodeName", ")", "{", "if", "(", "!", "markupByNodeName", ".", "hasOwnProperty", "(", "nodeName", ")", ")", "{", "continue", ";", "}", "var", "markupListByNodeName", "=", "markupByNodeName", "[", "nodeName", "]", ";", "// This for-in loop skips the holes of the sparse array. The order of", "// iteration should follow the order of assignment, which happens to match", "// numerical index order, but we don't rely on that.", "var", "resultIndex", ";", "for", "(", "resultIndex", "in", "markupListByNodeName", ")", "{", "if", "(", "markupListByNodeName", ".", "hasOwnProperty", "(", "resultIndex", ")", ")", "{", "var", "markup", "=", "markupListByNodeName", "[", "resultIndex", "]", ";", "// Push the requested markup with an additional RESULT_INDEX_ATTR", "// attribute. If the markup does not start with a < character, it", "// will be discarded below (with an appropriate console.error).", "markupListByNodeName", "[", "resultIndex", "]", "=", "markup", ".", "replace", "(", "OPEN_TAG_NAME_EXP", ",", "// This index will be parsed back out below.", "'$1 '", "+", "RESULT_INDEX_ATTR", "+", "'=\"'", "+", "resultIndex", "+", "'\" '", ")", ";", "}", "}", "// Render each group of markup with similar wrapping `nodeName`.", "var", "renderNodes", "=", "createNodesFromMarkup", "(", "markupListByNodeName", ".", "join", "(", "''", ")", ",", "emptyFunction", "// Do nothing special with <script> tags.", ")", ";", "for", "(", "var", "j", "=", "0", ";", "j", "<", "renderNodes", ".", "length", ";", "++", "j", ")", "{", "var", "renderNode", "=", "renderNodes", "[", "j", "]", ";", "if", "(", "renderNode", ".", "hasAttribute", "&&", "renderNode", ".", "hasAttribute", "(", "RESULT_INDEX_ATTR", ")", ")", "{", "resultIndex", "=", "+", "renderNode", ".", "getAttribute", "(", "RESULT_INDEX_ATTR", ")", ";", "renderNode", ".", "removeAttribute", "(", "RESULT_INDEX_ATTR", ")", ";", "(", "\"production\"", "!==", "\"development\"", "?", "invariant", "(", "!", "resultList", ".", "hasOwnProperty", "(", "resultIndex", ")", ",", "'Danger: Assigning to an already-occupied result index.'", ")", ":", "invariant", "(", "!", "resultList", ".", "hasOwnProperty", "(", "resultIndex", ")", ")", ")", ";", "resultList", "[", "resultIndex", "]", "=", "renderNode", ";", "// This should match resultList.length and markupList.length when", "// we're done.", "resultListAssignmentCount", "+=", "1", ";", "}", "else", "if", "(", "\"production\"", "!==", "\"development\"", ")", "{", "console", ".", "error", "(", "'Danger: Discarding unexpected node:'", ",", "renderNode", ")", ";", "}", "}", "}", "// Although resultList was populated out of order, it should now be a dense", "// array.", "(", "\"production\"", "!==", "\"development\"", "?", "invariant", "(", "resultListAssignmentCount", "===", "resultList", ".", "length", ",", "'Danger: Did not assign to every index of resultList.'", ")", ":", "invariant", "(", "resultListAssignmentCount", "===", "resultList", ".", "length", ")", ")", ";", "(", "\"production\"", "!==", "\"development\"", "?", "invariant", "(", "resultList", ".", "length", "===", "markupList", ".", "length", ",", "'Danger: Expected markup to render %s nodes, but rendered %s.'", ",", "markupList", ".", "length", ",", "resultList", ".", "length", ")", ":", "invariant", "(", "resultList", ".", "length", "===", "markupList", ".", "length", ")", ")", ";", "return", "resultList", ";", "}" ]

[ "Renders", "markup", "into", "an", "array", "of", "nodes", ".", "The", "markup", "is", "expected", "to", "render", "into", "a", "list", "of", "root", "nodes", ".", "Also", "the", "length", "of", "resultList", "and", "markupList", "should", "be", "the", "same", "." ]

[ "function", "recomputePluginOrdering", "(", ")", "{", "if", "(", "!", "EventPluginOrder", ")", "{", "// Wait until an `EventPluginOrder` is injected.", "return", ";", "}", "for", "(", "var", "pluginName", "in", "namesToPlugins", ")", "{", "var", "PluginModule", "=", "namesToPlugins", "[", "pluginName", "]", ";", "var", "pluginIndex", "=", "EventPluginOrder", ".", "indexOf", "(", "pluginName", ")", ";", "(", "\"production\"", "!==", "\"development\"", "?", "invariant", "(", "pluginIndex", ">", "-", "1", ",", "'EventPluginRegistry: Cannot inject event plugins that do not exist in '", "+", "'the plugin ordering, `%s`.'", ",", "pluginName", ")", ":", "invariant", "(", "pluginIndex", ">", "-", "1", ")", ")", ";", "if", "(", "EventPluginRegistry", ".", "plugins", "[", "pluginIndex", "]", ")", "{", "continue", ";", "}", "(", "\"production\"", "!==", "\"development\"", "?", "invariant", "(", "PluginModule", ".", "extractEvents", ",", "'EventPluginRegistry: Event plugins must implement an `extractEvents` '", "+", "'method, but `%s` does not.'", ",", "pluginName", ")", ":", "invariant", "(", "PluginModule", ".", "extractEvents", ")", ")", ";", "EventPluginRegistry", ".", "plugins", "[", "pluginIndex", "]", "=", "PluginModule", ";", "var", "publishedEvents", "=", "PluginModule", ".", "eventTypes", ";", "for", "(", "var", "eventName", "in", "publishedEvents", ")", "{", "(", "\"production\"", "!==", "\"development\"", "?", "invariant", "(", "publishEventForPlugin", "(", "publishedEvents", "[", "eventName", "]", ",", "PluginModule", ",", "eventName", ")", ",", "'EventPluginRegistry: Failed to publish event `%s` for plugin `%s`.'", ",", "eventName", ",", "pluginName", ")", ":", "invariant", "(", "publishEventForPlugin", "(", "publishedEvents", "[", "eventName", "]", ",", "PluginModule", ",", "eventName", ")", ")", ")", ";", "}", "}", "}" ]

[ "Recomputes", "the", "plugin", "list", "using", "the", "injected", "plugins", "and", "plugin", "ordering", "." ]

[ "function", "publishEventForPlugin", "(", "dispatchConfig", ",", "PluginModule", ",", "eventName", ")", "{", "(", "\"production\"", "!==", "\"development\"", "?", "invariant", "(", "!", "EventPluginRegistry", ".", "eventNameDispatchConfigs", ".", "hasOwnProperty", "(", "eventName", ")", ",", "'EventPluginHub: More than one plugin attempted to publish the same '", "+", "'event name, `%s`.'", ",", "eventName", ")", ":", "invariant", "(", "!", "EventPluginRegistry", ".", "eventNameDispatchConfigs", ".", "hasOwnProperty", "(", "eventName", ")", ")", ")", ";", "EventPluginRegistry", ".", "eventNameDispatchConfigs", "[", "eventName", "]", "=", "dispatchConfig", ";", "var", "phasedRegistrationNames", "=", "dispatchConfig", ".", "phasedRegistrationNames", ";", "if", "(", "phasedRegistrationNames", ")", "{", "for", "(", "var", "phaseName", "in", "phasedRegistrationNames", ")", "{", "if", "(", "phasedRegistrationNames", ".", "hasOwnProperty", "(", "phaseName", ")", ")", "{", "var", "phasedRegistrationName", "=", "phasedRegistrationNames", "[", "phaseName", "]", ";", "publishRegistrationName", "(", "phasedRegistrationName", ",", "PluginModule", ",", "eventName", ")", ";", "}", "}", "return", "true", ";", "}", "else", "if", "(", "dispatchConfig", ".", "registrationName", ")", "{", "publishRegistrationName", "(", "dispatchConfig", ".", "registrationName", ",", "PluginModule", ",", "eventName", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "Publishes", "an", "event", "so", "that", "it", "can", "be", "dispatched", "by", "the", "supplied", "plugin", "." ]

[ "function", "(", "spec", ")", "{", "var", "Constructor", "=", "function", "(", "props", ",", "context", ")", "{", "// This constructor is overridden by mocks. The argument is used", "// by mocks to assert on what gets mounted.", "if", "(", "\"production\"", "!==", "\"development\"", ")", "{", "(", "\"production\"", "!==", "\"development\"", "?", "warning", "(", "this", "instanceof", "Constructor", ",", "'Something is calling a React component directly. Use a factory or '", "+", "'JSX instead. See: https://fb.me/react-legacyfactory'", ")", ":", "null", ")", ";", "}", "// Wire up auto-binding", "if", "(", "this", ".", "__reactAutoBindMap", ")", "{", "bindAutoBindMethods", "(", "this", ")", ";", "}", "this", ".", "props", "=", "props", ";", "this", ".", "context", "=", "context", ";", "this", ".", "state", "=", "null", ";", "// ReactClasses doesn't have constructors. Instead, they use the", "// getInitialState and componentWillMount methods for initialization.", "var", "initialState", "=", "this", ".", "getInitialState", "?", "this", ".", "getInitialState", "(", ")", ":", "null", ";", "if", "(", "\"production\"", "!==", "\"development\"", ")", "{", "// We allow auto-mocks to proceed as if they're returning null.", "if", "(", "typeof", "initialState", "===", "'undefined'", "&&", "this", ".", "getInitialState", ".", "_isMockFunction", ")", "{", "// This is probably bad practice. Consider warning here and", "// deprecating this convenience.", "initialState", "=", "null", ";", "}", "}", "(", "\"production\"", "!==", "\"development\"", "?", "invariant", "(", "typeof", "initialState", "===", "'object'", "&&", "!", "Array", ".", "isArray", "(", "initialState", ")", ",", "'%s.getInitialState(): must return an object or null'", ",", "Constructor", ".", "displayName", "||", "'ReactCompositeComponent'", ")", ":", "invariant", "(", "typeof", "initialState", "===", "'object'", "&&", "!", "Array", ".", "isArray", "(", "initialState", ")", ")", ")", ";", "this", ".", "state", "=", "initialState", ";", "}", ";", "Constructor", ".", "prototype", "=", "new", "ReactClassComponent", "(", ")", ";", "Constructor", ".", "prototype", ".", "constructor", "=", "Constructor", ";", "injectedMixins", ".", "forEach", "(", "mixSpecIntoComponent", ".", "bind", "(", "null", ",", "Constructor", ")", ")", ";", "mixSpecIntoComponent", "(", "Constructor", ",", "spec", ")", ";", "// Initialize the defaultProps property after all mixins have been merged", "if", "(", "Constructor", ".", "getDefaultProps", ")", "{", "Constructor", ".", "defaultProps", "=", "Constructor", ".", "getDefaultProps", "(", ")", ";", "}", "if", "(", "\"production\"", "!==", "\"development\"", ")", "{", "// This is a tag to indicate that the use of these method names is ok,", "// since it's used with createClass. If it's not, then it's likely a", "// mistake so we'll warn you to use the static property, property", "// initializer or constructor respectively.", "if", "(", "Constructor", ".", "getDefaultProps", ")", "{", "Constructor", ".", "getDefaultProps", ".", "isReactClassApproved", "=", "{", "}", ";", "}", "if", "(", "Constructor", ".", "prototype", ".", "getInitialState", ")", "{", "Constructor", ".", "prototype", ".", "getInitialState", ".", "isReactClassApproved", "=", "{", "}", ";", "}", "}", "(", "\"production\"", "!==", "\"development\"", "?", "invariant", "(", "Constructor", ".", "prototype", ".", "render", ",", "'createClass(...): Class specification must implement a `render` method.'", ")", ":", "invariant", "(", "Constructor", ".", "prototype", ".", "render", ")", ")", ";", "if", "(", "\"production\"", "!==", "\"development\"", ")", "{", "(", "\"production\"", "!==", "\"development\"", "?", "warning", "(", "!", "Constructor", ".", "prototype", ".", "componentShouldUpdate", ",", "'%s has a method called '", "+", "'componentShouldUpdate(). Did you mean shouldComponentUpdate()? '", "+", "'The name is phrased as a question because the function is '", "+", "'expected to return a value.'", ",", "spec", ".", "displayName", "||", "'A component'", ")", ":", "null", ")", ";", "}", "// Reduce time spent doing lookups by setting these on the prototype.", "for", "(", "var", "methodName", "in", "ReactClassInterface", ")", "{", "if", "(", "!", "Constructor", ".", "prototype", "[", "methodName", "]", ")", "{", "Constructor", ".", "prototype", "[", "methodName", "]", "=", "null", ";", "}", "}", "// Legacy hook", "Constructor", ".", "type", "=", "Constructor", ";", "if", "(", "\"production\"", "!==", "\"development\"", ")", "{", "try", "{", "Object", ".", "defineProperty", "(", "Constructor", ",", "'type'", ",", "typeDeprecationDescriptor", ")", ";", "}", "catch", "(", "x", ")", "{", "// IE will fail on defineProperty (es5-shim/sham too)", "}", "}", "return", "Constructor", ";", "}" ]

[ "Creates", "a", "composite", "component", "class", "given", "a", "class", "specification", "." ]

[ "function", "(", "propTypes", ",", "props", ",", "location", ")", "{", "// TODO: Stop validating prop types here and only use the element", "// validation.", "var", "componentName", "=", "this", ".", "getName", "(", ")", ";", "for", "(", "var", "propName", "in", "propTypes", ")", "{", "if", "(", "propTypes", ".", "hasOwnProperty", "(", "propName", ")", ")", "{", "var", "error", ";", "try", "{", "// This is intentionally an invariant that gets caught. It's the same", "// behavior as without this statement except with a better message.", "(", "\"production\"", "!==", "\"development\"", "?", "invariant", "(", "typeof", "propTypes", "[", "propName", "]", "===", "'function'", ",", "'%s: %s type `%s` is invalid; it must be a function, usually '", "+", "'from React.PropTypes.'", ",", "componentName", "||", "'React class'", ",", "ReactPropTypeLocationNames", "[", "location", "]", ",", "propName", ")", ":", "invariant", "(", "typeof", "propTypes", "[", "propName", "]", "===", "'function'", ")", ")", ";", "error", "=", "propTypes", "[", "propName", "]", "(", "props", ",", "propName", ",", "componentName", ",", "location", ")", ";", "}", "catch", "(", "ex", ")", "{", "error", "=", "ex", ";", "}", "if", "(", "error", "instanceof", "Error", ")", "{", "// We may want to extend this logic for similar errors in", "// React.render calls, so I'm abstracting it away into", "// a function to minimize refactoring in the future", "var", "addendum", "=", "getDeclarationErrorAddendum", "(", "this", ")", ";", "if", "(", "location", "===", "ReactPropTypeLocations", ".", "prop", ")", "{", "// Preface gives us something to blacklist in warning module", "(", "\"production\"", "!==", "\"development\"", "?", "warning", "(", "false", ",", "'Failed Composite propType: %s%s'", ",", "error", ".", "message", ",", "addendum", ")", ":", "null", ")", ";", "}", "else", "{", "(", "\"production\"", "!==", "\"development\"", "?", "warning", "(", "false", ",", "'Failed Context Types: %s%s'", ",", "error", ".", "message", ",", "addendum", ")", ":", "null", ")", ";", "}", "}", "}", "}", "}" ]

[ "Assert", "that", "the", "props", "are", "valid" ]

[ "function", "warnForPropsMutation", "(", "propName", ",", "element", ")", "{", "var", "type", "=", "element", ".", "type", ";", "var", "elementName", "=", "typeof", "type", "===", "'string'", "?", "type", ":", "type", ".", "displayName", ";", "var", "ownerName", "=", "element", ".", "_owner", "?", "element", ".", "_owner", ".", "getPublicInstance", "(", ")", ".", "constructor", ".", "displayName", ":", "null", ";", "var", "warningKey", "=", "propName", "+", "'|'", "+", "elementName", "+", "'|'", "+", "ownerName", ";", "if", "(", "warnedPropsMutations", ".", "hasOwnProperty", "(", "warningKey", ")", ")", "{", "return", ";", "}", "warnedPropsMutations", "[", "warningKey", "]", "=", "true", ";", "var", "elementInfo", "=", "''", ";", "if", "(", "elementName", ")", "{", "elementInfo", "=", "' <'", "+", "elementName", "+", "' />'", ";", "}", "var", "ownerInfo", "=", "''", ";", "if", "(", "ownerName", ")", "{", "ownerInfo", "=", "' The element was created by '", "+", "ownerName", "+", "'.'", ";", "}", "(", "\"production\"", "!==", "\"development\"", "?", "warning", "(", "false", ",", "'Don\\'t set .props.%s of the React component%s. Instead, specify the '", "+", "'correct value when initially creating the element or use '", "+", "'React.cloneElement to make a new element with updated props.%s'", ",", "propName", ",", "elementInfo", ",", "ownerInfo", ")", ":", "null", ")", ";", "}" ]

[ "Warn", "about", "mutating", "props", "when", "setting", "propName", "on", "element", "." ]

[ "function", "(", "object", ")", "{", "if", "(", "\"production\"", "!==", "\"development\"", ")", "{", "if", "(", "typeof", "object", "!==", "'object'", "||", "!", "object", "||", "Array", ".", "isArray", "(", "object", ")", ")", "{", "(", "\"production\"", "!==", "\"development\"", "?", "warning", "(", "false", ",", "'React.addons.createFragment only accepts a single object.'", ",", "object", ")", ":", "null", ")", ";", "return", "object", ";", "}", "if", "(", "ReactElement", ".", "isValidElement", "(", "object", ")", ")", "{", "(", "\"production\"", "!==", "\"development\"", "?", "warning", "(", "false", ",", "'React.addons.createFragment does not accept a ReactElement '", "+", "'without a wrapper object.'", ")", ":", "null", ")", ";", "return", "object", ";", "}", "if", "(", "canWarnForReactFragment", ")", "{", "var", "proxy", "=", "{", "}", ";", "Object", ".", "defineProperty", "(", "proxy", ",", "fragmentKey", ",", "{", "enumerable", ":", "false", ",", "value", ":", "object", "}", ")", ";", "Object", ".", "defineProperty", "(", "proxy", ",", "didWarnKey", ",", "{", "writable", ":", "true", ",", "enumerable", ":", "false", ",", "value", ":", "false", "}", ")", ";", "for", "(", "var", "key", "in", "object", ")", "{", "proxyPropertyAccessWithWarning", "(", "proxy", ",", "key", ")", ";", "}", "Object", ".", "preventExtensions", "(", "proxy", ")", ";", "return", "proxy", ";", "}", "}", "return", "object", ";", "}" ]

[ "Wrap", "a", "keyed", "object", "in", "an", "opaque", "proxy", "that", "warns", "you", "if", "you", "access", "any", "of", "its", "properties", "." ]

[ "function", "(", "container", ")", "{", "// Various parts of our code (such as ReactCompositeComponent's", "// _renderValidatedComponent) assume that calls to render aren't nested;", "// verify that that's the case. (Strictly speaking, unmounting won't cause a", "// render but we still don't expect to be in a render call here.)", "(", "\"production\"", "!==", "\"development\"", "?", "warning", "(", "ReactCurrentOwner", ".", "current", "==", "null", ",", "'unmountComponentAtNode(): Render methods should be a pure function of '", "+", "'props and state; triggering nested component updates from render is '", "+", "'not allowed. If necessary, trigger nested updates in '", "+", "'componentDidUpdate.'", ")", ":", "null", ")", ";", "(", "\"production\"", "!==", "\"development\"", "?", "invariant", "(", "container", "&&", "(", "(", "container", ".", "nodeType", "===", "ELEMENT_NODE_TYPE", "||", "container", ".", "nodeType", "===", "DOC_NODE_TYPE", ")", ")", ",", "'unmountComponentAtNode(...): Target container is not a DOM element.'", ")", ":", "invariant", "(", "container", "&&", "(", "(", "container", ".", "nodeType", "===", "ELEMENT_NODE_TYPE", "||", "container", ".", "nodeType", "===", "DOC_NODE_TYPE", ")", ")", ")", ")", ";", "var", "reactRootID", "=", "getReactRootID", "(", "container", ")", ";", "var", "component", "=", "instancesByReactRootID", "[", "reactRootID", "]", ";", "if", "(", "!", "component", ")", "{", "return", "false", ";", "}", "ReactMount", ".", "unmountComponentFromNode", "(", "component", ",", "container", ")", ";", "delete", "instancesByReactRootID", "[", "reactRootID", "]", ";", "delete", "containersByReactRootID", "[", "reactRootID", "]", ";", "if", "(", "\"production\"", "!==", "\"development\"", ")", "{", "delete", "rootElementsByReactRootID", "[", "reactRootID", "]", ";", "}", "return", "true", ";", "}" ]

[ "Unmounts", "and", "destroys", "the", "React", "component", "rendered", "in", "the", "container", "." ]

[ "function", "(", "objName", ",", "fnName", ",", "func", ")", "{", "if", "(", "\"production\"", "!==", "\"development\"", ")", "{", "var", "measuredFunc", "=", "null", ";", "var", "wrapper", "=", "function", "(", ")", "{", "if", "(", "ReactPerf", ".", "enableMeasure", ")", "{", "if", "(", "!", "measuredFunc", ")", "{", "measuredFunc", "=", "ReactPerf", ".", "storedMeasure", "(", "objName", ",", "fnName", ",", "func", ")", ";", "}", "return", "measuredFunc", ".", "apply", "(", "this", ",", "arguments", ")", ";", "}", "return", "func", ".", "apply", "(", "this", ",", "arguments", ")", ";", "}", ";", "wrapper", ".", "displayName", "=", "objName", "+", "'_'", "+", "fnName", ";", "return", "wrapper", ";", "}", "return", "func", ";", "}" ]

[ "Use", "this", "to", "wrap", "methods", "you", "want", "to", "measure", ".", "Zero", "overhead", "in", "production", "." ]

[ "function", "(", ")", "{", "var", "acc", "=", "arguments", ".", "callee", ".", "caller", ";", "var", "nom", "=", "(", "(", "acc", "?", "acc", ".", "nom", ":", "\"\"", ")", "||", "\"(instance method)\"", ")", "+", "\":\"", ";", "enyo", ".", "logging", ".", "log", "(", "\"log\"", ",", "[", "nom", "]", ".", "concat", "(", "enyo", ".", "cloneArray", "(", "arguments", ")", ")", ")", ";", "}" ]

[ "Sends", "a", "log", "message", "to", "the", "console", "prepended", "with", "the", "name", "of", "the", "kind", "and", "method", "from", "which", "_log_", "was", "invoked", ".", "Multiple", "arguments", "are", "coerced", "to", "String", "and", "joined", "with", "spaces", "." ]

[ "function", "mv", "(", "sourceURI", ",", "destURI", ",", "callback", ")", "{", "if", "(", "!", "sourceURI", ")", "{", "callback", "(", "new", "Error", "(", "'source URI is required'", ")", ")", "}", "if", "(", "!", "destURI", ")", "{", "callback", "(", "new", "Error", "(", "'dest URI is required'", ")", ")", "}", "util", ".", "get", "(", "sourceURI", ",", "function", "(", "err", ",", "val", ",", "uri", ")", "{", "util", ".", "put", "(", "destURI", ",", "val", ",", "function", "(", "err", ",", "ret", ",", "uri", ")", "{", "if", "(", "!", "err", ")", "{", "util", ".", "rm", "(", "sourceURI", ",", "function", "(", "err", ",", "ret", ")", "{", "if", "(", "!", "err", ")", "{", "callback", "(", "null", ",", "ret", ",", "uri", ")", "}", "else", "{", "callback", "(", "err", ")", "}", "}", ")", "}", "else", "{", "callback", "(", "err", ")", "}", "}", ")", "}", ")", "}" ]

[ "Move", "rdf", "from", "a", "source", "to", "a", "destination", "." ]

[ "function", "update", "(", ")", "{", "connection", "=", "new", "Connection", "(", "room", ")", "// set our funcitonal code on the ready event, so we are sure that the socket has been created and is connected to the server", "connection", ".", "on", "(", "'ready'", ",", "_", "=>", "{", "connection", ".", "on", "(", "'snapshot-event'", ",", "event", "=>", "{", "// get every listener including bots and lurkers", "userList", "=", "event", ".", "data", ".", "listing", ".", "sort", "(", ")", "render", "(", "userList", ")", "connection", ".", "close", "(", ")", "}", ")", "}", ")", "}" ]

[ "Update", "the", "userList", "global", "with", "new", "data", "from", "the", "targeted", "euphoria", "room", ".", "We", "use", "the", "snapshot", "even", "send", "on", "a", "new", "connect", "to", "update", "the", "userlist", "." ]

[ "function", "render", "(", "list", ")", "{", "const", "blank", "=", "new", "Array", "(", "process", ".", "stdout", ".", "rows", ")", ".", "fill", "(", "'\\n'", ")", "console", ".", "log", "(", "blank", ")", "readline", ".", "cursorTo", "(", "process", ".", "stdout", ",", "0", ",", "0", ")", "readline", ".", "clearScreenDown", "(", "process", ".", "stdout", ")", "list", ".", "forEach", "(", "user", "=>", "{", "console", ".", "log", "(", "`", "${", "chalk", ".", "hsl", "(", "color", "(", "user", ".", "name", ")", ",", "100", ",", "50", ")", "(", "user", ".", "name", ")", "}", "${", "user", ".", "id", "}", "`", ")", "}", ")", "}" ]

[ "Render", "our", "list", "replace", "the", "old", "console", "content", "with", "our", "newer", "content", "and", "place", "the", "relevant", "data", "in", "the", "relevant", "places", "." ]

[ "function", "getMeasureStations", "(", "latitude", ",", "longitude", ",", "params", ",", "callback", ")", "{", "if", "(", "!", "latitude", "||", "!", "longitude", ")", "{", "callback", "(", "new", "Error", "(", "\"WaterFlow.getMeasureStations: latitude and longitude required\"", ")", ")", ";", "return", ";", "}", "params", "=", "params", "||", "{", "}", ";", "params", ".", "latitude", "=", "latitude", ";", "params", ".", "longitude", "=", "longitude", ";", "core", ".", "callApi", "(", "'/waterflowservice/GetMeasureStations'", ",", "params", ",", "callback", ")", ";", "}" ]

[ "Returns", "a", "list", "of", "all", "available", "measure", "stations", "producing", "water", "level", "data", "." ]

[ "function", "getWaterLevel", "(", "stationId", ",", "startDate", ",", "endDate", ",", "params", ",", "callback", ")", "{", "if", "(", "!", "stationId", ")", "{", "callback", "(", "new", "Error", "(", "\"WaterFlow.getWaterLevel: stationId required\"", ")", ")", ";", "return", ";", "}", "params", "=", "params", "||", "{", "}", ";", "params", ".", "stationid", "=", "stationId", ";", "if", "(", "!", "startDate", "&&", "!", "endDate", ")", "{", "startDate", "=", "new", "Date", "(", ")", ";", "startDate", ".", "setHours", "(", "startDate", ".", "getHours", "(", ")", "-", "4", ")", ";", "startDate", "=", "formatDate", "(", "startDate", ")", ";", "endDate", "=", "new", "Date", "(", ")", ";", "endDate", "=", "formatDate", "(", "endDate", ")", ";", "}", "params", ".", "startdate", "=", "startDate", ";", "params", ".", "endDate", "=", "endDate", ";", "core", ".", "callApi", "(", "'/waterflowservice/GetWaterLevel'", ",", "params", ",", "callback", ")", ";", "}" ]

[ "Returns", "a", "list", "of", "water", "level", "measuring", "points", "given", "a", "sertain", "station", "and", "time", "interval", "." ]

[ "function", "matches", "(", "url", ",", "command", ")", "{", "var", "cap", ";", "if", "(", "cap", "=", "commandReg", ".", "exec", "(", "url", ")", ")", "return", "cap", "[", "1", "]", "===", "command", ";", "}" ]

[ "Ugliness", "to", "support", "escaped", "backslashes", "in", "windows" ]

[ "function", "Pending", "(", "runner", ")", "{", "runner", ".", "on", "(", "'start'", ",", "function", "(", ")", "{", "console", ".", "log", "(", "'* '", ")", "console", ".", "log", "(", "'*********************'", ")", ";", "console", ".", "log", "(", "'*** Pending tests ***'", ")", ";", "console", ".", "log", "(", "'*********************'", ")", ";", "console", ".", "log", "(", "'* '", ")", "}", ")", ";", "var", "scope", "=", "[", "]", ";", "runner", ".", "on", "(", "'pending'", ",", "function", "(", "test", ")", "{", "var", "current", "=", "[", "test", "]", ",", "parent", "=", "test", ".", "parent", ";", "// stack suites", "while", "(", "!", "!", "parent", ")", "{", "current", ".", "unshift", "(", "parent", ")", "parent", "=", "parent", ".", "parent", ";", "}", "// print titles", "current", ".", "forEach", "(", "function", "(", "val", ",", "key", ")", "{", "if", "(", "val", "!=", "scope", "[", "key", "]", ")", "{", "while", "(", "scope", ".", "length", ">", "key", ")", "{", "scope", ".", "pop", "(", ")", "}", "console", ".", "log", "(", "'* '", "+", "Array", "(", "key", ")", ".", "join", "(", "' '", ")", "+", "val", ".", "title", ")", ";", "scope", ".", "push", "(", "val", ")", ";", "}", "}", ")", "}", ")", "}" ]

[ "Initialize", "a", "new", "Pending", "test", "reporter", "." ]

[ "function", "(", "d", ",", "use_UTC", ")", "{", "if", "(", "typeof", "d", "===", "\"string\"", ")", "{", "if", "(", "d", ".", "match", "(", "/", "[0-9][0-9][0-9][0-9][\\s]*-[0-1][0-9]-[\\s]*[0-3][0-9]", "/", ")", ")", "{", "return", "d", ".", "replace", "(", "/", "\\s+", "/", ",", "\"\"", ")", ";", "}", "d", "=", "new", "Date", "(", "d", ")", ";", "}", "else", "if", "(", "typeof", "d", "===", "\"number\"", ")", "{", "d", "=", "new", "Date", "(", "d", ")", ";", "}", "else", "if", "(", "typeof", "d", "!==", "\"object\"", "&&", "typeof", "d", ".", "getFullYear", "!==", "\"function\"", ")", "{", "throw", "\"Expecting type: \"", "+", "String", "(", "d", ")", "+", "\" --> \"", "+", "typeof", "d", ";", "}", "if", "(", "!", "use_UTC", ")", "{", "return", "[", "d", ".", "getFullYear", "(", ")", ",", "String", "(", "\"0\"", "+", "(", "d", ".", "getMonth", "(", ")", "+", "1", ")", ")", ".", "substr", "(", "-", "2", ")", ",", "String", "(", "\"0\"", "+", "d", ".", "getDate", "(", ")", ")", ".", "substr", "(", "-", "2", ")", "]", ".", "join", "(", "\"-\"", ")", ";", "}", "return", "[", "d", ".", "getUTCFullYear", "(", ")", ",", "String", "(", "\"0\"", "+", "(", "d", ".", "getUTCMonth", "(", ")", "+", "1", ")", ")", ".", "substr", "(", "-", "2", ")", ",", "String", "(", "\"0\"", "+", "d", ".", "getUTCDate", "(", ")", ")", ".", "substr", "(", "-", "2", ")", "]", ".", "join", "(", "\"-\"", ")", ";", "}" ]

[ "Format", "a", "date", "as", "YYYY", "-", "MM", "-", "DD" ]

[ "function", "(", "options", ")", "{", "var", "ky", ",", "default_keys", "=", "[", "\"normalize_date\"", ",", "\"hours\"", ",", "\"save_parse\"", ",", "\"tags\"", ",", "\"map\"", "]", ",", "defaults", "=", "{", "}", ",", "map", "=", "{", "}", ";", "default_keys", ".", "forEach", "(", "function", "(", "ky", ")", "{", "defaults", "[", "ky", "]", "=", "true", ";", "}", ")", ";", "this", ".", "defaults", "=", "defaults", ";", "this", ".", "map", "=", "false", ";", "this", ".", "parse_tree", "=", "{", "}", ";", "this", ".", "msgs", "=", "[", "]", ";", "if", "(", "options", "!==", "undefined", ")", "{", "for", "(", "ky", "in", "options", ")", "{", "if", "(", "options", ".", "hasOwnProperty", "(", "ky", ")", ")", "{", "if", "(", "default_keys", ".", "indexOf", "(", "ky", ")", ">=", "0", ")", "{", "this", ".", "defaults", "[", "ky", "]", "=", "options", "[", "ky", "]", ";", "}", "else", "{", "map", "[", "ky", "]", "=", "options", "[", "ky", "]", ";", "}", "}", "}", "if", "(", "Object", ".", "keys", "(", "map", ")", ".", "length", ">", "0", ")", "{", "this", ".", "map", "=", "map", ";", "}", "}", "}" ]

[ "reset", "-", "clear", "the", "parse", "tree", "sets", "save_parse", "to", "true", "sets", "normalize_date", "to", "true", "sets", "tags", "to", "true", "sets", "map", "ot", "false" ]

[ "function", "(", "msg", ")", "{", "var", "i", "=", "this", ".", "msgs", ".", "length", ";", "this", ".", "msgs", ".", "push", "(", "'ERROR: '", "+", "msg", ")", ";", "if", "(", "(", "i", "+", "1", ")", "!==", "this", ".", "msgs", ".", "length", ")", "{", "return", "false", ";", "}", "return", "true", ";", "}" ]

[ "error", "-", "collect", "parse", "errors", "into", "the", "msgs", "array", "." ]

[ "function", "(", "no_clear", ")", "{", "var", "result", ";", "if", "(", "this", ".", "msgs", "===", "undefined", ")", "{", "this", ".", "msgs", "=", "[", "]", ";", "}", "result", "=", "this", ".", "msgs", ".", "join", "(", "\"\\n\"", ")", ";", "// set optional default i needed", "if", "(", "no_clear", "!==", "undefined", ")", "{", "no_clear", "=", "false", ";", "}", "if", "(", "no_clear", "===", "true", ")", "{", "return", "result", ";", "}", "// Clear the messages", "this", ".", "msgs", "=", "[", "]", ";", "return", "result", ";", "}" ]

[ "messages", "-", "return", "the", "msgs", "array", "as", "a", "single", "string", "delimited", "by", "new", "lines", "." ]

[ "function", "(", ")", "{", "var", "self", "=", "this", ",", "dates", "=", "Object", ".", "keys", "(", "this", ".", "parse_tree", ")", ",", "lines", "=", "[", "]", ";", "dates", ".", "sort", "(", ")", ";", "dates", ".", "forEach", "(", "function", "(", "dy", ",", "i", ")", "{", "var", "times", "=", "Object", ".", "keys", "(", "self", ".", "parse_tree", "[", "dy", "]", ")", ";", "lines", ".", "push", "(", "dy", ")", ";", "times", ".", "sort", "(", ")", ";", "times", ".", "forEach", "(", "function", "(", "tm", ")", "{", "var", "tags", "=", "\"\"", ",", "maps", "=", "\"\"", ",", "notes", "=", "\"\"", ",", "rec", ";", "rec", "=", "self", ".", "parse_tree", "[", "dy", "]", "[", "tm", "]", ";", "if", "(", "typeof", "rec", "===", "\"string\"", ")", "{", "notes", "=", "rec", ";", "}", "else", "{", "if", "(", "typeof", "rec", ".", "map", "!==", "\"undefined\"", "&&", "rec", ".", "map", "!==", "false", ")", "{", "maps", "=", "[", "rec", ".", "map", ".", "project_name", ",", "rec", ".", "map", ".", "task", "]", ".", "join", "(", "\", \"", ")", "+", "\"; \"", ";", "}", "if", "(", "typeof", "rec", ".", "tags", "!==", "\"undefined\"", "&&", "rec", ".", "tags", "!==", "false", ")", "{", "tags", "=", "rec", ".", "tags", ".", "join", "(", "\", \"", ")", "+", "\"; \"", ";", "}", "if", "(", "typeof", "rec", ".", "notes", "!==", "\"undefined\"", ")", "{", "notes", "=", "rec", ".", "notes", ";", "}", "}", "lines", ".", "push", "(", "[", "tm", ",", "\"; \"", ",", "tags", ",", "maps", ",", "notes", "]", ".", "join", "(", "\"\"", ")", ")", ";", "}", ")", ";", "}", ")", ";", "return", "lines", ".", "join", "(", "\"\\n\\n\"", ")", ";", "}" ]

[ "Render", "parse", "tree", "as", "string", "." ]

[ "function", "addFiles", "(", "pattern", ",", "cb", ")", "{", "glob", "(", "pattern", ",", "function", "(", "err", ",", "files", ")", "{", "if", "(", "err", ")", "throw", "err", ";", "async", ".", "each", "(", "files", ",", "readFile", ",", "function", "(", "err", ")", "{", "if", "(", "err", ")", "throw", "err", ";", "if", "(", "cb", ")", "cb", "(", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Add", "files", "to", "register" ]

[ "function", "find", "(", "source", ",", "fn", ")", "{", "glob", "(", "'**'", ",", "{", "cwd", ":", "source", ",", "dot", ":", "true", "}", ",", "function", "(", "err", ",", "files", ")", "{", "fn", "(", "err", ",", "files", ")", ";", "}", ")", ";", "}" ]

[ "Glob", "source", "dir" ]

[ "function", "filterIgnored", "(", "files", ",", "ignore", ",", "fn", ")", "{", "fn", "(", "null", ",", "files", ".", "filter", "(", "function", "(", "file", ")", "{", "// TODO make more robust", "return", "!", "~", "ignore", ".", "indexOf", "(", "file", ")", "&&", "!", "~", "ignore", ".", "indexOf", "(", "file", "+", "'/'", ")", ";", "}", ")", ")", ";", "}" ]

[ "Filter", "ignored", "files" ]