Datasets:

---

CM

/

codexglue_code2text_javascript

like 12

[ "function", "read_via_closest_dialect", "(", "lexer", ",", "options", ")", "{", "trace", "(", "lexer", ".", "message_src_loc", "(", "\"\"", ",", "lexer", ",", "{", "file", ":", "false", "}", ")", ")", ";", "// options allow this function to be used when a readtab", "// handler needs to read by invoking a handler that it's", "// overridden, without knowing what dialect was overridden.", "// (see invoke_readfn_overridden_by below)", "options", "=", "options", "||", "{", "}", ";", "// normally we start with the close dialect (0)", "var", "startingDialect", "=", "options", ".", "startingDialect", "||", "0", ";", "// And normally we read the source text under the current position", "// unless they give us a token that's already been read)", "var", "token", "=", "options", ".", "token", ";", "if", "(", "!", "token", ")", "{", "// we *peek* when determining which readtab read function to call,", "// so the read functions can consume the *entire* form, including the", "// first token (which makes the design of the read functions easier", "// easier to understand and test in isolation).", "token", "=", "lexer", ".", "peek_token", "(", ")", ";", "}", "debug", "(", "'reading expression starting \"'", "+", "token", ".", "text", "+", "'\"'", ")", ";", "var", "form", "=", "retry", ";", "var", "readfn", ";", "// try the dialects from beginning (inner scope) to end (outer scope)...", "for", "(", "var", "i", "=", "startingDialect", ";", "isretry", "(", "form", ")", "&&", "i", "<", "lexer", ".", "dialects", ".", "length", ";", "i", "++", ")", "{", "var", "dialect", "=", "lexer", ".", "dialects", "[", "i", "]", ";", "debug", "(", "'looking for \"'", "+", "token", ".", "text", "+", "'\" in '", "+", "dialect", ".", "name", "+", "' readtab'", ")", ";", "readfn", "=", "findReadfn", "(", "dialect", ".", "readtab", ",", "token", ")", "if", "(", "readfn", ")", "{", "form", "=", "read_via_readfn", "(", "readfn", ",", "lexer", ",", "token", ".", "text", ")", ";", "if", "(", "!", "form", ")", "{", "lexer", ".", "error", "(", "'Invalid response from \"'", "+", "token", ".", "text", "+", "'\" readtab function in \"'", "+", "dialect", ".", "name", "+", "'\"'", ")", ";", "}", "}", "}", "// if we've tried all the dialects and either didn't find a match,", "// or found a match that returned \"reader.retry\"...", "if", "(", "isretry", "(", "form", ")", ")", "{", "// try all the dialects again, this time looking for \"__default\"", "// note: most likely this will get all the way to core's __default,", "// but dialect's *can* override __default if they need to, and", "// could e.g. \"selectively\" override it by returning reader.retry in", "// cases where they want core's __default to handle it instead.", "for", "(", "var", "i", "=", "startingDialect", ";", "isretry", "(", "form", ")", "&&", "i", "<", "lexer", ".", "dialects", ".", "length", ";", "i", "++", ")", "{", "var", "dialect", "=", "lexer", ".", "dialects", "[", "i", "]", ";", "debug", "(", "'looking for \"__default\" in '", "+", "dialect", ".", "name", "+", "' readtab'", ")", ";", "readfn", "=", "dialect", ".", "readtab", "!==", "undefined", "?", "dialect", ".", "readtab", "[", "'__default'", "]", ":", "undefined", ";", "if", "(", "readfn", ")", "{", "form", "=", "read_via_readfn", "(", "readfn", ",", "lexer", ",", "token", ".", "text", ")", ";", "if", "(", "!", "form", ")", "{", "lexer", ".", "error", "(", "'Invalid response for \"'", "+", "token", ".", "text", "+", "'\" returned by __default function in \"'", "+", "dialect", ".", "name", "+", "'\"'", ")", ";", "}", "}", "}", "}", "// this should never happen (because of __default) but JIC:", "if", "(", "!", "form", "||", "isretry", "(", "form", ")", ")", "{", "lexer", ".", "error", "(", "'No dialect handled the text starting \"'", "+", "lexer", ".", "snoop", "(", "10", ")", "+", "'...'", ")", ";", "}", "return", "form", ";", "}" ]

[ "Read", "the", "form", "under", "the", "current", "position", "using", "the", "closest", "scoped", "dialect", "that", "contains", "a", "matching", "entry", "in", "it", "s", "readtab", "." ]

[ "function", "pop_local_dialects", "(", "lexer", ",", "list", ")", "{", "if", "(", "list", "&&", "list", ".", "length", ">", "0", ")", "{", "// we go in reverse order since the most recently", "// used (pushed) dialects will be at the end", "for", "(", "var", "i", "=", "list", ".", "length", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "list", "[", "i", "]", ".", "dialect", ")", "{", "unuse_dialect", "(", "list", "[", "i", "]", ".", "dialect", ",", "lexer", ")", ";", "}", "}", "}", "}" ]

[ "pop", "any", "local", "dialects", "enabled", "within", "the", "scope", "of", "the", "provided", "list", "." ]

[ "function", "read_delimited_text", "(", "lexer", ",", "start", ",", "end", ",", "options", ")", "{", "options", "=", "options", "||", "{", "includeDelimiters", ":", "true", "}", ";", "var", "delimited", "=", "lexer", ".", "next_delimited_token", "(", "start", ",", "end", ",", "options", ")", ";", "return", "sl", ".", "atom", "(", "delimited", ")", ";", "}" ]

[ "scan", "some", "delimited", "text", "and", "get", "it", "as", "a", "string", "atom", "lexer", ".", "options", ".", "omitDelimiters", "=", "whether", "to", "include", "the", "include", "the", "delimiters", "or", "not" ]

[ "function", "symbol", "(", "lexer", ",", "text", ")", "{", "var", "token", "=", "lexer", ".", "next_token", "(", "text", ")", ";", "return", "sl", ".", "atom", "(", "text", ",", "{", "token", ":", "token", "}", ")", ";", "}" ]

[ "A", "symbol", "Use", "reader", ".", "symbol", "in", "their", "readtab", "to", "ensure", "the", "lexer", "scans", "the", "specified", "token", "text", "correctly", "as", "a", "symbol", "." ]

[ "function", "callback", "(", "req", ",", "res", ",", "resolve", ",", "reject", ",", "error", ",", "result", ",", "permissions", ",", "action", ")", "{", "if", "(", "error", ")", "{", "reqlog", ".", "error", "(", "'internal server error'", ",", "error", ")", ";", "if", "(", "exports", ".", "handleErrors", ")", "{", "responseBuilder", ".", "error", "(", "req", ",", "res", ",", "'INTERNAL_SERVER_ERROR'", ")", ";", "}", "else", "{", "reject", "(", "error", ")", ";", "}", "}", "else", "{", "// filter the result attributes to send only those that this userType can see", "// check if the result is an array, to iterate it", "if", "(", "Array", ".", "isArray", "(", "result", ")", ")", "{", "for", "(", "var", "i", "=", "0", ",", "length", "=", "result", ".", "length", ";", "i", "<", "length", ";", "i", "++", ")", "{", "result", "[", "i", "]", "=", "filterAttributes", "(", "result", "[", "i", "]", ",", "permissions", ")", ";", "}", "}", "else", "{", "result", "=", "filterAttributes", "(", "result", ",", "permissions", ")", ";", "}", "reqlog", ".", "info", "(", "action", "+", "'.success'", ",", "result", ")", ";", "resolve", "(", "result", ")", ";", "}", "/**\n\t * Delete the attributes that the activeUser cant see\n\t * @method filterAttributes\n\t * @param {object} object The result object\n\t * @param {object} permissions The permissions object\n\t * @return {object} The filtered object\n\t */", "function", "filterAttributes", "(", "object", ",", "permissions", ")", "{", "if", "(", "object", ")", "{", "var", "userType", "=", "req", ".", "activeUser", "&&", "req", ".", "activeUser", ".", "type", "||", "'null'", ";", "for", "(", "var", "attribute", "in", "object", ".", "_doc", ")", "{", "if", "(", "object", ".", "_doc", ".", "hasOwnProperty", "(", "attribute", ")", ")", "{", "// dont return this attribute when:", "if", "(", "!", "permissions", "[", "attribute", "]", "||", "// if this attribute is not defined in permissions", "permissions", "[", "attribute", "]", "[", "0", "]", "!==", "'null'", "&&", "// this attribute is not set as public", "permissions", "[", "attribute", "]", ".", "indexOf", "(", "userType", ")", "===", "-", "1", "&&", "// this attribute is not available to this userType", "userType", "!==", "'admin'", "// the user is not admin", ")", "{", "delete", "object", ".", "_doc", "[", "attribute", "]", ";", "}", "}", "}", "}", "return", "object", ";", "}", "}" ]

[ "Query", "callback", ".", "Handles", "errors", "filters", "attributes" ]

[ "function", "filterAttributes", "(", "object", ",", "permissions", ")", "{", "if", "(", "object", ")", "{", "var", "userType", "=", "req", ".", "activeUser", "&&", "req", ".", "activeUser", ".", "type", "||", "'null'", ";", "for", "(", "var", "attribute", "in", "object", ".", "_doc", ")", "{", "if", "(", "object", ".", "_doc", ".", "hasOwnProperty", "(", "attribute", ")", ")", "{", "// dont return this attribute when:", "if", "(", "!", "permissions", "[", "attribute", "]", "||", "// if this attribute is not defined in permissions", "permissions", "[", "attribute", "]", "[", "0", "]", "!==", "'null'", "&&", "// this attribute is not set as public", "permissions", "[", "attribute", "]", ".", "indexOf", "(", "userType", ")", "===", "-", "1", "&&", "// this attribute is not available to this userType", "userType", "!==", "'admin'", "// the user is not admin", ")", "{", "delete", "object", ".", "_doc", "[", "attribute", "]", ";", "}", "}", "}", "}", "return", "object", ";", "}" ]

[ "Delete", "the", "attributes", "that", "the", "activeUser", "cant", "see" ]

[ "function", "hasNext", "(", "cursor", ",", "callback", ")", "{", "const", "Cursor", "=", "require", "(", "'../cursor'", ")", ";", "if", "(", "cursor", ".", "s", ".", "currentDoc", ")", "{", "return", "callback", "(", "null", ",", "true", ")", ";", "}", "if", "(", "cursor", ".", "isNotified", "(", ")", ")", "{", "return", "callback", "(", "null", ",", "false", ")", ";", "}", "nextObject", "(", "cursor", ",", "(", "err", ",", "doc", ")", "=>", "{", "if", "(", "err", ")", "return", "callback", "(", "err", ",", "null", ")", ";", "if", "(", "cursor", ".", "s", ".", "state", "===", "Cursor", ".", "CLOSED", "||", "cursor", ".", "isDead", "(", ")", ")", "return", "callback", "(", "null", ",", "false", ")", ";", "if", "(", "!", "doc", ")", "return", "callback", "(", "null", ",", "false", ")", ";", "cursor", ".", "s", ".", "currentDoc", "=", "doc", ";", "callback", "(", "null", ",", "true", ")", ";", "}", ")", ";", "}" ]

[ "Check", "if", "there", "is", "any", "document", "still", "available", "in", "the", "cursor", "." ]

[ "function", "nextObject", "(", "cursor", ",", "callback", ")", "{", "const", "Cursor", "=", "require", "(", "'../cursor'", ")", ";", "if", "(", "cursor", ".", "s", ".", "state", "===", "Cursor", ".", "CLOSED", "||", "(", "cursor", ".", "isDead", "&&", "cursor", ".", "isDead", "(", ")", ")", ")", "return", "handleCallback", "(", "callback", ",", "MongoError", ".", "create", "(", "{", "message", ":", "'Cursor is closed'", ",", "driver", ":", "true", "}", ")", ")", ";", "if", "(", "cursor", ".", "s", ".", "state", "===", "Cursor", ".", "INIT", "&&", "cursor", ".", "s", ".", "cmd", ".", "sort", ")", "{", "try", "{", "cursor", ".", "s", ".", "cmd", ".", "sort", "=", "formattedOrderClause", "(", "cursor", ".", "s", ".", "cmd", ".", "sort", ")", ";", "}", "catch", "(", "err", ")", "{", "return", "handleCallback", "(", "callback", ",", "err", ")", ";", "}", "}", "// Get the next object", "cursor", ".", "_next", "(", "(", "err", ",", "doc", ")", "=>", "{", "cursor", ".", "s", ".", "state", "=", "Cursor", ".", "OPEN", ";", "if", "(", "err", ")", "return", "handleCallback", "(", "callback", ",", "err", ")", ";", "handleCallback", "(", "callback", ",", "null", ",", "doc", ")", ";", "}", ")", ";", "}" ]

[ "Get", "the", "next", "available", "document", "from", "the", "cursor", "returns", "null", "if", "no", "more", "documents", "are", "available", "." ]

[ "function", "toArray", "(", "cursor", ",", "callback", ")", "{", "const", "Cursor", "=", "require", "(", "'../cursor'", ")", ";", "const", "items", "=", "[", "]", ";", "// Reset cursor", "cursor", ".", "rewind", "(", ")", ";", "cursor", ".", "s", ".", "state", "=", "Cursor", ".", "INIT", ";", "// Fetch all the documents", "const", "fetchDocs", "=", "(", ")", "=>", "{", "cursor", ".", "_next", "(", "(", "err", ",", "doc", ")", "=>", "{", "if", "(", "err", ")", "{", "return", "cursor", ".", "_endSession", "?", "cursor", ".", "_endSession", "(", "(", ")", "=>", "handleCallback", "(", "callback", ",", "err", ")", ")", ":", "handleCallback", "(", "callback", ",", "err", ")", ";", "}", "if", "(", "doc", "==", "null", ")", "{", "return", "cursor", ".", "close", "(", "{", "skipKillCursors", ":", "true", "}", ",", "(", ")", "=>", "handleCallback", "(", "callback", ",", "null", ",", "items", ")", ")", ";", "}", "// Add doc to items", "items", ".", "push", "(", "doc", ")", ";", "// Get all buffered objects", "if", "(", "cursor", ".", "bufferedCount", "(", ")", ">", "0", ")", "{", "let", "docs", "=", "cursor", ".", "readBufferedDocuments", "(", "cursor", ".", "bufferedCount", "(", ")", ")", ";", "// Transform the doc if transform method added", "if", "(", "cursor", ".", "s", ".", "transforms", "&&", "typeof", "cursor", ".", "s", ".", "transforms", ".", "doc", "===", "'function'", ")", "{", "docs", "=", "docs", ".", "map", "(", "cursor", ".", "s", ".", "transforms", ".", "doc", ")", ";", "}", "push", ".", "apply", "(", "items", ",", "docs", ")", ";", "}", "// Attempt a fetch", "fetchDocs", "(", ")", ";", "}", ")", ";", "}", ";", "fetchDocs", "(", ")", ";", "}" ]

[ "Returns", "an", "array", "of", "documents", ".", "See", "Cursor", ".", "prototype", ".", "toArray", "for", "more", "information", "." ]

[ "function", "get", "(", "key", ",", "store", "=", "getDefaultStore", "(", ")", ")", "{", "let", "req", "return", "store", "[", "IDBStore", "]", "(", "'readonly'", ",", "store", "=>", "{", "req", "=", "store", ".", "get", "(", "key", ")", "}", ")", ".", "then", "(", "(", ")", "=>", "req", ".", "result", ")", "}" ]

[ "Get", "a", "value", "based", "on", "the", "provided", "key", "." ]

[ "function", "(", "config", ")", "{", "!", "is_obj", "(", "config", ")", "||", "Object", ".", "keys", "(", "config", ")", ".", "forEach", "(", "function", "(", "key", ")", "{", "if", "(", "typeof", "config", "[", "key", "]", "==", "'function'", "&&", "typeof", "this", "[", "key", "]", "==", "'function'", ")", "// this allows you to override a method for a", "this", "[", "__override__", "]", "(", "key", ",", "config", "[", "key", "]", ")", ";", "// specific instance of a Class, rather than require", "else", "// you extend the Class for a few minor changes", "this", "[", "key", "]", "=", "config", "[", "key", "]", ";", "// NB: can also be achieved by creating a `singleton`", "}", ",", "this", ")", ";", "util", ".", "def", "(", "this", ",", "__config__", ",", "{", "value", ":", "config", "}", ",", "'r'", ",", "true", ")", ";", "}" ]

[ "this", "is", "set", "by", "beforeinstance", "to", "avoid", "weird", "behaviour", "constructor", "methods" ]

[ "function", "makeBookmarkedTabItem", "(", "bm", ")", "{", "var", "urlStr", "=", "bm", ".", "url", ";", "if", "(", "!", "urlStr", ")", "{", "console", ".", "error", "(", "'makeBookmarkedTabItem: Malformed bookmark: missing URL!: '", ",", "bm", ")", ";", "urlStr", "=", "''", ";", "// better than null or undefined!", "}", "if", "(", "bm", ".", "title", "===", "undefined", ")", "{", "console", ".", "warn", "(", "'makeBookmarkedTabItem: Bookmark title undefined (ignoring...): '", ",", "bm", ")", ";", "}", "var", "tabItem", "=", "new", "TabItem", "(", "{", "url", ":", "urlStr", ",", "saved", ":", "true", ",", "savedTitle", ":", "_", ".", "get", "(", "bm", ",", "'title'", ",", "urlStr", ")", ",", "savedBookmarkId", ":", "bm", ".", "id", ",", "savedBookmarkIndex", ":", "bm", ".", "index", "}", ")", ";", "return", "tabItem", ";", "}" ]

[ "Initialize", "a", "TabItem", "from", "a", "bookmark" ]

[ "function", "makeOpenTabItem", "(", "tab", ")", "{", "var", "urlStr", "=", "tab", ".", "url", ";", "if", "(", "!", "urlStr", ")", "{", "console", ".", "error", "(", "'malformed tab -- no URL: '", ",", "tab", ")", ";", "urlStr", "=", "''", ";", "}", "/*\n if (!tab.title) {\n console.warn(\"tab missing title (ignoring...): \", tab);\n }\n */", "var", "tabItem", "=", "new", "TabItem", "(", "{", "url", ":", "urlStr", ",", "audible", ":", "tab", ".", "audible", ",", "favIconUrl", ":", "tab", ".", "favIconUrl", ",", "open", ":", "true", ",", "tabTitle", ":", "_", ".", "get", "(", "tab", ",", "'title'", ",", "urlStr", ")", ",", "openTabId", ":", "tab", ".", "id", ",", "active", ":", "tab", ".", "active", ",", "openTabIndex", ":", "tab", ".", "index", "}", ")", ";", "return", "tabItem", ";", "}" ]

[ "Initialize", "a", "TabItem", "from", "an", "open", "Chrome", "tab" ]

[ "function", "mergeOpenTabs", "(", "tabItems", ",", "openTabs", ")", "{", "var", "tabInfo", "=", "getOpenTabInfo", "(", "tabItems", ",", "openTabs", ")", ";", "/* TODO: Use algorithm from OLDtabWindow.js to determine tab order.\n * For now, let's just concat open and closed tabs, in their sorted order.\n */", "var", "openTabItems", "=", "tabInfo", ".", "get", "(", "true", ",", "Immutable", ".", "Seq", "(", ")", ")", ".", "sortBy", "(", "function", "(", "ti", ")", "{", "return", "ti", ".", "openTabIndex", ";", "}", ")", ";", "var", "closedTabItems", "=", "tabInfo", ".", "get", "(", "false", ",", "Immutable", ".", "Seq", "(", ")", ")", ".", "sortBy", "(", "function", "(", "ti", ")", "{", "return", "ti", ".", "savedBookmarkIndex", ";", "}", ")", ";", "var", "mergedTabItems", "=", "openTabItems", ".", "concat", "(", "closedTabItems", ")", ";", "return", "mergedTabItems", ";", "}" ]

[ "Merge", "currently", "open", "tabs", "from", "an", "open", "Chrome", "window", "with", "tabItem", "state", "of", "a", "saved", "tabWindow" ]

[ "function", "updateWindow", "(", "tabWindow", ",", "chromeWindow", ")", "{", "// console.log(\"updateWindow: \", tabWindow.toJS(), chromeWindow);", "var", "mergedTabItems", "=", "mergeOpenTabs", "(", "tabWindow", ".", "tabItems", ",", "chromeWindow", ".", "tabs", ")", ";", "var", "updWindow", "=", "tabWindow", ".", "set", "(", "'tabItems'", ",", "mergedTabItems", ")", ".", "set", "(", "'focused'", ",", "chromeWindow", ".", "focused", ")", ".", "set", "(", "'open'", ",", "true", ")", ".", "set", "(", "'openWindowId'", ",", "chromeWindow", ".", "id", ")", ";", "return", "updWindow", ";", "}" ]

[ "update", "a", "TabWindow", "from", "a", "current", "snapshot", "of", "the", "Chrome", "Window" ]

[ "function", "saveTab", "(", "tabWindow", ",", "tabItem", ",", "tabNode", ")", "{", "var", "_tabWindow$tabItems$f3", "=", "tabWindow", ".", "tabItems", ".", "findEntry", "(", "function", "(", "ti", ")", "{", "return", "ti", ".", "open", "&&", "ti", ".", "openTabId", "===", "tabItem", ".", "openTabId", ";", "}", ")", ";", "var", "_tabWindow$tabItems$f4", "=", "_slicedToArray", "(", "_tabWindow$tabItems$f3", ",", "1", ")", ";", "var", "index", "=", "_tabWindow$tabItems$f4", "[", "0", "]", ";", "var", "updTabItem", "=", "tabItem", ".", "set", "(", "'saved'", ",", "true", ")", ".", "set", "(", "'savedTitle'", ",", "tabNode", ".", "title", ")", ".", "set", "(", "'savedBookmarkId'", ",", "tabNode", ".", "id", ")", ".", "set", "(", "'savedBookmarkIndex'", ",", "tabNode", ".", "index", ")", ";", "var", "updItems", "=", "tabWindow", ".", "tabItems", ".", "splice", "(", "index", ",", "1", ",", "updTabItem", ")", ";", "return", "tabWindow", ".", "set", "(", "'tabItems'", ",", "updItems", ")", ";", "}" ]

[ "Update", "a", "tab", "s", "saved", "state" ]

[ "function", "pushin", "(", "path", ",", "record", ",", "setter", ",", "newValue", ")", "{", "var", "context", "=", "record", ";", "var", "parent", "=", "record", ";", "var", "lastPart", "=", "null", ";", "var", "_i", ";", "var", "_len", ";", "var", "part", ";", "var", "keys", ";", "for", "(", "_i", "=", "0", ",", "_len", "=", "path", ".", "length", ";", "_i", "<", "_len", ";", "_i", "++", ")", "{", "part", "=", "path", "[", "_i", "]", ";", "lastPart", "=", "part", ";", "parent", "=", "context", ";", "context", "=", "context", "[", "part", "]", ";", "if", "(", "sys", ".", "isNull", "(", "context", ")", "||", "sys", ".", "isUndefined", "(", "context", ")", ")", "{", "parent", "[", "part", "]", "=", "{", "}", ";", "context", "=", "parent", "[", "part", "]", ";", "}", "}", "if", "(", "sys", ".", "isEmpty", "(", "setter", ")", "||", "setter", "===", "'$set'", ")", "{", "parent", "[", "lastPart", "]", "=", "newValue", ";", "return", "parent", "[", "lastPart", "]", ";", "}", "else", "{", "switch", "(", "setter", ")", "{", "case", "'$inc'", ":", "/**\n\t\t\t\t * Increments a field by the amount you specify. It takes the form\n\t\t\t\t * `{ $inc: { field1: amount } }`\n\t\t\t\t * @name $inc\n\t\t\t\t * @memberOf module:document/probe.updateOperators\n\t\t\t\t * @example\n\t\t\t\t * var probe = require(\"document/probe\");\n\t\t\t\t * probe.update( obj, {'name.last' : 'Owen', 'name.first' : 'LeRoy'},\n\t\t\t\t * {$inc : {'password.changes' : 2}} );\n\t\t\t\t */", "if", "(", "!", "sys", ".", "isNumber", "(", "newValue", ")", ")", "{", "newValue", "=", "1", ";", "}", "if", "(", "sys", ".", "isNumber", "(", "parent", "[", "lastPart", "]", ")", ")", "{", "parent", "[", "lastPart", "]", "=", "parent", "[", "lastPart", "]", "+", "newValue", ";", "return", "parent", "[", "lastPart", "]", ";", "}", "break", ";", "case", "'$dec'", ":", "/**\n\t\t\t\t * Decrements a field by the amount you specify. It takes the form\n\t\t\t\t * `{ $dec: { field1: amount }`\n * @name $dec\n\t\t\t\t * @memberOf module:document/probe.updateOperators\n\t\t\t\t * @example\n\t\t\t\t * var probe = require(\"document/probe\");\n\t\t\t\t * probe.update( obj, {'name.last' : 'Owen', 'name.first' : 'LeRoy'},\n\t\t\t\t * {$dec : {'password.changes' : 2}} );\n\t\t\t\t */", "if", "(", "!", "sys", ".", "isNumber", "(", "newValue", ")", ")", "{", "newValue", "=", "1", ";", "}", "if", "(", "sys", ".", "isNumber", "(", "parent", "[", "lastPart", "]", ")", ")", "{", "parent", "[", "lastPart", "]", "=", "parent", "[", "lastPart", "]", "-", "newValue", ";", "return", "parent", "[", "lastPart", "]", ";", "}", "break", ";", "case", "'$unset'", ":", "/**\n\t\t\t\t * Removes the field from the object. It takes the form\n\t\t\t\t * `{ $unset: { field1: \"\" } }`\n\t\t\t\t * @name $unset\n\t\t\t\t * @memberOf module:document/probe.updateOperators\n\t\t\t\t * @example\n\t\t\t\t * var probe = require(\"document/probe\");\n\t\t\t\t * probe.update( data, {'name.first' : 'Yogi'}, {$unset : {'name.first' : ''}} );\n\t\t\t\t */", "return", "delete", "parent", "[", "lastPart", "]", ";", "case", "'$pop'", ":", "/**\n\t\t\t\t * The $pop operator removes the first or last element of an array. Pass $pop a value of 1 to remove the last element\n\t\t\t\t * in an array and a value of -1 to remove the first element of an array. This will only work on arrays. Syntax:\n\t\t\t\t * `{ $pop: { field: 1 } }` or `{ $pop: { field: -1 } }`\n\t\t\t\t * @name $pop\n\t\t\t\t * @memberOf module:document/probe.updateOperators\n\t\t\t\t * @example\n\t\t\t\t * var probe = require(\"document/probe\");\n\t\t\t\t * // attr is the name of the array field\n\t\t\t\t * probe.update( data, {_id : '511d18827da2b88b09000133'}, {$pop : {attr : 1}} );\n\t\t\t\t */", "if", "(", "sys", ".", "isArray", "(", "parent", "[", "lastPart", "]", ")", ")", "{", "if", "(", "!", "sys", ".", "isNumber", "(", "newValue", ")", ")", "{", "newValue", "=", "1", ";", "}", "if", "(", "newValue", "===", "1", ")", "{", "return", "parent", "[", "lastPart", "]", ".", "pop", "(", ")", ";", "}", "else", "{", "return", "parent", "[", "lastPart", "]", ".", "shift", "(", ")", ";", "}", "}", "break", ";", "case", "'$push'", ":", "/**\n\t\t\t\t * The $push operator appends a specified value to an array. It looks like this:\n\t\t\t\t * `{ $push: { <field>: <value> } }`\n\t\t\t\t * @name $push\n\t\t\t\t * @memberOf module:document/probe.updateOperators\n\t\t\t\t * @example\n\t\t\t\t * var probe = require(\"document/probe\");\n\t\t\t\t * // attr is the name of the array field\n\t\t\t\t * probe.update( data, {_id : '511d18827da2b88b09000133'},\n\t\t\t\t * {$push : {attr : {\"hand\" : \"new\", \"color\" : \"new\"}}} );\n\t\t\t\t */", "if", "(", "sys", ".", "isArray", "(", "parent", "[", "lastPart", "]", ")", ")", "{", "return", "parent", "[", "lastPart", "]", ".", "push", "(", "newValue", ")", ";", "}", "break", ";", "case", "'$pull'", ":", "/**\n\t\t\t\t * The $pull operator removes all instances of a value from an existing array. It looks like this:\n\t\t\t\t * `{ $pull: { field: <query> } }`\n\t\t\t\t * @name $pull\n\t\t\t\t * @memberOf module:document/probe.updateOperators\n\t\t\t\t * @example\n\t\t\t\t * var probe = require(\"document/probe\");\n\t\t\t\t * // attr is the name of the array field\n\t\t\t\t * probe.update( data, {'email' : '[email protected]'},\n\t\t\t\t * {$pull : {attr : {\"color\" : \"green\"}}} );\n\t\t\t\t */", "if", "(", "sys", ".", "isArray", "(", "parent", "[", "lastPart", "]", ")", ")", "{", "keys", "=", "exports", ".", "findKeys", "(", "parent", "[", "lastPart", "]", ",", "newValue", ")", ";", "sys", ".", "each", "(", "keys", ",", "function", "(", "val", ",", "index", ")", "{", "return", "delete", "parent", "[", "lastPart", "]", "[", "index", "]", ";", "}", ")", ";", "parent", "[", "lastPart", "]", "=", "sys", ".", "compact", "(", "parent", "[", "lastPart", "]", ")", ";", "return", "parent", "[", "lastPart", "]", ";", "}", "}", "}", "}" ]

[ "This", "will", "write", "the", "value", "into", "a", "record", "at", "the", "path", "creating", "intervening", "objects", "if", "they", "don", "t", "exist" ]

[ "function", "handle", "(", "options", ",", "callback", ")", "{", "if", "(", "_", ".", "isString", "(", "options", ")", ")", "{", "options", "=", "{", "path", ":", "options", "}", ";", "}", "if", "(", "_", ".", "isObject", "(", "options", ")", ")", "{", "const", "opts", "=", "{", "}", ";", "_", ".", "merge", "(", "opts", ",", "config", ",", "options", ")", ";", "options", "=", "opts", ";", "}", "else", "{", "options", "=", "_", ".", "cloneDeep", "(", "config", ")", ";", "}", "options", ".", "path", "=", "options", ".", "path", "||", "config", ".", "get", "(", "\"home\"", ")", ";", "return", "stat", "(", "options", ".", "path", ",", "function", "(", "err", ",", "stats", ")", "{", "if", "(", "err", ")", "{", "return", "callback", "(", "err", ")", ";", "}", "const", "done", "=", "wrap", "(", "stats", ",", "callback", ")", ";", "if", "(", "stats", ".", "isDirectory", "(", ")", ")", "{", "options", ".", "dirStats", "=", "stats", ";", "return", "processDir", "(", "options", ",", "done", ")", ";", "}", "else", "if", "(", "stats", ".", "isFile", "(", ")", ")", "{", "return", "processFile", "(", "options", ",", "done", ")", ";", "}", "return", "callback", "(", "null", ",", "null", ")", ";", "}", ")", ";", "}" ]

[ "Handling", "requests", "for", "browsing", "file", "-", "system" ]

[ "function", "Component", "(", "opts", ")", "{", "if", "(", "typeof", "opts", "===", "\"function\"", ")", "{", "var", "_constructor", "=", "opts", ";", "opts", "=", "null", ";", "return", "register", "(", "_constructor", ")", ";", "}", "opts", "=", "opts", "||", "{", "}", ";", "var", "_opts", "=", "opts", ";", "var", "_opts$restrict", "=", "_opts", ".", "restrict", ";", "var", "restrict", "=", "_opts$restrict", "===", "undefined", "?", "\"EA\"", ":", "_opts$restrict", ";", "var", "_opts$replace", "=", "_opts", ".", "replace", ";", "var", "replace", "=", "_opts$replace", "===", "undefined", "?", "false", ":", "_opts$replace", ";", "var", "_opts$transclude", "=", "_opts", ".", "transclude", ";", "var", "transclude", "=", "_opts$transclude", "===", "undefined", "?", "false", ":", "_opts$transclude", ";", "var", "_opts$scope", "=", "_opts", ".", "scope", ";", "var", "scope", "=", "_opts$scope", "===", "undefined", "?", "{", "}", ":", "_opts$scope", ";", "var", "template", "=", "_opts", ".", "template", ";", "var", "templateUrl", "=", "_opts", ".", "templateUrl", ";", "return", "register", ";", "function", "register", "(", "constructor", ")", "{", "(", "0", ",", "_Controller", ".", "Controller", ")", "(", "constructor", ")", ";", "var", "meta", "=", "(", "0", ",", "_utils", ".", "funcMeta", ")", "(", "constructor", ")", ";", "var", "name", "=", "meta", ".", "name", ";", "name", "=", "name", "[", "0", "]", ".", "toLowerCase", "(", ")", "+", "name", ".", "substr", "(", "1", ",", "name", ".", "length", "-", "DEFAULT_SUFFIX", ".", "length", "-", "1", ")", ";", "if", "(", "!", "template", "&&", "!", "templateUrl", "&&", "template", "!==", "false", ")", "{", "var", "tmplName", "=", "(", "0", ",", "_utils", ".", "dashCase", ")", "(", "name", ")", ";", "templateUrl", "=", "\"./components/\"", "+", "tmplName", "+", "\"/\"", "+", "tmplName", "+", "\".html\"", ";", "}", "if", "(", "template", "===", "false", ")", "{", "template", "=", "undefined", ";", "templateUrl", "=", "undefined", ";", "}", "_app", ".", "app", ".", "directive", "(", "name", ",", "function", "(", ")", "{", "return", "{", "restrict", ":", "restrict", ",", "scope", ":", "scope", ",", "bindToController", ":", "true", ",", "controller", ":", "meta", ".", "controller", ".", "name", ",", "controllerAs", ":", "name", ",", "template", ":", "template", ",", "templateUrl", ":", "templateUrl", ",", "replace", ":", "replace", ",", "transclude", ":", "transclude", "}", ";", "}", ")", ";", "}", "}" ]

[ "Declare", "an", "angular", "Component", "directive", "." ]

[ "function", "safesocket", "(", "expected", ",", "fn", ")", "{", "return", "function", "(", ")", "{", "var", "_args", "=", "[", "]", ";", "for", "(", "var", "idx", "in", "arguments", ")", "{", "_args", ".", "push", "(", "arguments", "[", "idx", "]", ")", ";", "}", "var", "args", "=", "_args", ".", "filter", "(", "notFunction", ")", ".", "slice", "(", "0", ",", "expected", ")", ";", "for", "(", "var", "i", "=", "args", ".", "length", ";", "i", "<", "expected", ";", "i", "++", ")", "{", "args", ".", "push", "(", "undefined", ")", ";", "}", "var", "arg", "=", "_args", ".", "pop", "(", ")", ";", "args", ".", "push", "(", "(", "arg", "instanceof", "Function", ")", "?", "arg", ":", "noop", ")", ";", "fn", ".", "apply", "(", "this", ",", "args", ")", ";", "}", ";", "}" ]

[ "Wraps", "socket", ".", "io", "event", "handlers", "to", "prevent", "crashes", "from", "certain", "malicious", "inputs", "." ]

[ "function", "Scrib", "(", "adapters", ",", "callback", ")", "{", "EventEmitter", ".", "call", "(", "this", ")", ";", "// Convert array to object", "if", "(", "Array", ".", "isArray", "(", "adapters", ")", ")", "{", "var", "am", "=", "adapters", ";", "adapters", "=", "{", "}", ";", "am", ".", "forEach", "(", "function", "(", "m", ")", "{", "adapters", "[", "m", "]", "=", "{", "}", ";", "}", ")", ";", "}", "var", "all", "=", "[", "]", ",", "self", "=", "this", ";", "for", "(", "var", "m", "in", "adapters", ")", "{", "try", "{", "var", "adapter", ";", "try", "{", "adapter", "=", "require", "(", "\"scrib-\"", "+", "m", ")", ";", "}", "catch", "(", "e", ")", "{", "adapter", "=", "require", "(", "path", ".", "join", "(", "path", ".", "dirname", "(", "module", ".", "parent", ".", "filename", ")", ",", "m", ")", ")", ";", "}", "all", ".", "push", "(", "async", ".", "apply", "(", "adapter", ",", "self", ",", "adapters", "[", "m", "]", ")", ")", ";", "}", "catch", "(", "e", ")", "{", "return", "callback", "(", "e", ")", ";", "}", "}", "async", ".", "parallel", "(", "all", ",", "function", "done", "(", "err", ")", "{", "callback", "(", "err", ")", ";", "}", ")", ";", "}" ]

[ "Initalizes", "a", "new", "logger" ]

[ "function", "(", "header", ",", "key", ",", "cert", ")", "{", "var", "parsedHeader", ";", "if", "(", "header", ")", "{", "if", "(", "!", "header", ".", "isBase64", "(", ")", ")", "{", "throw", "new", "CError", "(", "'missing header or wrong format'", ")", ".", "log", "(", ")", ";", "}", "else", "{", "parsedHeader", "=", "JSON", ".", "parse", "(", "forge", ".", "util", ".", "decode64", "(", "header", ")", ")", ";", "this", ".", "isModeAllowed", ".", "call", "(", "this", ",", "parsedHeader", ".", "payload", ".", "mode", ")", ";", "}", "var", "Handshake", "=", "app", ".", "class", ".", "Handshake", ",", "Authentication", "=", "app", ".", "class", ".", "Authentication", ",", "Authorization", "=", "app", ".", "class", ".", "Authorization", ",", "mode", "=", "parsedHeader", ".", "payload", ".", "mode", ",", "sid", "=", "parsedHeader", ".", "payload", ".", "sid", ",", "result", "=", "{", "}", ";", "var", "options", "=", "{", "sid", ":", "sid", ",", "key", ":", "key", "||", "config", ".", "key", ",", "cert", ":", "cert", "||", "config", ".", "cert", "}", ";", "switch", "(", "mode", ")", "{", "case", "'handshake'", ":", "result", ".", "header", "=", "new", "Handshake", "(", "options", ")", ";", "break", ";", "case", "'auth-init'", ":", "result", ".", "header", "=", "new", "Authentication", "(", "options", ")", ";", "break", ";", "default", ":", "result", ".", "header", "=", "new", "Authorization", "(", "options", ")", ";", "break", ";", "}", "try", "{", "var", "ecryptedSecret", "=", "parsedHeader", ".", "payload", ".", "secret", ";", "if", "(", "ecryptedSecret", ")", "{", "var", "secret", "=", "result", ".", "header", ".", "keychain", ".", "decryptRsa", "(", "ecryptedSecret", ")", ";", "result", ".", "header", ".", "setSecret", "(", "secret", ")", ";", "}", "parsedHeader", ".", "content", "=", "result", ".", "header", ".", "decryptContent", "(", "parsedHeader", ".", "content", ")", ";", "}", "catch", "(", "e", ")", "{", "throw", "new", "CError", "(", "{", "body", ":", "{", "code", ":", "'ImATeapot'", ",", "message", ":", "'unable to decrypt content'", ",", "cause", ":", "e", "}", "}", ")", ".", "log", "(", "'body'", ")", ";", "}", "delete", "result", ".", "header", ";", "if", "(", "debug", ")", "{", "log", ".", "debug", "(", "'%s parsed header'", ",", "app", ".", "name", ")", ";", "log", ".", "debug", "(", "parsedHeader", ")", ";", "}", "}", "return", "parsedHeader", ";", "}" ]

[ "Parse", "the", "Authorization", "header" ]

[ "function", "(", "data", ")", "{", "try", "{", "data", "=", "data", "||", "this", ".", "getContent", "(", ")", ";", "return", "this", ".", "keychain", ".", "sign", "(", "JSON", ".", "stringify", "(", "data", ")", ")", ";", "}", "catch", "(", "e", ")", "{", "throw", "new", "CError", "(", "{", "body", ":", "{", "code", ":", "'ImATeapot'", ",", "message", ":", "'unable to sign content'", ",", "cause", ":", "e", "}", "}", ")", ".", "log", "(", "'body'", ")", ";", "}", "}" ]

[ "Generate", "a", "signature", "for", "for", "data", "or", "content", "property" ]

[ "function", "(", ")", "{", "var", "content", "=", "this", ".", "getContent", "(", ")", ";", "var", "out", "=", "{", "payload", ":", "this", ".", "getPayload", "(", ")", ",", "content", ":", "this", ".", "cryptContent", "(", "content", ")", ",", "signature", ":", "this", ".", "generateSignature", "(", ")", "}", ";", "if", "(", "debug", ")", "{", "log", ".", "debug", "(", "'%s encode with sid %s'", ",", "app", ".", "name", ",", "out", ".", "payload", ".", "sid", ")", ";", "log", ".", "debug", "(", "'%s encode with token %s'", ",", "app", ".", "name", ",", "content", ".", "token", ")", ";", "}", "return", "forge", ".", "util", ".", "encode64", "(", "JSON", ".", "stringify", "(", "out", ")", ")", ";", "}" ]

[ "Encode", "the", "header", "including", "payload", "content", "and", "signature" ]

[ "function", "stringIterator", "(", "str", ")", "{", "let", "index", "=", "0", ";", "return", "{", "next", "(", ")", "{", "return", "index", "<", "bmpLength", "(", "str", ")", "?", "{", "value", ":", "bmpCharAt", "(", "str", ",", "index", "++", ")", ",", "done", ":", "false", "}", ":", "{", "done", ":", "true", "}", ";", "}", "}", ";", "}" ]

[ "Creates", "an", "iterator", "over", "strings", ".", "ES2015", "strings", "already", "satisfy", "the", "iterator", "protocol", "so", "this", "function", "will", "not", "be", "used", "for", "them", ".", "This", "is", "for", "ES5", "strings", "where", "the", "iterator", "protocol", "doesn", "t", "exist", ".", "As", "with", "ES2015", "iterators", "it", "takes", "into", "account", "double", "-", "width", "BMP", "characters", "and", "will", "return", "the", "entire", "character", "as", "a", "two", "-", "character", "string", "." ]

[ "function", "objectIterator", "(", "obj", ",", "sort", ",", "kv", "=", "false", ")", "{", "let", "keys", "=", "Object", ".", "keys", "(", "obj", ")", ";", "keys", "=", "typeof", "sort", "===", "'function'", "?", "keys", ".", "sort", "(", "sort", ")", ":", "keys", ".", "sort", "(", ")", ";", "let", "index", "=", "0", ";", "return", "{", "next", "(", ")", "{", "if", "(", "index", "<", "keys", ".", "length", ")", "{", "const", "k", "=", "keys", "[", "index", "++", "]", ";", "const", "value", "=", "{", "}", ";", "if", "(", "kv", ")", "{", "value", ".", "k", "=", "k", ";", "value", ".", "v", "=", "obj", "[", "k", "]", ";", "}", "else", "{", "value", "[", "k", "]", "=", "obj", "[", "k", "]", ";", "}", "return", "{", "value", ",", "done", ":", "false", "}", ";", "}", "return", "{", "done", ":", "true", "}", ";", "}", "}", ";", "}" ]

[ "Creates", "an", "iterator", "over", "objcts", "." ]

[ "function", "functionIterator", "(", "fn", ")", "{", "return", "function", "*", "(", ")", "{", "let", "current", ";", "let", "index", "=", "0", ";", "for", "(", ";", ";", ")", "{", "current", "=", "fn", "(", "index", "++", ",", "current", ")", ";", "if", "(", "current", "===", "undefined", ")", "{", "break", ";", "}", "yield", "current", ";", "}", "}", "(", ")", ";", "}" ]

[ "Creates", "an", "iterator", "that", "runs", "a", "function", "for", "each", "next", "value", "." ]

[ "function", "isKvFormObject", "(", "obj", ")", "{", "const", "keys", "=", "Object", ".", "keys", "(", "obj", ")", ";", "if", "(", "keys", ".", "length", "!==", "2", ")", "{", "return", "false", ";", "}", "return", "!", "!", "~", "keys", ".", "indexOf", "(", "'k'", ")", "&&", "!", "!", "~", "keys", ".", "indexOf", "(", "'v'", ")", ";", "}" ]

[ "Determines", "whether", "an", "object", "is", "in", "kv", "-", "form", ".", "This", "used", "by", "the", "reducers", "that", "must", "recognize", "this", "form", "and", "reduce", "those", "elements", "back", "into", "key", "-", "value", "form", "." ]

[ "function", "isIterable", "(", "obj", ")", "{", "return", "isImplemented", "(", "obj", ",", "'iterator'", ")", "||", "isString", "(", "obj", ")", "||", "isArray", "(", "obj", ")", "||", "isObject", "(", "obj", ")", ";", "}" ]

[ "Determines", "whether", "the", "passed", "object", "is", "iterable", "in", "terms", "of", "what", "iterable", "means", "to", "this", "library", ".", "In", "other", "words", "objects", "and", "ES5", "arrays", "and", "strings", "will", "return", "true", "as", "will", "objects", "with", "a", "next", "function", ".", "For", "that", "reason", "this", "function", "is", "only", "really", "useful", "within", "the", "library", "and", "therefore", "isn", "t", "exported", "." ]

[ "function", "relationship", "(", "mood", ")", "{", "var", "verb", "=", "void", "0", ",", "talk", "=", "void", "0", ";", "if", "(", "mood", "===", "\"good\"", ")", "{", "verb", "=", "\"strengthened\"", ";", "talk", "=", "\"discussion\"", ";", "}", "else", "{", "verb", "=", "\"strained\"", ";", "talk", "=", "\"argument\"", ";", "}", "var", "familiar_people", "=", "_word_library2", ".", "default", ".", "getWords", "(", "\"familiar_people\"", ")", ";", "var", "conversation_topics", "=", "_word_library2", ".", "default", ".", "getWords", "(", "\"conversation_topics\"", ")", ";", "var", "person", "=", "nu", ".", "chooseFrom", "(", "familiar_people", ")", ";", "var", "topic", "=", "nu", ".", "chooseFrom", "(", "conversation_topics", ")", ";", "var", "sentence", "=", "'Your relationship with '", "+", "person", "+", "' may be '", "+", "verb", "+", "' '", ";", "sentence", "+=", "'as the result of '", "+", "nu", ".", "an", "(", "talk", ")", "+", "' about '", "+", "topic", ";", "return", "nu", ".", "sentenceCase", "(", "sentence", ")", ";", "}" ]

[ "Generate", "a", "mood", "-", "based", "sentence", "about", "a", "relationship" ]

[ "function", "datePredict", "(", ")", "{", "var", "daysAhead", "=", "Math", ".", "floor", "(", "Math", ".", "random", "(", ")", "*", "5", ")", "+", "2", ";", "var", "day", "=", "new", "Date", "(", ")", ";", "day", ".", "setDate", "(", "day", ".", "getDate", "(", ")", "+", "daysAhead", ")", ";", "var", "monthStr", "=", "(", "0", ",", "_dateformat2", ".", "default", ")", "(", "day", ",", "\"mmmm\"", ")", ";", "var", "dayStr", "=", "(", "0", ",", "_dateformat2", ".", "default", ")", "(", "day", ",", "\"d\"", ")", ";", "var", "rnum", "=", "Math", ".", "floor", "(", "Math", ".", "random", "(", ")", "*", "10", ")", ";", "var", "str", "=", "void", "0", ";", "if", "(", "rnum", "<=", "4", ")", "{", "str", "=", "monthStr", "+", "' '", "+", "dayStr", "+", "' will be an important day for you'", ";", "}", "else", "if", "(", "rnum", "<=", "7", ")", "{", "str", "=", "'Interesting things await you on '", "+", "monthStr", "+", "' '", "+", "dayStr", ";", "}", "else", "{", "str", "=", "'The events of '", "+", "monthStr", "+", "' '", "+", "dayStr", "+", "' have the potential to change your life.'", ";", "}", "return", "nu", ".", "sentenceCase", "(", "str", ")", ";", "}" ]

[ "Generate", "a", "random", "prediction", "sentence", "containing", "a", "date", "." ]

[ "function", "modifyStatsObject", "(", "stats", ",", "path", ")", "{", "stats", ".", "path", "=", "path", ";", "stats", ".", "basename", "=", "fs", ".", "basename", "(", "path", ")", ";", "stats", ".", "dirname", "=", "fs", ".", "dirname", "(", "path", ")", ";", "stats", ".", "extname", "=", "fs", ".", "extname", "(", "path", ")", ";", "return", "stats", ";", "}" ]

[ "Update", "the", "stats", "object", "returned", "by", "methods", "using", "fs", ".", "Stats", "." ]

[ "function", "parse", "(", ")", "{", "var", "msie", "=", "/", "MSIE.(\\d+)", "/", "i", ".", "exec", "(", "ua", ")", ";", "var", "rv", "=", "/", "Trident.+rv:(\\d+)", "/", "i", ".", "exec", "(", "ua", ")", ";", "var", "version", "=", "msie", "||", "rv", "||", "undefined", ";", "return", "version", "?", "+", "version", "[", "1", "]", ":", "version", ";", "}" ]

[ "Get", "IE", "major", "version", "number" ]

[ "function", "stat", "(", "path", ",", "callback", ")", "{", "if", "(", "!", "callback", ")", "return", "stat", ".", "bind", "(", "this", ",", "path", ")", ";", "fs", ".", "lstat", "(", "path", ",", "function", "(", "err", ",", "stat", ")", "{", "if", "(", "err", ")", "return", "callback", "(", "err", ")", ";", "var", "ctime", "=", "stat", ".", "ctime", "/", "1000", ";", "var", "cseconds", "=", "Math", ".", "floor", "(", "ctime", ")", ";", "var", "mtime", "=", "stat", ".", "mtime", "/", "1000", ";", "var", "mseconds", "=", "Math", ".", "floor", "(", "mtime", ")", ";", "var", "mode", ";", "if", "(", "stat", ".", "isSymbolicLink", "(", ")", ")", "{", "mode", "=", "0120000", ";", "}", "else", "if", "(", "stat", ".", "mode", "&", "0111", ")", "{", "mode", "=", "0100755", ";", "}", "else", "{", "mode", "=", "0100644", ";", "}", "callback", "(", "null", ",", "{", "ctime", ":", "[", "cseconds", ",", "Math", ".", "floor", "(", "(", "ctime", "-", "cseconds", ")", "*", "1000000000", ")", "]", ",", "mtime", ":", "[", "mseconds", ",", "Math", ".", "floor", "(", "(", "mtime", "-", "mseconds", ")", "*", "1000000000", ")", "]", ",", "dev", ":", "stat", ".", "dev", ",", "ino", ":", "stat", ".", "ino", ",", "mode", ":", "mode", ",", "uid", ":", "stat", ".", "uid", ",", "gid", ":", "stat", ".", "gid", ",", "size", ":", "stat", ".", "size", "}", ")", ";", "}", ")", ";", "}" ]

[ "Given", "a", "path", "return", "a", "continuable", "for", "the", "stat", "object", "." ]

[ "function", "find", "(", "param", ")", "{", "var", "fn", ",", "asInt", "=", "Number", "(", "param", ")", ";", "fn", "=", "isNaN", "(", "asInt", ")", "?", "findBySlug", ":", "findById", ";", "fn", ".", "apply", "(", "null", ",", "arguments", ")", ";", "}" ]

[ "Smart", "find", "uses", "findBySlug", "or", "findById" ]

[ "function", "update", "(", "id", ",", "body", ",", "cb", ")", "{", "body", ".", "updated_at", "=", "new", "Date", "(", ")", ";", "var", "q", "=", "qb", ".", "update", "(", "id", ",", "body", ")", ";", "db", ".", "getClient", "(", "function", "(", "err", ",", "client", ",", "done", ")", "{", "client", ".", "query", "(", "q", "[", "0", "]", ",", "q", "[", "1", "]", ",", "function", "(", "err", ",", "r", ")", "{", "var", "result", "=", "r", "&&", "r", ".", "rows", "[", "0", "]", ";", "if", "(", "!", "err", "&&", "!", "result", ")", "{", "err", "=", "new", "exceptions", ".", "NotFound", "(", ")", ";", "}", "if", "(", "err", ")", "{", "cb", "(", "err", ")", ";", "done", "(", "err", ")", ";", "}", "else", "{", "cb", "(", "null", ",", "result", ")", ";", "done", "(", ")", ";", "}", "}", ")", ";", "}", ")", ";", "}" ]

[ "Updates", "post", "with", "id" ]

[ "function", "archive", "(", "cb", ")", "{", "db", ".", "getClient", "(", "function", "(", "err", ",", "client", ",", "done", ")", "{", "client", ".", "query", "(", "qb", ".", "select", "(", ")", "+", "' WHERE published = true'", ",", "function", "(", "err", ",", "r", ")", "{", "if", "(", "err", ")", "{", "cb", "(", "err", ")", ";", "done", "(", "err", ")", ";", "}", "else", "{", "cb", "(", "null", ",", "r", ".", "rows", ")", ";", "done", "(", ")", ";", "}", "}", ")", ";", "}", ")", ";", "}" ]

[ "Returns", "all", "published", "posts", "without", "pagination", "support" ]

[ "function", "getTargetSize", "(", "size", ",", "buffer", ")", "{", "size", "*=", "1000000", ";", "// Converting to MB to B.", "// 10% is default.", "buffer", "=", "1", "+", "(", "buffer", "?", "buffer", "/", "100", ":", "0.1", ")", ";", "return", "Math", ".", "round", "(", "size", "*", "buffer", ")", ";", "}" ]

[ "Gets", "the", "desired", "file", "size", "for", "the", "resize", "." ]

[ "function", "shrinkImage", "(", "base64Image", ",", "targetSize", ")", "{", "return", "new", "Promise", "(", "(", "resolve", ",", "reject", ")", "=>", "{", "let", "canvas", "=", "document", ".", "createElement", "(", "'canvas'", ")", ";", "let", "image", "=", "new", "Image", "(", ")", ";", "image", ".", "onload", "=", "_", "=>", "{", "canvas", ".", "height", "=", "image", ".", "naturalHeight", ";", "canvas", ".", "width", "=", "image", ".", "naturalWidth", ";", "canvas", ".", "getContext", "(", "'2d'", ")", ".", "drawImage", "(", "image", ",", "0", ",", "0", ")", ";", "return", "resolve", "(", "shrink", "(", "95", ")", ")", ";", "function", "shrink", "(", "quality", ")", "{", "let", "redrawnImage", "=", "canvas", ".", "toDataURL", "(", "'image/jpeg'", ",", "quality", "/", "100", ")", ";", "// 1. Stop at zero because quality can't get any worse!", "// 2. Base64 encoded images are 1.33 times larger than once they are converted back to a blob.", "return", "quality", "!==", "0", "&&", "redrawnImage", ".", "length", "/", "1.33", ">", "targetSize", "?", "shrink", "(", "quality", "-", "5", ")", ":", "redrawnImage", ";", "}", "}", ";", "image", ".", "src", "=", "base64Image", ";", "}", ")", ";", "}" ]

[ "Rewrites", "base64", "image", "using", "canvas", "until", "it", "is", "down", "to", "desired", "file", "size", "." ]

[ "function", "base64ToBlob", "(", "base64Image", ",", "contentType", ")", "{", "// http://stackoverflow.com/questions/16245767/creating-a-blob-from-a-base64-string-in-javascript", "// Remove leading 'data:image/jpeg;base64,' or 'data:image/png;base64,'", "base64Image", "=", "base64Image", ".", "split", "(", "','", ")", "[", "1", "]", ";", "let", "byteCharacters", "=", "atob", "(", "base64Image", ")", ";", "// http://stackoverflow.com/questions/6259515/javascript-elegant-way-to-split-string-into-segments-n-characters-long", "let", "byteArrays", "=", "byteCharacters", ".", "match", "(", "/", "[\\s\\S]{1,512}", "/", "g", ")", ".", "map", "(", "slice", "=>", "{", "let", "byteNumbers", "=", "slice", ".", "split", "(", "''", ")", ".", "map", "(", "x", "=>", "x", ".", "charCodeAt", "(", "0", ")", ")", ";", "return", "new", "Uint8Array", "(", "byteNumbers", ")", ";", "}", ")", ";", "let", "blob", "=", "new", "Blob", "(", "byteArrays", ",", "{", "type", ":", "contentType", "||", "'image/jpg'", "/* or 'image/png' */", "}", ")", ";", "return", "blob", ";", "}" ]

[ "Converts", "Base64", "image", "into", "a", "blob", "file", "." ]

[ "function", "convertImageToBase64", "(", "image", ")", "{", "let", "fileReader", "=", "new", "FileReader", "(", ")", ";", "return", "new", "Promise", "(", "(", "resolve", ",", "reject", ")", "=>", "{", "fileReader", ".", "onload", "=", "fileLoadedEvent", "=>", "resolve", "(", "fileLoadedEvent", ".", "target", ".", "result", ")", ";", "fileReader", ".", "readAsDataURL", "(", "image", ")", ";", "}", ")", ";", "}" ]

[ "Gets", "image", "height", "and", "width", "in", "pixels", "." ]

[ "function", "handler", "(", "req", ",", "res", ")", "{", "var", "path", "=", "cog", ".", "getConfig", "(", "'options.api_data'", ")", ";", "var", "urlRegex", "=", "cog", ".", "getConfig", "(", "'options.api_url_regex'", ")", ";", "var", "url", "=", "req", ".", "url", ".", "replace", "(", "/", "^\\/", "/", ",", "''", ")", ".", "replace", "(", "/", "\\/$", "/", ",", "''", ")", ";", "console", ".", "log", "(", "req", ".", "method", "+", "' '", "+", "req", ".", "url", ")", ";", "// Find the JSON-data file and serve it, if URL points to the API.", "if", "(", "path", "&&", "urlRegex", "&&", "urlRegex", ".", "test", "(", "url", ")", ")", "{", "var", "file", "=", "path", "+", "'/'", "+", "url", "+", "'.json'", ";", "if", "(", "grunt", ".", "file", ".", "exists", "(", "file", ")", ")", "{", "res", ".", "end", "(", "grunt", ".", "file", ".", "read", "(", "file", ")", ")", ";", "return", ";", "}", "}", "if", "(", "req", ".", "method", "==", "'POST'", ")", "{", "// TODO: This needs fixing, since it throws an error.", "res", ".", "end", "(", "'{\"message\": \"OK\"}'", ")", ";", "}", "}" ]

[ "This", "is", "the", "development", "server", "used", "by", "CoG", "." ]

[ "function", "(", "name", ",", "type", ",", "filename", ",", "code", ")", "{", "this", ".", "name", "=", "name", ";", "this", ".", "type", "=", "type", ";", "this", ".", "filename", "=", "filename", ";", "this", ".", "code", "=", "code", ";", "}" ]

[ "Represents", "a", "single", "System" ]

[ "function", "vorto", "(", ")", "{", "var", "length", "=", "arguments", ".", "length", ";", "var", "format", ",", "options", ",", "callback", ";", "if", "(", "typeof", "arguments", "[", "length", "-", "1", "]", "!==", "'function'", ")", "{", "throw", "new", "Error", "(", "'The last argument must be a callback function: function(err, version){...}'", ")", ";", "}", "else", "{", "callback", "=", "arguments", "[", "length", "-", "1", "]", ";", "}", "if", "(", "length", "===", "1", ")", "{", "format", "=", "'%h'", ";", "options", "=", "DEFAULTS", ";", "}", "else", "if", "(", "length", "===", "2", ")", "{", "if", "(", "typeof", "arguments", "[", "0", "]", "===", "'string'", ")", "{", "format", "=", "arguments", "[", "0", "]", ";", "options", "=", "DEFAULTS", ";", "}", "else", "if", "(", "typeof", "arguments", "[", "0", "]", "===", "'object'", ")", "{", "format", "=", "'%h'", ";", "options", "=", "createOptions", "(", "arguments", "[", "0", "]", ",", "DEFAULTS", ")", ";", "}", "else", "{", "throw", "new", "Error", "(", "'First argument must be a \\'string\\' or an \\'object\\''", ")", ";", "}", "}", "else", "if", "(", "length", "===", "3", ")", "{", "if", "(", "typeof", "arguments", "[", "0", "]", "!==", "'string'", ")", "{", "throw", "new", "Error", "(", "'First argument must be a string'", ")", ";", "}", "if", "(", "typeof", "arguments", "[", "1", "]", "!==", "'object'", ")", "{", "throw", "new", "Error", "(", "'Second argument must be an object'", ")", ";", "}", "format", "=", "arguments", "[", "0", "]", ";", "options", "=", "createOptions", "(", "arguments", "[", "1", "]", ",", "DEFAULTS", ")", ";", "}", "if", "(", "format", ".", "indexOf", "(", "'%j'", ")", ">", "-", "1", ")", "{", "var", "j", "=", "packageVersion", "(", "options", ".", "repo", ")", ";", "git", "(", "format", ",", "options", ",", "function", "(", "err", ",", "version", ")", "{", "if", "(", "err", ")", "{", "callback", "(", "err", ",", "null", ")", ";", "}", "else", "{", "callback", "(", "null", ",", "version", ".", "replace", "(", "'%j'", ",", "j", ")", ")", ";", "}", "}", ")", ";", "}", "else", "{", "git", "(", "format", ",", "options", ",", "callback", ")", ";", "}", "}" ]

[ "Init", "function", "that", "might", "take", "3", "parameters", ".", "It", "checks", "the", "input", "parameters", "and", "will", "throw", "errors", "if", "they", "re", "not", "valid", "or", "wrongly", "ordered", "." ]

[ "function", "packageVersion", "(", "repo", ")", "{", "var", "location", "=", "repo", "?", "path", ".", "join", "(", "repo", ",", "'package.json'", ")", ":", "'./package.json'", ";", "var", "pack", "=", "require", "(", "location", ")", ";", "return", "pack", "[", "'version'", "]", ";", "}" ]

[ "Load", "the", "version", "from", "package", ".", "json" ]

[ "function", "(", "name", ",", "value", ",", "iType", ")", "{", "var", "type", "=", "iType", ",", "coded", ",", "attach", "=", "{", "'_attachments'", ":", "this", ".", "get", "(", "'_attachments'", ")", "||", "{", "}", "}", ",", "types", "=", "{", "\"html\"", ":", "{", "\"content_type\"", ":", "\"text\\/html\"", "}", ",", "\"text\"", ":", "{", "\"content_type\"", ":", "\"text\\/plain\"", "}", ",", "\"xml\"", ":", "{", "\"content_type\"", ":", "\"text\\/plain\"", "}", ",", "\"jpeg\"", ":", "{", "\"content_type\"", ":", "\"image\\/jpeg\"", "}", ",", "\"png\"", ":", "{", "\"content_type\"", ":", "\"image\\/png\"", "}", "}", "// base64 chokes on charCodes > 255", ",", "filterCharCodes", "=", "function", "(", "s", ")", "{", "// replace newlines and carriage returns with a space. then filter the non-ascii", "return", "_", ".", "reduce", "(", "s", ".", "replace", "(", "/", "\\n", "/", "g", ",", "' '", ")", ".", "replace", "(", "/", "\\r", "/", "g", ",", "' '", ")", ",", "function", "(", "result", ",", "x", ",", "i", ")", "{", "if", "(", "s", ".", "charCodeAt", "(", "i", ")", "<", "256", ")", "{", "result", "+=", "s", "[", "i", "]", ";", "}", "return", "result", ";", "}", ",", "''", ")", ";", "}", ";", ";", "// as a prelude to a 'read', the second argument is the 'type'", "if", "(", "arguments", ".", "length", "===", "2", ")", "{", "this", ".", "options", ".", "set", "(", "'Content-Type'", ",", "(", "types", "&&", "types", "[", "value", "]", "&&", "types", "[", "value", "]", ".", "content_type", ")", "||", "'text\\/plain'", ")", ";", "}", "else", "if", "(", "arguments", ".", "length", "===", "3", ")", "{", "type", "=", "(", "types", "&&", "types", "[", "type", "]", ")", "?", "type", ":", "'xml'", ";", "types", "[", "type", "]", ".", "data", "=", "_", ".", "encode", "(", "filterCharCodes", "(", "value", ")", ")", ";", "attach", ".", "_attachments", "[", "name", "]", "=", "types", "[", "type", "]", ";", "}", "this", ".", "set", "(", "'_attachments'", ",", "attach", ".", "_attachments", ")", ";", "return", "this", ";", "}" ]

[ "configure", "the", "URL", "for", "an", "attachment" ]

[ "function", "EventReactor", "(", "options", ",", "proto", ")", "{", "// allow initialization without a new prefix", "if", "(", "!", "(", "this", "instanceof", "EventReactor", ")", ")", "return", "new", "EventReactor", "(", "options", ",", "proto", ")", ";", "options", "=", "options", "||", "{", "}", ";", "this", ".", "restore", "=", "{", "}", ";", "// don't attach the extra event reactor methods, we are going to apply them", "// manually to the prototypes", "if", "(", "options", ".", "manual", ")", "return", "this", ";", "var", "methods", "=", "EventReactor", ".", "generation", ",", "method", ";", "for", "(", "method", "in", "methods", ")", "{", "if", "(", "methods", ".", "hasOwnProperty", "(", "method", ")", ")", "{", "this", "[", "method", "]", "(", "proto", ")", ";", "}", "}", "// such as aliases and emit overrides", "this", ".", "aliases", "(", "proto", ")", ";", "this", ".", "emit", "(", "proto", ")", ";", "}" ]

[ "The", "EventReactor", "plugin", "that", "allows", "you", "to", "extend", "update", "the", "EventEmitter", "prototype", "." ]

[ "function", "every", "(", ")", "{", "for", "(", "var", "args", "=", "slice", ".", "call", "(", "arguments", ",", "0", ")", ",", "callback", "=", "args", ".", "pop", "(", ")", ",", "length", "=", "args", ".", "length", ",", "i", "=", "0", ";", "i", "<", "length", ";", "this", ".", "on", "(", "args", "[", "i", "++", "]", ",", "callback", ")", ")", "{", "}", "return", "this", ";", "}" ]

[ "Apply", "the", "same", "callback", "to", "every", "given", "event", "." ]

[ "function", "handle", "(", ")", "{", "for", "(", "var", "i", "=", "0", ",", "length", "=", "args", ".", "length", ";", "i", "<", "length", ";", "self", ".", "removeListener", "(", "args", "[", "i", "++", "]", ",", "handle", ")", ")", "{", "}", "// call the function as last as the function might be calling on of", "// events that where in our either queue, so we need to make sure that", "// everything is removed", "callback", ".", "apply", "(", "self", ",", "arguments", ")", ";", "}" ]

[ "Handler", "for", "all", "the", "calls", "so", "every", "remaining", "event", "listener", "is", "removed", "removed", "properly", "before", "we", "call", "the", "callback", "." ]

[ "function", "handle", "(", ")", "{", "self", ".", "removeListener", "(", "event", ",", "reset", ")", ";", "callback", ".", "apply", "(", "self", ",", "[", "event", "]", ".", "concat", "(", "args", ")", ")", ";", "}" ]

[ "Handle", "the", "idle", "callback", "as", "the", "setTimeout", "got", "triggerd", "." ]

[ "function", "reset", "(", ")", "{", "clearTimeout", "(", "timer", ")", ";", "self", ".", "idle", ".", "apply", "(", "self", ",", "[", "event", ",", "callback", ",", "timeout", "]", ".", "concat", "(", "args", ")", ")", ";", "}" ]

[ "Reset", "the", "timeout", "timer", "again", "as", "the", "event", "was", "triggerd", "." ]

[ "function", "listen", "(", "pw", ",", "type", ",", "listener", ",", "fnm", ",", "rf", ",", "cbtype", ",", "passes", ")", "{", "var", "fn", "=", "function", "pulseListener", "(", "flow", ",", "artery", ",", "pulse", ")", "{", "if", "(", "!", "rf", "||", "!", "(", "artery", "instanceof", "cat", ".", "Artery", ")", "||", "!", "(", "pulse", "instanceof", "cat", ".", "Pulse", ")", "||", "flow", "instanceof", "Error", ")", "return", "arguments", ".", "length", "?", "fn", ".", "_callback", ".", "apply", "(", "pw", ",", "Array", ".", "prototype", ".", "slice", ".", "call", "(", "arguments", ")", ")", ":", "fn", ".", "_callback", ".", "call", "(", "pw", ")", ";", "var", "isRfCb", "=", "rf", "===", "'callback'", ",", "emitErrs", "=", "pulse", ".", "emitErrors", "||", "(", "pulse", ".", "emitErrors", "!==", "false", "&&", "artery", ".", "emitErrors", ")", "||", "(", "pulse", ".", "emitErrors", "!==", "false", "&&", "artery", ".", "emitErrors", "!==", "false", "&&", "pw", ".", "options", "&&", "pw", ".", "options", ".", "emitErrors", ")", ";", "var", "args", "=", "arguments", ".", "length", ">", "fn", ".", "length", "?", "Array", ".", "prototype", ".", "slice", ".", "call", "(", "arguments", ",", "isRfCb", "?", "fn", ".", "length", ":", "1", ")", ":", "null", ";", "if", "(", "isRfCb", ")", "{", "(", "args", "=", "args", "||", "[", "]", ")", ".", "push", "(", "function", "retrofitCb", "(", "err", ")", "{", "// last argument should be the callback function", "if", "(", "err", "instanceof", "Error", ")", "emitError", "(", "pw", ",", "err", ",", "pulse", ".", "type", ",", "[", "artery", ",", "pulse", "]", ")", ";", "// emit any callback errors", "var", "pi", "=", "0", ",", "al", ";", "if", "(", "passes", ")", "for", "(", "var", "pl", "=", "passes", ".", "length", ";", "pi", "<", "pl", ";", "++", "pi", ")", "{", "artery", ".", "passes", "[", "passes", "[", "pi", "]", "]", "=", "arguments", "[", "pi", "]", ";", "// pass by name before any other arguments are passed", "}", "if", "(", "(", "al", "=", "arguments", ".", "length", "-", "(", "pi", "+=", "pi", ">", "0", ")", ")", "===", "1", ")", "artery", ".", "pass", ".", "push", "(", "arguments", "[", "pi", "]", ")", ";", "else", "if", "(", "al", ")", "artery", ".", "pass", ".", "push", ".", "apply", "(", "artery", ".", "pass", ",", "Array", ".", "prototype", ".", "slice", ".", "call", "(", "arguments", ",", "pi", ")", ")", ";", "}", ")", ";", "}", "if", "(", "emitErrs", ")", "{", "try", "{", "args", "&&", "args", ".", "length", "?", "fn", ".", "_callback", ".", "apply", "(", "pw", ",", "args", ")", ":", "fn", ".", "_callback", ".", "call", "(", "pw", ",", "artery", ",", "pulse", ")", ";", "}", "catch", "(", "e", ")", "{", "emitError", "(", "pw", ",", "e", ",", "pulse", ".", "type", ",", "[", "artery", ",", "pulse", "]", ")", ";", "}", "}", "else", "args", "&&", "args", ".", "length", "?", "fn", ".", "_callback", ".", "apply", "(", "pw", ",", "args", ")", ":", "fn", ".", "_callback", ".", "call", "(", "pw", ",", "artery", ",", "pulse", ")", ";", "}", ";", "fn", ".", "_callback", "=", "listener", ";", "if", "(", "cbtype", ")", "fn", ".", "_cbtype", "=", "cbtype", ";", "return", "PulseEmitter", ".", "super_", ".", "prototype", "[", "fnm", "||", "'addListener'", "]", ".", "call", "(", "pw", ",", "type", ",", "fn", ")", ";", "}" ]

[ "Listens", "for", "incoming", "events", "using", "event", "emitter", "s", "add", "listener", "function", "but", "with", "optional", "error", "handling", "and", "pulse", "event", "only", "capabilities" ]

[ "function", "complete", "(", "err", ",", "msg", ")", "{", "b9", ".", "off", "(", "'hello'", ",", "success", ")", ";", "// cleanup", "// optional callback, error-first...", "if", "(", "typeof", "callback", "==", "'function'", ")", "{", "callback", "(", "err", ",", "msg", ")", ";", "}", "}" ]

[ "handle", "complete", "callback", "..." ]

[ "function", "receive", "(", "str", ")", "{", "ping", "(", ")", ";", "// clear/schedule next ping", "var", "msg", "=", "typeof", "str", "===", "'string'", "?", "JSON", ".", "parse", "(", "str", ")", ":", "str", ";", "b9", ".", "emit", "(", "'rtm.read'", ",", "msg", ",", "replyTo", "(", "null", ")", ")", ";", "// acknowledge that a pending message was sent successfully", "if", "(", "msg", ".", "reply_to", ")", "{", "delete", "pending", "[", "msg", ".", "reply_to", "]", ";", "}", "else", "if", "(", "msg", ".", "type", "!=", "null", ")", "{", "b9", ".", "emit", "(", "msg", ".", "type", ",", "msg", ",", "replyTo", "(", "msg", ".", "channel", ")", ")", ";", "}", "}" ]

[ "handle", "a", "websocket", "message" ]

[ "function", "ping", "(", ")", "{", "clearTimeout", "(", "ping", ".", "timer", ")", ";", "ping", ".", "timer", "=", "setTimeout", "(", "function", "(", ")", "{", "b9", ".", "send", "(", "{", "type", ":", "'ping'", ",", "time", ":", "Date", ".", "now", "(", ")", "}", ")", ";", "}", ",", "b9", ".", "_interval", ")", ";", "}" ]

[ "keep", "the", "connection", "alive" ]

[ "function", "assertEqualsDelta", "(", "msg", ",", "expected", ",", "actual", ",", "epsilon", ")", "{", "var", "args", "=", "this", ".", "argsWithOptionalMsg_", "(", "arguments", ",", "4", ")", ";", "jstestdriver", ".", "assertCount", "++", ";", "msg", "=", "args", "[", "0", "]", ";", "expected", "=", "args", "[", "1", "]", ";", "actual", "=", "args", "[", "2", "]", ";", "epsilon", "=", "args", "[", "3", "]", ";", "if", "(", "!", "compareDelta_", "(", "expected", ",", "actual", ",", "epsilon", ")", ")", "{", "this", ".", "fail", "(", "msg", "+", "'expected '", "+", "epsilon", "+", "' within '", "+", "this", ".", "prettyPrintEntity_", "(", "expected", ")", "+", "' but was '", "+", "this", ".", "prettyPrintEntity_", "(", "actual", ")", "+", "''", ")", ";", "}", "return", "true", ";", "}" ]

[ "Asserts", "that", "two", "doubles", "or", "the", "elements", "of", "two", "arrays", "of", "doubles", "are", "equal", "to", "within", "a", "positive", "delta", "." ]

[ "function", "parseName", "(", "name", ")", "{", "if", "(", "name", ")", "{", "const", "arr", "=", "name", ".", "split", "(", "'.'", ")", "const", "len", "=", "arr", ".", "length", "if", "(", "len", ">", "2", ")", "{", "return", "arr", ".", "slice", "(", "0", ",", "-", "1", ")", ".", "join", "(", "'.'", ")", "}", "else", "if", "(", "len", "===", "2", "||", "len", "===", "1", ")", "{", "return", "arr", "[", "0", "]", "}", "}", "return", "name", "}" ]

[ "remove", "pkg", ".", "name", "extension", "if", "exists" ]

[ "function", "(", "object", ")", "{", "var", "methodName", ";", "methodName", "=", "this", ".", "test", "(", "object", ",", "true", ")", ";", "if", "(", "methodName", "!==", "true", ")", "{", "throw", "new", "exports", ".", "NotImplementedError", "(", "{", "code", ":", "'interface'", ",", "message", ":", "'Object %(object) does not implement %(interface)#%(method)()'", ",", "//Additional information", "interface", ":", "this", ".", "name", ",", "object", ":", "object", ",", "method", ":", "methodName", "}", ")", ";", "}", "return", "this", ";", "}" ]

[ "Throw", "error", "if", "object", "does", "not", "have", "all", "methods" ]

[ "function", "(", "object", ",", "returnName", ")", "{", "var", "methodName", ";", "for", "(", "methodName", "in", "this", ".", "methods", ")", "{", "if", "(", "!", "(", "object", "[", "methodName", "]", "instanceof", "Function", ")", ")", "{", "return", "returnName", "?", "methodName", ":", "false", ";", "}", "}", "return", "true", ";", "}" ]

[ "Return", "false", "or", "the", "missing", "method", "name", "in", "object", "if", "method", "is", "missing", "in", "object" ]

[ "function", "(", "_module", ")", "{", "if", "(", "!", "this", ".", "name", ")", "{", "throw", "new", "exports", ".", "ValueError", "(", "{", "message", ":", "'name is empty'", "}", ")", ";", "}", "var", "_exports", "=", "_module", ".", "exports", "||", "_module", ";", "_exports", "[", "this", ".", "name", "]", "=", "this", ";", "return", "this", ";", "}" ]

[ "Export", "this", "interface", "into", "_exports" ]

[ "function", "(", ")", "{", "var", "prefix", "=", "'%('", ",", "suffix", "=", "')'", ",", "data", "=", "this", ".", "data", ",", "output", "=", "''", ",", "dataKey", ";", "output", "=", "this", ".", "__message__", ";", "for", "(", "dataKey", "in", "data", ")", "{", "if", "(", "data", ".", "hasOwnProperty", "(", "dataKey", ")", ")", "{", "output", "=", "output", ".", "replace", "(", "prefix", "+", "dataKey", "+", "suffix", ",", "''", "+", "data", "[", "dataKey", "]", ")", ";", "}", "}", "output", "=", "output", ".", "replace", "(", "prefix", "+", "'code'", "+", "suffix", ",", "''", "+", "this", ".", "code", ")", ";", "output", "=", "output", ".", "replace", "(", "prefix", "+", "'name'", "+", "suffix", ",", "''", "+", "this", ".", "name", ")", ";", "return", "output", ";", "}" ]

[ "Return", "formatted", "message" ]

[ "function", "(", "full", ")", "{", "var", "output", ",", "data", ";", "output", "=", "this", ".", "name", "+", "'['", "+", "this", ".", "code", "+", "']: '", ";", "output", "+=", "this", ".", "message", ";", "if", "(", "full", ")", "{", "output", "+=", "'\\n'", ";", "output", "+=", "this", ".", "stack", ".", "toString", "(", ")", ";", "}", "return", "output", ";", "}" ]

[ "Return", "string", "formatted", "representation" ]

[ "function", "setView", "(", "{", "action", ",", "config", ",", "route", ",", "routes", ",", "method", "}", ")", "{", "const", "ws", "=", "route", ".", "ws", ";", "return", "exports", ".", "getView", "(", "action", ",", "config", ")", ".", "then", "(", "view", "=>", "{", "routes", "[", "ws", "?", "'ws'", ":", "route", ".", "type", "]", ".", "push", "(", "{", "action", ",", "method", ",", "view", ",", "match", ":", "new", "Route", "(", "route", ".", "url", ")", ",", "}", ")", ";", "}", ")", ";", "}" ]

[ "Set", "the", "view", "for", "a", "specific", "route" ]

[ "function", "(", ")", "{", "var", "rangeList", "=", "this", ",", "bookmark", "=", "CKEDITOR", ".", "dom", ".", "walker", ".", "bookmark", "(", ")", ",", "bookmarks", "=", "[", "]", ",", "current", ";", "return", "{", "/**\n\t\t\t\t * Retrieves the next range in the list.\n\t\t\t\t *\n\t\t\t\t * @member CKEDITOR.dom.rangeListIterator\n\t\t\t\t * @param {Boolean} [mergeConsequent=false] Whether join two adjacent\n\t\t\t\t * ranges into single, e.g. consequent table cells.\n\t\t\t\t */", "getNextRange", ":", "function", "(", "mergeConsequent", ")", "{", "current", "=", "current", "===", "undefined", "?", "0", ":", "current", "+", "1", ";", "var", "range", "=", "rangeList", "[", "current", "]", ";", "// Multiple ranges might be mangled by each other.", "if", "(", "range", "&&", "rangeList", ".", "length", ">", "1", ")", "{", "// Bookmarking all other ranges on the first iteration,", "// the range correctness after it doesn't matter since we'll", "// restore them before the next iteration.", "if", "(", "!", "current", ")", "{", "// Make sure bookmark correctness by reverse processing.", "for", "(", "var", "i", "=", "rangeList", ".", "length", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "bookmarks", ".", "unshift", "(", "rangeList", "[", "i", "]", ".", "createBookmark", "(", "true", ")", ")", ";", "}", "if", "(", "mergeConsequent", ")", "{", "// Figure out how many ranges should be merged.", "var", "mergeCount", "=", "0", ";", "while", "(", "rangeList", "[", "current", "+", "mergeCount", "+", "1", "]", ")", "{", "var", "doc", "=", "range", ".", "document", ",", "found", "=", "0", ",", "left", "=", "doc", ".", "getById", "(", "bookmarks", "[", "mergeCount", "]", ".", "endNode", ")", ",", "right", "=", "doc", ".", "getById", "(", "bookmarks", "[", "mergeCount", "+", "1", "]", ".", "startNode", ")", ",", "next", ";", "// Check subsequent range.", "while", "(", "1", ")", "{", "next", "=", "left", ".", "getNextSourceNode", "(", "false", ")", ";", "if", "(", "!", "right", ".", "equals", "(", "next", ")", ")", "{", "// This could be yet another bookmark or", "// walking across block boundaries.", "if", "(", "bookmark", "(", "next", ")", "||", "(", "next", ".", "type", "==", "CKEDITOR", ".", "NODE_ELEMENT", "&&", "next", ".", "isBlockBoundary", "(", ")", ")", ")", "{", "left", "=", "next", ";", "continue", ";", "}", "}", "else", "{", "found", "=", "1", ";", "}", "break", ";", "}", "if", "(", "!", "found", ")", "break", ";", "mergeCount", "++", ";", "}", "}", "range", ".", "moveToBookmark", "(", "bookmarks", ".", "shift", "(", ")", ")", ";", "// Merge ranges finally after moving to bookmarks.", "while", "(", "mergeCount", "--", ")", "{", "next", "=", "rangeList", "[", "++", "current", "]", ";", "next", ".", "moveToBookmark", "(", "bookmarks", ".", "shift", "(", ")", ")", ";", "range", ".", "setEnd", "(", "next", ".", "endContainer", ",", "next", ".", "endOffset", ")", ";", "}", "}", "return", "range", ";", "}", "}", ";", "}" ]

[ "Creates", "an", "instance", "of", "the", "rangeList", "iterator", "it", "should", "be", "used", "only", "when", "the", "ranges", "processing", "could", "be", "DOM", "intrusive", "which", "means", "it", "may", "pollute", "and", "break", "other", "ranges", "in", "this", "list", ".", "Otherwise", "it", "s", "enough", "to", "just", "iterate", "over", "this", "array", "in", "a", "for", "loop", "." ]

[ "function", "(", "typeCode", ")", "{", "switch", "(", "typeCode", ")", "{", "case", "this", ".", "types", ".", "undefined", ":", "return", "this", ".", "Undefined", ";", "case", "this", ".", "types", ".", "string", ":", "return", "this", ".", "String", ";", "case", "this", ".", "types", ".", "integer", ":", "return", "this", ".", "Integer", ";", "case", "this", ".", "types", ".", "double", ":", "return", "this", ".", "Double", ";", "case", "this", ".", "types", ".", "boolean", ":", "return", "this", ".", "Boolean", ";", "case", "this", ".", "types", "[", "\"null\"", "]", ":", "return", "this", ".", "Null", ";", "case", "this", ".", "types", ".", "datetime", ":", "return", "this", ".", "DateTime", ";", "case", "this", ".", "types", ".", "array", ":", "return", "this", ".", "Array", ";", "case", "this", ".", "types", ".", "object", ":", "return", "this", ".", "Object", ";", "case", "this", ".", "types", "[", "\"function\"", "]", ":", "return", "this", ".", "Function", ";", "default", ":", "throw", "new", "Error", "(", "\"Unknown typeCode \\\"\"", "+", "typeCode", "+", "\"\\\".\"", ")", ";", "}", "}" ]

[ "Get", "an", "Adapter", "for", "typeCode" ]

[ "function", "addType", "(", "descriptor", ")", "{", "if", "(", "!", "(", "descriptor", "instanceof", "fs", ".", "Stats", ")", ")", "{", "return", "descriptor", ";", "}", "[", "\"isFile\"", ",", "\"isDirectory\"", ",", "\"isBlockDevice\"", ",", "\"isCharacterDevice\"", ",", "\"isSymbolicLink\"", ",", "\"isFIFO\"", ",", "\"isSocket\"", ",", "]", ".", "forEach", "(", "function", "(", "funcName", ")", "{", "if", "(", "descriptor", "[", "funcName", "]", "(", ")", ")", "{", "descriptor", "[", "funcName", "]", "=", "true", ";", "}", "else", "{", "descriptor", "[", "funcName", "]", "=", "undefined", ";", "}", "}", ")", ";", "if", "(", "_", ".", "isArray", "(", "descriptor", ".", "content", ")", ")", "{", "descriptor", ".", "content", ".", "forEach", "(", "function", "(", "obj", ")", "{", "addType", "(", "obj", ")", ";", "}", ")", ";", "}", "return", "descriptor", ";", "}" ]

[ "Add", "type", "to", "all", "stat", "objects", "in", "a", "descriptor" ]

[ "function", "getArgs", "(", "userArgs", ",", "defaultArgs", ",", "userCallback", ")", "{", "let", "args", "=", "{", "}", ";", "let", "callback", "=", "userCallback", "||", "function", "(", ")", "{", "}", ";", "defaultArgs", ".", "unshift", "(", "args", ")", ";", "_", ".", "assign", ".", "apply", "(", "null", ",", "defaultArgs", ")", ";", "if", "(", "_", ".", "isPlainObject", "(", "userArgs", ")", ")", "{", "_", ".", "merge", "(", "args", ",", "userArgs", ")", ";", "}", "else", "{", "callback", "=", "userArgs", ";", "}", "return", "{", "options", ":", "args", ",", "callback", ",", "}", ";", "}" ]

[ "Get", "arguments", "passed", "by", "user", "curated", "with", "configurations" ]

[ "function", "removeDuplicates", "(", "files", ",", "duplicates", ")", "{", "var", "i", ";", "var", "ret", "=", "[", "]", ";", "var", "found", "=", "{", "}", ";", "if", "(", "duplicates", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "duplicates", ".", "length", ";", "i", "++", ")", "{", "found", "[", "duplicates", "[", "i", "]", ".", "dst", "]", "=", "true", ";", "}", "}", "for", "(", "i", "=", "0", ";", "i", "<", "files", ".", "length", ";", "i", "++", ")", "{", "if", "(", "!", "found", "[", "files", "[", "i", "]", ".", "dst", "]", ")", "{", "found", "[", "files", "[", "i", "]", ".", "dst", "]", "=", "true", ";", "ret", ".", "push", "(", "files", "[", "i", "]", ")", ";", "}", "}", "return", "ret", ";", "}" ]

[ "Scan", "file", "specs", "and", "remove", "duplicates", "." ]

[ "function", "flatten", "(", "files", ")", "{", "var", "ret", "=", "[", "]", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "files", ".", "length", ";", "i", "++", ")", "{", "ret", ".", "push", "(", "files", "[", "i", "]", ".", "dst", ")", ";", "}", "return", "ret", ";", "}" ]

[ "Collect", "destination", "files", "from", "file", "spec", "list", "." ]

[ "function", "prefixDest", "(", "prefix", ",", "files", ")", "{", "for", "(", "var", "i", "=", "0", ";", "i", "<", "files", ".", "length", ";", "i", "++", ")", "{", "files", "[", "i", "]", ".", "dst", "=", "prefix", "+", "files", "[", "i", "]", ".", "dst", ";", "}", "return", "files", ";", "}" ]

[ "Add", "a", "directory", "prefix", "to", "all", "destinations", "in", "the", "file", "list", "." ]

[ "function", "filesInRepository", "(", "dir", ")", "{", "var", "ignoreDirs", "=", "cog", ".", "getOption", "(", "'ignore_dirs'", ")", ";", "// TODO: Allow an array and move to config.", "var", "ignoreFiles", "=", "/", "~$", "/", ";", "var", "files", "=", "glob", ".", "sync", "(", "dir", "?", "dir", "+", "'/*'", ":", "'*'", ")", ";", "var", "ret", "=", "[", "]", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "files", ".", "length", ";", "i", "++", ")", "{", "if", "(", "fs", ".", "lstatSync", "(", "files", "[", "i", "]", ")", ".", "isDirectory", "(", ")", ")", "{", "// Ignore standard directories of uninterest.", "if", "(", "!", "dir", "&&", "ignoreDirs", ".", "indexOf", "(", "files", "[", "i", "]", ")", ">=", "0", ")", "{", "continue", ";", "}", "ret", "=", "filesInRepository", "(", "files", "[", "i", "]", ")", ".", "concat", "(", "ret", ")", ";", "}", "else", "{", "if", "(", "!", "ignoreFiles", ".", "test", "(", "files", "[", "i", "]", ")", ")", "{", "ret", ".", "push", "(", "files", "[", "i", "]", ")", ";", "}", "}", "}", "return", "ret", ";", "}" ]

[ "Perform", "recursive", "lookup", "for", "files", "in", "the", "repository", "." ]

[ "function", "excludeFiles", "(", "list", ",", "regex", ")", "{", "var", "ret", "=", "[", "]", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "list", ".", "length", ";", "i", "++", ")", "{", "if", "(", "!", "regex", ".", "test", "(", "list", "[", "i", "]", ".", "dst", ")", ")", "{", "ret", ".", "push", "(", "list", "[", "i", "]", ")", ";", "}", "}", "return", "ret", ";", "}" ]

[ "Remove", "specs", "whose", "destination", "matches", "to", "the", "given", "regex", "pattern", "." ]

[ "function", "srcFiles", "(", ")", "{", "return", "removeDuplicates", "(", "configFiles", "(", ")", ".", "concat", "(", "libFiles", "(", ")", ")", ".", "concat", "(", "modelFiles", "(", ")", ")", ".", "concat", "(", "srcDataFiles", "(", ")", ")", ".", "concat", "(", "codeFiles", "(", ")", ")", ")", ";", "}" ]

[ "Find", "all", "source", "code", "files", "for", "the", "actual", "application", "." ]

[ "function", "otherNonJsFiles", "(", ")", "{", "return", "removeDuplicates", "(", "files", "(", "cog", ".", "getConfig", "(", "'src.other'", ")", ",", "'other'", ")", ",", "srcFiles", "(", ")", ".", "concat", "(", "otherJsFiles", "(", ")", ".", "concat", "(", "appIndexFiles", "(", ")", ")", ")", ")", ";", "}" ]

[ "Find", "other", "files", "that", "are", "not", "Javascript", "." ]

[ "function", "includeJsFiles", "(", ")", "{", "if", "(", "cog", ".", "getOption", "(", "'include_only_external'", ")", ")", "{", "return", "extLibFiles", "(", ")", ".", "concat", "(", "generatedJsFiles", "(", ")", ")", ";", "}", "if", "(", "cog", ".", "getOption", "(", "'compile_typescript'", ")", ")", "{", "return", "extLibFiles", "(", ")", ".", "concat", "(", "generatedJsFiles", "(", ")", ")", ";", "}", "return", "extLibFiles", "(", ")", ".", "concat", "(", "srcFiles", "(", ")", ")", ".", "concat", "(", "generatedJsFiles", "(", ")", ")", ";", "}" ]

[ "Find", "all", "code", "files", "needed", "to", "include", "in", "HTML", "index", "." ]

[ "function", "allJavascriptFiles", "(", ")", "{", "return", "srcFiles", "(", ")", ".", "concat", "(", "otherJsFiles", "(", ")", ")", ".", "concat", "(", "unitTestFiles", "(", ")", ")", ".", "concat", "(", "unitTestHelperFiles", "(", ")", ")", ".", "concat", "(", "taskFiles", "(", ")", ")", ".", "concat", "(", "commonJsFiles", "(", ")", ")", ";", "}" ]

[ "Find", "all", "Javascript", "based", "work", "files", "." ]

[ "function", "workTextFiles", "(", ")", "{", "return", "indexFiles", "(", ")", ".", "concat", "(", "srcFiles", "(", ")", ")", ".", "concat", "(", "allTestFiles", "(", ")", ")", ".", "concat", "(", "otherJsFiles", "(", ")", ")", ".", "concat", "(", "otherNonJsFiles", "(", ")", ")", ".", "concat", "(", "taskFiles", "(", ")", ")", ".", "concat", "(", "cssFiles", "(", ")", ")", ".", "concat", "(", "toolsShellFiles", "(", ")", ")", ".", "concat", "(", "commonJsFiles", "(", ")", ")", ".", "concat", "(", "htmlTemplateFiles", "(", ")", ")", ".", "concat", "(", "pythonFiles", "(", ")", ")", ".", "concat", "(", "textDataFiles", "(", ")", ")", ";", "}" ]

[ "Find", "all", "text", "based", "work", "files", "." ]

[ "function", "generatedJsFiles", "(", "what", ")", "{", "var", "ret", "=", "[", "]", ";", "if", "(", "(", "!", "what", "||", "what", "===", "'templates'", ")", "&&", "cog", ".", "getOption", "(", "'template'", ")", ")", "{", "ret", ".", "push", "(", "{", "src", ":", "null", ",", "dst", ":", "cog", ".", "getOption", "(", "'template'", ")", "}", ")", ";", "}", "if", "(", "cog", ".", "getOption", "(", "'compile_typescript'", ")", ")", "{", "var", "src", "=", "srcTypescriptFiles", "(", ")", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "src", ".", "length", ";", "i", "++", ")", "{", "if", "(", "src", "[", "i", "]", ".", "src", ".", "substr", "(", "-", "3", ")", "===", "'.ts'", ")", "{", "src", "[", "i", "]", ".", "dst", "=", "src", "[", "i", "]", ".", "src", ".", "substr", "(", "0", ",", "src", "[", "i", "]", ".", "src", ".", "length", "-", "3", ")", "+", "'.js'", ";", "ret", ".", "push", "(", "src", "[", "i", "]", ")", ";", "}", "}", "}", "return", "ret", ";", "}" ]

[ "List", "of", "files", "that", "are", "generated", "Javascript", "files", "." ]

[ "function", "fileCategoryMap", "(", ")", "{", "// Go over every file lookup function we export.", "var", "exports", "=", "module", ".", "exports", "(", "grunt", ")", ";", "// This list of categories must contain all non-overlapping file categories.", "var", "categories", "=", "[", "'extLibFiles'", ",", "'extLibMapFiles'", ",", "'extCssFiles'", ",", "'extFontFiles'", ",", "'fontFiles'", ",", "'appIndexFiles'", ",", "'testIndexFiles'", ",", "'configFiles'", ",", "'libFiles'", ",", "'modelFiles'", ",", "'srcDataFiles'", ",", "'codeFiles'", ",", "'otherJsFiles'", ",", "'otherNonJsFiles'", ",", "'taskFiles'", ",", "'cssFiles'", ",", "'picFiles'", ",", "'soundFiles'", ",", "'unitTestFiles'", ",", "'commonJsFiles'", ",", "'commonOtherFiles'", ",", "'ignoredFiles'", ",", "'distUncompressedFiles'", ",", "'distLibFiles'", ",", "'distIndexFiles'", ",", "'distJsFiles'", ",", "'distCssFiles'", ",", "'toolsShellFiles'", ",", "'unitTestDataFiles'", ",", "'picSrcFiles'", ",", "'soundSrcFiles'", ",", "'htmlTemplateFiles'", ",", "'generatedJsFiles'", ",", "'otherMediaFiles'", ",", "'unitTestHelperFiles'", ",", "'pythonFiles'", ",", "'compiledPythonFiles'", ",", "'localizationDataFiles'", ",", "'developmentOtherDataFiles'", ",", "'developmentTextDataFiles'", "]", ";", "// Construct the map by calling each function defined above.", "var", "map", "=", "{", "}", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "categories", ".", "length", ";", "i", "++", ")", "{", "var", "files", "=", "flatten", "(", "exports", "[", "categories", "[", "i", "]", "]", "(", ")", ")", ";", "for", "(", "var", "j", "=", "0", ";", "j", "<", "files", ".", "length", ";", "j", "++", ")", "{", "if", "(", "map", "[", "files", "[", "j", "]", "]", ")", "{", "grunt", ".", "fail", ".", "warn", "(", "\"A file '\"", "+", "files", "[", "j", "]", "+", "\"' maps to category '\"", "+", "categories", "[", "i", "]", "+", "\"' in addition to '\"", "+", "map", "[", "files", "[", "j", "]", "]", "+", "\"' category.\"", ")", ";", "}", "else", "{", "map", "[", "files", "[", "j", "]", "]", "=", "categories", "[", "i", "]", ";", "}", "}", "}", "return", "map", ";", "}" ]

[ "Build", "complete", "map", "of", "known", "files", "." ]

[ "function", "validateBemJson", "(", "bemJson", ",", "fileName", ")", "{", "let", "errors", "=", "[", "]", ";", "if", "(", "Array", ".", "isArray", "(", "bemJson", ")", ")", "{", "bemJson", ".", "forEach", "(", "(", "childBemJson", ")", "=>", "{", "errors", "=", "errors", ".", "concat", "(", "validateBemJson", "(", "childBemJson", ",", "fileName", ")", ")", ";", "}", ")", ";", "}", "else", "if", "(", "bemJson", "instanceof", "Object", ")", "{", "Object", ".", "keys", "(", "bemJson", ")", ".", "forEach", "(", "(", "key", ")", "=>", "{", "const", "childBemJson", "=", "bemJson", "[", "key", "]", ";", "errors", "=", "errors", ".", "concat", "(", "validateBemJson", "(", "childBemJson", ",", "fileName", ")", ")", ";", "}", ")", ";", "errors", "=", "errors", ".", "concat", "(", "validateBemJsonNode", "(", "bemJson", ",", "fileName", ")", ")", ";", "// TODO", "}", "// TODO", "return", "errors", ";", "}" ]

[ "Validate", "BEM", "JSON" ]

[ "function", "extractBemJsonNode", "(", "bemJson", ")", "{", "let", "result", "=", "JSON", ".", "parse", "(", "JSON", ".", "stringify", "(", "bemJson", ")", ")", ";", "Object", ".", "keys", "(", "result", ")", ".", "forEach", "(", "(", "key", ")", "=>", "{", "result", "[", "key", "]", "=", "result", "[", "key", "]", ".", "toString", "(", ")", ";", "}", ")", ";", "return", "JSON", ".", "stringify", "(", "result", ",", "null", ",", "2", ")", ";", "}" ]

[ "Strips", "all", "child", "nodes", "from", "BemJson", "node", "for", "print", "puproses" ]

[ "function", "(", ")", "{", "var", "copy", "=", "[", "]", ";", "// Handle recursive loops", "if", "(", "queue", ".", "running", ")", "{", "queue", ".", "waiting", "=", "true", ";", "return", ";", "}", "// Mark queue as running, then search for ", "queue", ".", "running", "=", "true", ";", "munit", ".", "each", "(", "queue", ".", "modules", ",", "function", "(", "assert", ",", "index", ")", "{", "if", "(", "!", "queue", ".", "objects", ".", "length", ")", "{", "return", "false", ";", "}", "else", "if", "(", "!", "munit", ".", "render", ".", "checkDepency", "(", "assert", ")", ")", "{", "return", ";", "}", "// Looking for specific key in queue object", "if", "(", "munit", ".", "isString", "(", "assert", ".", "options", ".", "queue", ")", ")", "{", "munit", ".", "each", "(", "queue", ".", "objects", ",", "function", "(", "object", ",", "i", ")", "{", "if", "(", "object", "[", "assert", ".", "options", ".", "queue", "]", ")", "{", "queue", ".", "modules", "[", "index", "]", "=", "null", ";", "queue", ".", "objects", ".", "splice", "(", "i", ",", "1", ")", ";", "assert", ".", "queue", "=", "object", ";", "assert", ".", "trigger", "(", ")", ";", "return", "false", ";", "}", "}", ")", ";", "}", "// Any queue will do", "else", "{", "queue", ".", "modules", "[", "index", "]", "=", "null", ";", "assert", ".", "queue", "=", "queue", ".", "objects", ".", "shift", "(", ")", ";", "assert", ".", "trigger", "(", ")", ";", "}", "}", ")", ";", "// Clean out modules that completed (splicing causes iteration fails)", "queue", ".", "modules", ".", "forEach", "(", "function", "(", "assert", ")", "{", "if", "(", "assert", "!==", "null", ")", "{", "copy", ".", "push", "(", "assert", ")", ";", "}", "}", ")", ";", "queue", ".", "modules", "=", "copy", ";", "// Run again if check method was called during loop", "queue", ".", "running", "=", "false", ";", "if", "(", "queue", ".", "waiting", ")", "{", "queue", ".", "waiting", "=", "false", ";", "queue", ".", "check", "(", ")", ";", "}", "}" ]

[ "Runs", "through", "queued", "modules", "and", "finds", "objects", "to", "run", "them", "with" ]

[ "function", "recreate", "(", "makeStream", ",", "options", ")", "{", "if", "(", "options", "===", "undefined", "&&", "isObject", "(", "makeStream", ")", ")", "{", "options", "=", "makeStream", ";", "makeStream", "=", "options", ".", "makeStream", ";", "}", "options", "=", "options", "||", "{", "}", ";", "if", "(", "options", ".", "connect", "===", "undefined", ")", "{", "options", ".", "connect", "=", "true", ";", "}", "var", "connectedEvent", "=", "options", ".", "connectedEvent", "||", "'open'", ";", "var", "stream", "=", "through", "(", ")", ";", "stream", ".", "inverse", "=", "through", "(", ")", ";", "stream", ".", "inverse", ".", "pause", "(", ")", ";", "stream", ".", "write", "=", "function", "(", "chunk", ")", "{", "return", "stream", ".", "inverse", ".", "write", "(", "chunk", ")", ";", "}", ";", "stream", ".", "connect", "=", "function", "(", ")", "{", "stream", ".", "underlying", "=", "makeStream", "(", ")", ";", "stream", ".", "inverse", ".", "pipe", "(", "stream", ".", "underlying", ",", "{", "end", ":", "false", "}", ")", ";", "stream", ".", "underlying", ".", "on", "(", "'data'", ",", "function", "(", "chunk", ")", "{", "return", "stream", ".", "emit", "(", "'data'", ",", "chunk", ")", ";", "}", ")", ";", "stream", ".", "underlying", ".", "on", "(", "connectedEvent", ",", "function", "(", ")", "{", "stream", ".", "backoff", ".", "reset", "(", ")", ";", "stream", ".", "inverse", ".", "resume", "(", ")", ";", "stream", ".", "emit", "(", "'open'", ")", ";", "stream", ".", "emit", "(", "'underlying-open'", ")", ";", "}", ")", ";", "stream", ".", "underlying", ".", "on", "(", "'end'", ",", "function", "(", ")", "{", "stream", ".", "inverse", ".", "pause", "(", ")", ";", "if", "(", "!", "stream", ".", "preventBackoff", ")", "{", "stream", ".", "backoff", ".", "backoff", "(", ")", ";", "}", "stream", ".", "emit", "(", "'underlying-end'", ")", ";", "}", ")", ";", "stream", ".", "underlying", ".", "on", "(", "'error'", ",", "function", "(", "e", ")", "{", "stream", ".", "inverse", ".", "pause", "(", ")", ";", "if", "(", "!", "stream", ".", "preventBackoff", ")", "{", "stream", ".", "backoff", ".", "backoff", "(", ")", ";", "}", "stream", ".", "emit", "(", "'underlying-error'", ")", ";", "}", ")", ";", "}", ";", "var", "origEnd", "=", "stream", ".", "end", ".", "bind", "(", "stream", ")", ";", "stream", ".", "end", "=", "function", "(", ")", "{", "stream", ".", "preventBackoff", "=", "true", ";", "stream", ".", "underlying", ".", "end", "(", ")", ";", "return", "origEnd", "(", ")", ";", "}", ";", "stream", ".", "backoff", "=", "options", ".", "backoff", "||", "backoff", ".", "exponential", "(", "options", ")", ";", "stream", ".", "backoff", ".", "on", "(", "'backoff'", ",", "function", "(", "num", ",", "delay", ")", "{", "stream", ".", "emit", "(", "'backoff-schedule'", ",", "num", ",", "delay", ")", ";", "}", ")", ";", "stream", ".", "backoff", ".", "on", "(", "'ready'", ",", "function", "(", ")", "{", "stream", ".", "connect", "(", ")", ";", "stream", ".", "emit", "(", "'backoff-ready'", ")", ";", "}", ")", ";", "stream", ".", "backoff", ".", "on", "(", "'fail'", ",", "function", "(", ")", "{", "stream", ".", "emit", "(", "'backoff-fail'", ")", ";", "}", ")", ";", "if", "(", "options", ".", "connect", ")", "{", "stream", ".", "connect", "(", ")", ";", "}", "return", "stream", ";", "}" ]

[ "Create", "wrapper", "stream", "which", "takes", "care", "of", "recreating", "logic", "." ]

[ "function", "createServer", "(", ")", "{", "grunt", ".", "log", ".", "ok", "(", "'Registered as a grunt-net server ['", "+", "host", "+", "':'", "+", "port", "+", "'].'", ")", ";", "dnode", "(", "{", "spawn", ":", "spawn", "}", ")", ".", "listen", "(", "host", ",", "port", ")", ";", "}" ]

[ "create", "a", "server" ]

[ "function", "(", "token", ")", "{", "var", "pp", "=", "new", "JavascriptPreprocessor", "(", "this", ".", "parser", ",", "this", ".", "compiler", ",", "this", ".", "actions", ",", "this", ".", "scope", ",", "this", ".", "state", ")", ";", "if", "(", "token", ")", "{", "pp", ".", "code", "=", "this", ".", "get_code", "(", "this", ".", "code", ",", "token", ")", ";", "}", "return", "pp", ";", "}" ]

[ "Utils", "{{{", "1" ]

[ "function", "(", "action", ")", "{", "if", "(", "action", ")", "{", "switch", "(", "action", ".", "type", ")", "{", "case", "\"replace\"", ":", "this", ".", "code", "=", "`", "${", "this", ".", "code", ".", "substr", "(", "0", ",", "action", ".", "start", ")", "}", "${", "action", ".", "value", "}", "${", "this", ".", "code", ".", "substr", "(", "action", ".", "end", ")", "}", "`", ";", "return", "true", ";", "case", "\"remove\"", ":", "this", ".", "code", "=", "`", "${", "this", ".", "code", ".", "substr", "(", "0", ",", "action", ".", "start", ")", "}", "${", "this", ".", "code", ".", "substr", "(", "action", ".", "end", ")", "}", "`", ";", "return", "true", ";", "}", "}", "}" ]

[ "Actions", "{{{", "1" ]

[ "function", "(", "name", ",", "definition", ",", "is_return", ")", "{", "var", "pp", "=", "this", ".", "$new", "(", ")", ",", "code", "=", "`", "${", "name", "}", "${", "definition", ".", "toString", "(", ")", "}", "${", "is_return", "}", "`", ";", "pp", ".", "scope", "=", "this", ".", "scope", ";", "pp", ".", "process", "(", "\"[IN MEMORY]\"", ",", "code", ")", ";", "}" ]

[ "Define", "{{{", "1" ]

[ "function", "(", "code", ",", "tokens", ")", "{", "var", "actions", "=", "[", "]", ",", "i", "=", "0", ";", "this", ".", "code", "=", "code", ";", "for", "(", ";", "i", "<", "tokens", ".", "length", ";", "++", "i", ")", "{", "actions", "[", "i", "]", "=", "this", ".", "actions", ".", "invoke", "(", "this", ",", "tokens", "[", "i", "]", ")", ";", "}", "i", "=", "actions", ".", "length", ";", "while", "(", "i", "--", ")", "{", "this", ".", "action", "(", "actions", "[", "i", "]", ")", ";", "}", "return", "this", ".", "code", ";", "}" ]

[ "Processor", "{{{", "1" ]

[ "function", "(", "code", ")", "{", "try", "{", "return", "this", ".", "parser", ".", "parse", "(", "code", ")", ";", "}", "catch", "(", "e", ")", "{", "console", ".", "log", "(", "\"E\"", ",", "e", ")", ";", "console", ".", "log", "(", "code", ")", ";", "process", ".", "exit", "(", ")", ";", "}", "}" ]

[ "Parser", "{{{", "1" ]

[ "function", "callNew", "(", "T", ",", "args", ")", "{", "return", "new", "(", "Function", ".", "prototype", ".", "bind", ".", "apply", "(", "T", ",", "[", "null", "]", ".", "concat", "(", "args", ")", ")", ")", ";", "}" ]

[ "Give", "us", "a", "way", "to", "instantiate", "a", "new", "class", "with", "an", "array", "of", "args" ]

[ "function", "earley", "(", "tokens", ",", "grammar", ")", "{", "let", "states", "=", "Array", ".", "apply", "(", "null", ",", "Array", "(", "tokens", ".", "length", "+", "1", ")", ")", ".", "map", "(", "(", ")", "=>", "[", "]", ")", ";", "var", "i", ",", "j", ";", "let", "rulePairs", "=", "grammar", ".", "map", "(", "(", "rule", ")", "=>", "(", "{", "name", ":", "rule", ".", "lhs", ".", "name", ",", "rule", ":", "rule", ",", "position", ":", "0", ",", "origin", ":", "0", "}", ")", ")", ";", "[", "]", ".", "push", ".", "apply", "(", "states", "[", "0", "]", ",", "rulePairs", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<=", "tokens", ".", "length", ";", "i", "+=", "1", ")", "{", "for", "(", "j", "=", "0", ";", "j", "<", "states", "[", "i", "]", ".", "length", ";", "j", "+=", "1", ")", "{", "predict", "(", "tokens", ",", "states", ",", "i", ",", "j", ",", "grammar", ")", ";", "scan", "(", "tokens", ",", "states", ",", "i", ",", "j", ")", ";", "complete", "(", "tokens", ",", "states", ",", "i", ",", "j", ")", ";", "}", "}", "return", "swap", "(", "removeUnfinishedItems", "(", "states", ")", ")", ";", "}" ]

[ "Parses", "the", "input", "tokens", "using", "the", "earley", "top", "-", "down", "chart", "parsing", "algorithm", "to", "product", "a", "set", "of", "states", "each", "containing", "a", "list", "of", "earley", "items" ]

[ "function", "removeUnfinishedItems", "(", "states", ")", "{", "return", "states", ".", "map", "(", "(", "state", ")", "=>", "state", ".", "filter", "(", "(", "earleyItem", ")", "=>", "{", "return", "earleyItem", ".", "position", ">=", "earleyItem", ".", "rule", ".", "length", ";", "}", ")", ")", ";", "}" ]

[ "Removes", "earley", "items", "from", "each", "state", "that", "failed", "to", "completely", "parse", "through", ".", "In", "other", "words", "removes", "earley", "items", "whose", "position", "is", "less", "than", "the", "length", "of", "its", "rule" ]

[ "function", "swap", "(", "states", ")", "{", "let", "newStates", "=", "Array", ".", "apply", "(", "null", ",", "Array", "(", "states", ".", "length", ")", ")", ".", "map", "(", "(", ")", "=>", "[", "]", ")", ";", "states", ".", "forEach", "(", "(", "state", ",", "i", ")", "=>", "{", "state", ".", "forEach", "(", "(", "earleyItem", ")", "=>", "{", "newStates", "[", "earleyItem", ".", "origin", "]", ".", "push", "(", "earleyItem", ")", ";", "earleyItem", ".", "origin", "=", "i", ";", "}", ")", ";", "}", ")", ";", "return", "newStates", ";", "}" ]

[ "Places", "earley", "items", "in", "the", "states", "in", "which", "they", "originated", "as", "opposed", "to", "the", "states", "in", "which", "they", "finished", "parsing", "and", "set", "their", "origin", "properties", "to", "the", "state", "in", "which", "they", "finished", "." ]

[ "function", "dfsHelper", "(", "states", ",", "root", ",", "state", ",", "depth", ",", "tokens", ")", "{", "var", "edges", ";", "// Base case: we finished the root rule", "if", "(", "state", "===", "root", ".", "origin", "&&", "depth", "===", "root", ".", "rule", ".", "length", ")", "{", "return", "[", "]", ";", "}", "// If the current production symbol is a terminal", "if", "(", "root", ".", "rule", "[", "depth", "]", "instanceof", "RegExp", ")", "{", "if", "(", "root", ".", "rule", "[", "depth", "]", ".", "test", "(", "tokens", "[", "state", "]", ")", ")", "{", "let", "subMatch", "=", "dfsHelper", "(", "states", ",", "root", ",", "state", "+", "1", ",", "depth", "+", "1", ",", "tokens", ")", ";", "if", "(", "subMatch", ")", "{", "return", "[", "tokens", "[", "state", "]", "]", ".", "concat", "(", "subMatch", ")", ";", "}", "}", "return", "null", ";", "}", "else", "if", "(", "typeof", "root", ".", "rule", "[", "depth", "]", "===", "'string'", ")", "{", "if", "(", "root", ".", "rule", "[", "depth", "]", "===", "tokens", "[", "state", "]", ")", "{", "let", "subMatch", "=", "dfsHelper", "(", "states", ",", "root", ",", "state", "+", "1", ",", "depth", "+", "1", ",", "tokens", ")", ";", "if", "(", "subMatch", ")", "{", "return", "[", "tokens", "[", "state", "]", "]", ".", "concat", "(", "subMatch", ")", ";", "}", "}", "return", "null", ";", "}", "// Otherwise, it must be a non-terminal", "edges", "=", "states", "[", "state", "]", ".", "filter", "(", "(", "item", ")", "=>", "item", ".", "rule", ".", "lhs", "===", "root", ".", "rule", "[", "depth", "]", ")", ".", "map", "(", "(", "item", ")", "=>", "{", "let", "subMatch", "=", "dfsHelper", "(", "states", ",", "root", ",", "item", ".", "origin", ",", "depth", "+", "1", ",", "tokens", ")", ";", "if", "(", "subMatch", ")", "{", "return", "[", "{", "item", ":", "item", ".", "rule", ",", "children", ":", "dfsHelper", "(", "states", ",", "item", ",", "state", ",", "0", ",", "tokens", ")", "}", "]", ".", "concat", "(", "subMatch", ")", ";", "}", "return", "null", ";", "}", ")", ".", "filter", "(", "(", "list", ")", "=>", "list", ")", ";", "if", "(", "edges", ".", "length", ">", "1", ")", "{", "let", "diffs", "=", "edges", ".", "filter", "(", "(", "tree", ")", "=>", "JSON", ".", "stringify", "(", "tree", ")", "!==", "JSON", ".", "stringify", "(", "edges", "[", "0", "]", ")", ")", ";", "if", "(", "diffs", ".", "length", ">", "0", ")", "{", "//console.log('Ambiguity\\n' + JSON.stringify(edges, null, 2));", "console", ".", "log", "(", "'Ambiguous rules'", ")", ";", "}", "}", "return", "edges", "[", "0", "]", ";", "}" ]

[ "Recursive", "function", "that", "explores", "a", "specific", "earley", "item", "constructs", "the", "parse", "tree", "for", "it", "then", "sends", "it", "up", "the", "chimney!" ]

[ "function", "remove", "(", "ddqBackendInstance", ",", "recordId", ",", "callback", ")", "{", "// Note, this is not what we want.", "// it does not handle the times when the", "// isProcessing flag is true.", "ddqBackendInstance", ".", "deleteData", "(", "recordId", ")", ";", "ddqBackendInstance", ".", "checkAndEmitData", "(", ")", ";", "callback", "(", ")", ";", "}" ]

[ "Removes", "the", "message", "from", "stored", "data", "." ]

[ "function", "requeue", "(", "ddqBackendInstance", ",", "recordId", ",", "callback", ")", "{", "var", "record", ";", "record", "=", "ddqBackendInstance", ".", "getRecord", "(", "recordId", ")", ";", "record", ".", "isProcessing", "=", "false", ";", "record", ".", "requeued", "=", "true", ";", "callback", "(", ")", ";", "}" ]

[ "Sets", "the", "record", "to", "be", "requeued", "so", "another", "listener", "can", "pick", "it", "up", "and", "try", "to", "process", "the", "message", "again", "." ]

[ "function", "Command", "(", "name", ",", "cli", ",", "action", ")", "{", "if", "(", "!", "(", "this", "instanceof", "Command", ")", ")", "{", "return", "new", "Command", "(", "name", ",", "cli", ",", "action", ")", "}", "this", ".", "name", "=", "name", "this", ".", "cli", "=", "cli", "this", ".", "action", "=", "action", "}" ]

[ "The", "argument", "-", "parsing", "and", "action", "components", "of", "a", "CLI", "command", "are", "separated", "so", "that", "the", "CLI", "can", "both", "be", "imported", "from", "other", "modules", "and", "launched", "via", "PM2" ]

[ "function", "sortedArray", "(", "arr", ",", "comparator1", ",", "comparator2", ",", "comparator3", ")", "{", "var", "_", "=", "{", "}", ";", "arr", "=", "arr", "||", "[", "]", ";", "if", "(", "typeof", "arr", ".", "_sortedArray", "===", "\"object\"", ")", "{", "throw", "new", "Error", "(", "\"(sortedArray) Cannot extend array: Special key _sortedArray is already defined. Did you apply it twice?\"", ")", ";", "}", "arr", ".", "_sortedArray", "=", "_", ";", "_", ".", "reversed", "=", "false", ";", "_", ".", "push", "=", "arr", ".", "push", ";", "arr", ".", "push", "=", "push", ";", "_", ".", "unshift", "=", "arr", ".", "unshift", ";", "_", ".", "splice", "=", "arr", ".", "splice", ";", "arr", ".", "splice", "=", "splice", ";", "arr", ".", "unshift", "=", "push", ";", "_", ".", "indexOf", "=", "arr", ".", "indexOf", ";", "arr", ".", "indexOf", "=", "indexOf", ";", "_", ".", "sort", "=", "arr", ".", "sort", ";", "arr", ".", "sort", "=", "sort", ";", "_", ".", "reverse", "=", "arr", ".", "reverse", ";", "arr", ".", "reverse", "=", "reverse", ";", "arr", ".", "sortedIndex", "=", "sortedIndex", ";", "if", "(", "arguments", ".", "length", "===", "1", ")", "{", "arr", ".", "comparator", "=", "arr", ".", "comparator", "||", "defaultComparator", ";", "}", "else", "if", "(", "arguments", ".", "length", "===", "2", ")", "{", "arr", ".", "comparator", "=", "comparator1", ";", "}", "else", "{", "arr", ".", "comparator", "=", "multipleComparators", "(", "slice", ".", "call", "(", "arguments", ",", "1", ")", ")", ";", "}", "if", "(", "arr", ".", "length", ">", "0", ")", "{", "arr", ".", "sort", "(", ")", ";", "}", "return", "arr", ";", "}" ]

[ "Turns", "an", "array", "or", "every", "object", "with", "an", "array", "-", "like", "interface", "into", "a", "sorted", "array", "that", "maintains", "the", "sort", "order", ".", "This", "is", "basically", "achieved", "by", "replacing", "the", "original", "mutator", "methods", "with", "versions", "that", "respect", "the", "order", "." ]

[ "function", "indexOf", "(", "element", ",", "fromIndex", ")", "{", "/* jshint validthis:true */", "var", "arr", "=", "toArray", "(", "this", ")", ",", "index", ";", "if", "(", "fromIndex", ")", "{", "arr", "=", "arr", ".", "slice", "(", "fromIndex", ")", ";", "}", "index", "=", "binarySearch", "(", "arr", ",", "element", ",", "this", ".", "comparator", ")", ";", "if", "(", "index", "<", "0", ")", "{", "return", "-", "1", ";", "}", "else", "{", "return", "index", ";", "}", "}" ]

[ "Works", "like", "Array", ".", "prototype", ".", "indexOf", "but", "uses", "a", "faster", "binary", "search", "." ]

[ "function", "reverse", "(", ")", "{", "/* jshint validthis:true */", "var", "_", "=", "this", ".", "_sortedArray", ",", "reversed", "=", "_", ".", "reversed", ";", "if", "(", "reversed", ")", "{", "this", ".", "comparator", "=", "this", ".", "comparator", ".", "original", ";", "}", "else", "{", "this", ".", "comparator", "=", "getInversionOf", "(", "this", ".", "comparator", ")", ";", "}", "_", ".", "reversed", "=", "!", "reversed", ";", "_", ".", "reverse", ".", "call", "(", "this", ")", ";", "}" ]

[ "Works", "like", "Array", ".", "prototype", ".", "reverse", "." ]