Datasets:

---

CM

/

codexglue_code2text_javascript

like 12

[ "function", "addProperty", "(", "sourceData", ",", "propertiesGroups", ",", "filePath", ")", "{", "var", "group", "=", "propertiesUtils", ".", "getGroup", "(", "sourceData", "[", "2", "]", ",", "propertiesGroups", ")", ",", "propertyName", ",", "data", ",", "propertyDefinitionWithoutObjectName", ";", "if", "(", "!", "group", ")", "{", "grunt", ".", "log", ".", "error", "(", "'Object '", "+", "sourceData", "[", "2", "]", "+", "' without init file'", ")", ";", "return", ";", "}", "grunt", ".", "verbose", ".", "ok", "(", "sourceData", "[", "2", "]", ")", ";", "// generate property data", "propertyDefinitionWithoutObjectName", "=", "sourceData", "[", "2", "]", ".", "replace", "(", "group", ".", "pattern", ",", "''", ")", ".", "replace", "(", "/", "^\\.", "/", ",", "''", ")", ";", "propertyName", "=", "propertyDefinitionWithoutObjectName", ".", "replace", "(", "/", "^prototype\\.", "/", "i", ",", "''", ")", ";", "data", "=", "{", "name", ":", "propertyName", ",", "source", ":", "sourceData", "[", "3", "]", ".", "replace", "(", "/", "(^[\\r\\n\\s]+|[\\r\\n\\s;]+$)", "/", "g", ",", "''", ")", ",", "comment", ":", "sourceData", "[", "1", "]", "||", "''", ",", "type", ":", "propertiesUtils", ".", "isFunction", "(", "sourceData", "[", "3", "]", ")", "?", "'function'", ":", "'object'", ",", "isPublic", ":", "propertiesUtils", ".", "isPublic", "(", "propertyName", ")", ",", "isFromPrototype", ":", "propertiesUtils", ".", "isFromPrototype", "(", "propertyDefinitionWithoutObjectName", ")", ",", "filePath", ":", "filePath", "}", ";", "// add property data to prototype or inline array", "group", "[", "(", "data", ".", "isFromPrototype", "?", "'prototypeProperties'", ":", "'inlineProperties'", ")", "]", ".", "push", "(", "data", ")", ";", "}" ]

[ "Add", "property", "data", "to", "their", "properties", "group" ]

[ "function", "addJSONProperties", "(", "jsonData", ",", "propertiesGroups", ",", "filePath", ",", "currentNamesPath", ")", "{", "var", "i", ",", "group", ",", "propertyDefinition", ",", "propertyDefinitionWithoutObjectName", ",", "propertyName", ",", "data", ";", "if", "(", "currentNamesPath", "===", "undefined", ")", "{", "currentNamesPath", "=", "''", ";", "}", "// get all values", "for", "(", "i", "in", "jsonData", ")", "{", "// add to group if is a simply object", "if", "(", "jsonData", "[", "i", "]", "instanceof", "Array", "||", "jsonData", "[", "i", "]", "==", "null", "||", "typeof", "jsonData", "[", "i", "]", "!==", "'object'", "||", "grunt", ".", "util", ".", "_", ".", "isEmpty", "(", "jsonData", "[", "i", "]", ")", ")", "{", "// find group", "propertyDefinition", "=", "(", "currentNamesPath", "?", "currentNamesPath", "+", "'.'", "+", "i", ":", "i", ")", ".", "replace", "(", "/", "^[^.]+\\.", "/", ",", "''", ")", ";", "group", "=", "propertiesUtils", ".", "getGroup", "(", "propertyDefinition", ",", "propertiesGroups", ")", ";", "if", "(", "!", "group", ")", "{", "grunt", ".", "log", ".", "error", "(", "'Object '", "+", "propertyDefinition", "+", "' without init file'", ")", ";", "return", ";", "}", "grunt", ".", "verbose", ".", "ok", "(", "propertyDefinition", ")", ";", "// generate property data", "propertyDefinitionWithoutObjectName", "=", "propertyDefinition", ".", "replace", "(", "group", ".", "pattern", ",", "''", ")", ".", "replace", "(", "/", "^\\.", "/", ",", "''", ")", ";", "propertyName", "=", "propertyDefinitionWithoutObjectName", ".", "replace", "(", "/", "^prototype\\.", "/", "i", ",", "''", ")", ";", "data", "=", "{", "name", ":", "propertyName", ",", "comment", ":", "''", ",", "type", ":", "'object'", ",", "isPublic", ":", "propertiesUtils", ".", "isPublic", "(", "propertyName", ")", ",", "isFromPrototype", ":", "propertiesUtils", ".", "isFromPrototype", "(", "propertyDefinitionWithoutObjectName", ")", ",", "filePath", ":", "filePath", "}", ";", "// string -> \"string\"", "// true -> true", "switch", "(", "typeof", "jsonData", "[", "i", "]", ")", "{", "case", "'object'", ":", "if", "(", "jsonData", "[", "i", "]", "!=", "null", ")", "{", "data", ".", "source", "=", "JSON", ".", "stringify", "(", "jsonData", "[", "i", "]", ")", ";", "}", "break", ";", "case", "'string'", ":", "data", ".", "source", "=", "'\"'", "+", "jsonData", "[", "i", "]", ".", "split", "(", "'\"'", ")", ".", "join", "(", "'\\\\\"'", ")", "+", "'\"'", ";", "break", ";", "}", "if", "(", "data", ".", "source", "===", "undefined", ")", "{", "data", ".", "source", "=", "''", "+", "jsonData", "[", "i", "]", ";", "}", "// add property data to prototype or inline array", "group", "[", "(", "data", ".", "isFromPrototype", "?", "'prototypeProperties'", ":", "'inlineProperties'", ")", "]", ".", "push", "(", "data", ")", ";", "}", "else", "{", "// is object", "// add attributeName to path and try to add", "addJSONProperties", "(", "jsonData", "[", "i", "]", ",", "propertiesGroups", ",", "filePath", ",", "currentNamesPath", "?", "currentNamesPath", "+", "'.'", "+", "i", ":", "i", ")", ";", "}", "}", "}" ]

[ "Add", "JSON", "properties", "values", "to", "their", "properties", "group" ]

[ "function", "onChunk", "(", "count", ")", "{", "// If chunk read has no bytes than there is nothing left, so end a", "// collection.", "if", "(", "count", "===", "0", ")", "return", "next", "(", "end", ")", "// Move a offset `position` with `count` towards the end unless", "// position was a `null` in which case we just keep it (`null` means", "// from a current position).", "position", "=", "position", "===", "null", "?", "position", ":", "position", "+", "count", "// Read chunk is forwarded to a consumer that will return", "// a promise which is delivered once write is complete.", "// In a future we may switch to an approach similar to new", "// streams in node, where buffering watermarks are specified", "// via options and reads can buffer up up to that point in", "// parallel to write.", "when", "(", "next", "(", "buffer", ".", "slice", "(", "0", ",", "count", ")", ",", "state", ")", ",", "onDrain", ",", "onError", ")", "}" ]

[ "Function", "is", "used", "to", "read", "out", "given", "count", "bytes", "from", "the", "file", "starting", "from", "the", "current", "position", ".", "Note", "that", "position", "is", "captured", ".", "onChunk", "handler", "is", "invoked", "after", "reading", "a", "chunk", "of", "a", "file", "." ]

[ "function", "onDrain", "(", "value", ")", "{", "state", "=", "value", "// If value is marked as `reduced` no further reads should take place,", "// as consumer has finished consumption.", "if", "(", "isReduced", "(", "value", ")", ")", "return", "next", "(", "end", ")", "// If current `position` has reached or passed `finish` mark end a", "// collection.", "else", "if", "(", "position", ">=", "finish", ")", "return", "next", "(", "end", ",", "state", ")", "// Otherwise read another chunk from the current position & execute", "// `onChunk` handler or `onError` if fails. Note that `readChunk`", "// reads chunk and returns either number of bytes read or a promise", "// for that or an error if failed. Errors will invoke onError handler", "// causing collection error and end. `onChunk` will propagate data", "// further likely to the writer on the other end.", "when", "(", "readChunk", "(", "fd", ",", "buffer", ",", "position", ",", "size", ")", ",", "onChunk", ",", "onError", ")", "}" ]

[ "Handler", "is", "invoked", "whenever", "consumer", "of", "the", "collection", "finished", "consumption", "of", "the", "previous", "chunk", "and", "can", "accept", "more", "data", ".", "It", "s", "also", "passed", "a", "new", "state", "value", "that", "is", "being", "accumulated", "." ]

[ "function", "(", "objects", ")", "{", "if", "(", "!", "_", ".", "isArray", "(", "objects", ")", ")", "{", "objects", "=", "[", "objects", "]", ";", "}", "var", "change", "=", "new", "Parse", ".", "Op", ".", "Relation", "(", "objects", ",", "[", "]", ")", ";", "this", ".", "parent", ".", "set", "(", "this", ".", "key", ",", "change", ")", ";", "this", ".", "targetClassName", "=", "change", ".", "_targetClassName", ";", "}" ]

[ "Adds", "a", "Parse", ".", "Object", "or", "an", "array", "of", "Parse", ".", "Objects", "to", "the", "relation", "." ]

[ "function", "(", ")", "{", "var", "targetClass", ";", "var", "query", ";", "if", "(", "!", "this", ".", "targetClassName", ")", "{", "targetClass", "=", "Parse", ".", "Object", ".", "_getSubclass", "(", "this", ".", "parent", ".", "className", ")", ";", "query", "=", "new", "Parse", ".", "Query", "(", "targetClass", ")", ";", "query", ".", "_extraOptions", ".", "redirectClassNameForKey", "=", "this", ".", "key", ";", "}", "else", "{", "targetClass", "=", "Parse", ".", "Object", ".", "_getSubclass", "(", "this", ".", "targetClassName", ")", ";", "query", "=", "new", "Parse", ".", "Query", "(", "targetClass", ")", ";", "}", "query", ".", "_addCondition", "(", "\"$relatedTo\"", ",", "\"object\"", ",", "this", ".", "parent", ".", "_toPointer", "(", ")", ")", ";", "query", ".", "_addCondition", "(", "\"$relatedTo\"", ",", "\"key\"", ",", "this", ".", "key", ")", ";", "return", "query", ";", "}" ]

[ "Returns", "a", "Parse", ".", "Query", "that", "is", "limited", "to", "objects", "in", "this", "relation", "." ]

[ "function", "(", "s_line", ",", "s_close_delim", ",", "z_merge_delim", ")", "{", "// open block", "add", "(", "s_line", "||", "''", ",", "z_merge_delim", ",", "true", ")", ";", "// set close delim", "s_close", "=", "(", "'string'", "===", "typeof", "s_close_delim", ")", "?", "s_close_delim", ":", "a_closers", ".", "slice", "(", "-", "1", ")", "[", "0", "]", ";", "a_closers", ".", "push", "(", "s_close", ")", ";", "// increase indentation", "add", ".", "tabs", "+=", "1", ";", "}" ]

[ "block", "open", "helper" ]

[ "function", "trimHtml", "(", "html", ")", "{", "function", "trimSpaces", "(", "all", ",", "s1", ",", "s2", ")", "{", "// WebKit &nbsp; meant to preserve multiple spaces but instead inserted around all inline tags,", "// including the spans with inline styles created on paste", "if", "(", "!", "s1", "&&", "!", "s2", ")", "{", "return", "' '", ";", "}", "return", "'\\u00a0'", ";", "}", "html", "=", "filter", "(", "html", ",", "[", "/", "^[\\s\\S]*<body[^>]*>\\s*|\\s*<\\/body[^>]*>[\\s\\S]*$", "/", "ig", ",", "// Remove anything but the contents within the BODY element", "/", "<!--StartFragment-->|<!--EndFragment-->", "/", "g", ",", "// Inner fragments (tables from excel on mac)", "[", "/", "( ?)<span class=\"Apple-converted-space\">\\u00a0<\\/span>( ?)", "/", "g", ",", "trimSpaces", "]", ",", "/", "<br class=\"Apple-interchange-newline\">", "/", "g", ",", "/", "<br>$", "/", "i", "// Trailing BR elements", "]", ")", ";", "return", "html", ";", "}" ]

[ "Trims", "the", "specified", "HTML", "by", "removing", "all", "WebKit", "fragments", "all", "elements", "wrapping", "the", "body", "trailing", "BR", "elements", "etc", "." ]

[ "function", "getDataTransferItems", "(", "dataTransfer", ")", "{", "var", "items", "=", "{", "}", ";", "if", "(", "dataTransfer", ")", "{", "// Use old WebKit/IE API", "if", "(", "dataTransfer", ".", "getData", ")", "{", "var", "legacyText", "=", "dataTransfer", ".", "getData", "(", "'Text'", ")", ";", "if", "(", "legacyText", "&&", "legacyText", ".", "length", ">", "0", ")", "{", "if", "(", "legacyText", ".", "indexOf", "(", "mceInternalUrlPrefix", ")", "==", "-", "1", ")", "{", "items", "[", "'text/plain'", "]", "=", "legacyText", ";", "}", "}", "}", "if", "(", "dataTransfer", ".", "types", ")", "{", "for", "(", "var", "i", "=", "0", ";", "i", "<", "dataTransfer", ".", "types", ".", "length", ";", "i", "++", ")", "{", "var", "contentType", "=", "dataTransfer", ".", "types", "[", "i", "]", ";", "try", "{", "// IE11 throws exception when contentType is Files (type is present but data cannot be retrieved via getData())", "items", "[", "contentType", "]", "=", "dataTransfer", ".", "getData", "(", "contentType", ")", ";", "}", "catch", "(", "ex", ")", "{", "items", "[", "contentType", "]", "=", "\"\"", ";", "// useless in general, but for consistency across browsers", "}", "}", "}", "}", "return", "items", ";", "}" ]

[ "Gets", "various", "content", "types", "out", "of", "a", "datatransfer", "object", "." ]

[ "function", "(", "originalIt", ")", "{", "return", "function", "it", "(", "desc", ",", "cb", ")", "{", "if", "(", "cb", ".", "length", "===", "0", ")", "{", "originalIt", "(", "desc", ",", "cb", ")", ";", "}", "else", "{", "originalIt", "(", "desc", ",", "wrapInTryCatch", "(", "cb", ")", ")", ";", "}", "}", ";", "}" ]

[ "wrap", "jasmine", "s", "it", "function", "so", "that", "each", "test", "is", "wrapped", "in", "a", "trycatch", "handler" ]

[ "function", "mount", "(", "mountLocation", ",", "tagname", ",", "props", ")", "{", "// return riot.mount(mountLocation, tagname, props)[0];", "const", "id", "=", "makeUID", "(", "`", "${", "tagname", "}", "`", ")", ";", "const", "fauxTag", "=", "`", "${", "tagname", "}", "${", "tagname", "}", "${", "id", "}", "${", "tagname", "}", "`", ";", "// Loop through all sub-mounted editors that might already exist in the", "// mount location and properly unmount them for clean up", "const", "selector", "=", "'[data-elmoed-editor]'", ";", "const", "subEditors", "=", "mountLocation", ".", "querySelectorAll", "(", "selector", ")", ";", "for", "(", "const", "submountedEditor", "of", "subEditors", ")", "{", "// _tag learned from: https://github.com/riot/riot/issues/934", "// Might not be maintained, hence the check for its existence", "if", "(", "!", "submountedEditor", ".", "_tag", ")", "{", "console", ".", "error", "(", "'Unsuccessful unmount tag: Bad Riot.js version?'", ")", ";", "continue", ";", "}", "submountedEditor", ".", "_tag", ".", "unmount", "(", ")", ";", "}", "/* eslint-disable no-param-reassign */", "// Clear any initial HTML", "mountLocation", ".", "innerHTML", "=", "''", ";", "// Add in the HTML in the right location for riot to find", "mountLocation", ".", "innerHTML", "=", "fauxTag", ";", "// Finally, mount the element where it belongs", "const", "tagInstance", "=", "riot", ".", "mount", "(", "`", "${", "id", "}", "`", ",", "props", ")", "[", "0", "]", ";", "tagInstance", ".", "on", "(", "'before-unmount'", ",", "(", ")", "=>", "{", "props", ".", "clearAll", "(", ")", ";", "// ensure everything gets cleared", "}", ")", ";", "return", "tagInstance", ";", "}" ]

[ "riot", ".", "js", "adaptor" ]

[ "function", "(", "editor", ",", "name", ",", "isIndent", ")", "{", "this", ".", "name", "=", "name", ";", "this", ".", "editor", "=", "editor", ";", "/**\r\n\t\t\t * An object of jobs handled by the command. Each job consists\r\n\t\t\t * of two functions: `refresh` and `exec` as well as the execution priority.\r\n\t\t\t *\r\n\t\t\t *\t* The `refresh` function determines whether a job is doable for\r\n\t\t\t *\t a particular context. These functions are executed in the\r\n\t\t\t *\t order of priorities, one by one, for all plugins that registered\r\n\t\t\t *\t jobs. As jobs are related to generic commands, refreshing\r\n\t\t\t *\t occurs when the global command is firing the `refresh` event.\r\n\t\t\t *\r\n\t\t\t *\t **Note**: This function must return either {@link CKEDITOR#TRISTATE_DISABLED}\r\n\t\t\t *\t or {@link CKEDITOR#TRISTATE_OFF}.\r\n\t\t\t *\r\n\t\t\t *\t* The `exec` function modifies the DOM if possible. Just like\r\n\t\t\t *\t `refresh`, `exec` functions are executed in the order of priorities\r\n\t\t\t *\t while the generic command is executed. This function is not executed\r\n\t\t\t *\t if `refresh` for this job returned {@link CKEDITOR#TRISTATE_DISABLED}.\r\n\t\t\t *\r\n\t\t\t *\t **Note**: This function must return a Boolean value, indicating whether it\r\n\t\t\t *\t was successful. If a job was successful, then no other jobs are being executed.\r\n\t\t\t *\r\n\t\t\t * Sample definition:\r\n\t\t\t *\r\n\t\t\t *\t\tcommand.jobs = {\r\n\t\t\t *\t\t\t// Priority = 20.\r\n\t\t\t *\t\t\t'20': {\r\n\t\t\t *\t\t\t\trefresh( editor, path ) {\r\n\t\t\t *\t\t\t\t\tif ( condition )\r\n\t\t\t *\t\t\t\t\t\treturn CKEDITOR.TRISTATE_OFF;\r\n\t\t\t *\t\t\t\t\telse\r\n\t\t\t *\t\t\t\t\t\treturn CKEDITOR.TRISTATE_DISABLED;\r\n\t\t\t *\t\t\t\t},\r\n\t\t\t *\t\t\t\texec( editor ) {\r\n\t\t\t *\t\t\t\t\t// DOM modified! This was OK.\r\n\t\t\t *\t\t\t\t\treturn true;\r\n\t\t\t *\t\t\t\t}\r\n\t\t\t *\t\t\t},\r\n\t\t\t *\t\t\t// Priority = 60. This job is done later.\r\n\t\t\t *\t\t\t'60': {\r\n\t\t\t *\t\t\t\t// Another job.\r\n\t\t\t *\t\t\t}\r\n\t\t\t *\t\t};\r\n\t\t\t *\r\n\t\t\t * For additional information, please check comments for\r\n\t\t\t * the `setupGenericListeners` function.\r\n\t\t\t *\r\n\t\t\t * @readonly\r\n\t\t\t * @property {Object} [={}]\r\n\t\t\t */", "this", ".", "jobs", "=", "{", "}", ";", "/**\r\n\t\t\t * Determines whether the editor that the command belongs to has\r\n\t\t\t * {@link CKEDITOR.config#enterMode config.enterMode} set to {@link CKEDITOR#ENTER_BR}.\r\n\t\t\t *\r\n\t\t\t * @readonly\r\n\t\t\t * @see CKEDITOR.config#enterMode\r\n\t\t\t * @property {Boolean} [=false]\r\n\t\t\t */", "this", ".", "enterBr", "=", "editor", ".", "config", ".", "enterMode", "==", "CKEDITOR", ".", "ENTER_BR", ";", "/**\r\n\t\t\t * Determines whether the command belongs to the indentation family.\r\n\t\t\t * Otherwise it is assumed to be an outdenting command.\r\n\t\t\t *\r\n\t\t\t * @readonly\r\n\t\t\t * @property {Boolean} [=false]\r\n\t\t\t */", "this", ".", "isIndent", "=", "!", "!", "isIndent", ";", "/**\r\n\t\t\t * The name of the global command related to this one.\r\n\t\t\t *\r\n\t\t\t * @readonly\r\n\t\t\t */", "this", ".", "relatedGlobal", "=", "isIndent", "?", "'indent'", ":", "'outdent'", ";", "/**\r\n\t\t\t * A keystroke associated with this command (*Tab* or *Shift+Tab*).\r\n\t\t\t *\r\n\t\t\t * @readonly\r\n\t\t\t */", "this", ".", "indentKey", "=", "isIndent", "?", "9", ":", "CKEDITOR", ".", "SHIFT", "+", "9", ";", "/**\r\n\t\t\t * Stores created markers for the command so they can eventually be\r\n\t\t\t * purged after the `exec` function is run.\r\n\t\t\t */", "this", ".", "database", "=", "{", "}", ";", "}" ]

[ "A", "base", "class", "for", "specific", "indentation", "command", "definitions", "responsible", "for", "handling", "a", "pre", "-", "defined", "set", "of", "elements", "i", ".", "e", ".", "indentlist", "for", "lists", "or", "indentblock", "for", "text", "block", "elements", "." ]

[ "function", "(", "editor", ",", "commands", ")", "{", "editor", ".", "on", "(", "'pluginsLoaded'", ",", "function", "(", ")", "{", "for", "(", "var", "name", "in", "commands", ")", "{", "(", "function", "(", "editor", ",", "command", ")", "{", "var", "relatedGlobal", "=", "editor", ".", "getCommand", "(", "command", ".", "relatedGlobal", ")", ";", "for", "(", "var", "priority", "in", "command", ".", "jobs", ")", "{", "// Observe generic exec event and execute command when necessary.\r", "// If the command was successfully handled by the command and\r", "// DOM has been modified, stop event propagation so no other plugin\r", "// will bother. Job is done.\r", "relatedGlobal", ".", "on", "(", "'exec'", ",", "function", "(", "evt", ")", "{", "if", "(", "evt", ".", "data", ".", "done", ")", "return", ";", "// Make sure that anything this command will do is invisible\r", "// for undoManager. What undoManager only can see and\r", "// remember is the execution of the global command (relatedGlobal).\r", "editor", ".", "fire", "(", "'lockSnapshot'", ")", ";", "if", "(", "command", ".", "execJob", "(", "editor", ",", "priority", ")", ")", "evt", ".", "data", ".", "done", "=", "true", ";", "editor", ".", "fire", "(", "'unlockSnapshot'", ")", ";", "// Clean up the markers.\r", "CKEDITOR", ".", "dom", ".", "element", ".", "clearAllMarkers", "(", "command", ".", "database", ")", ";", "}", ",", "this", ",", "null", ",", "priority", ")", ";", "// Observe generic refresh event and force command refresh.\r", "// Once refreshed, save command state in event data\r", "// so generic command plugin can update its own state and UI.\r", "relatedGlobal", ".", "on", "(", "'refresh'", ",", "function", "(", "evt", ")", "{", "if", "(", "!", "evt", ".", "data", ".", "states", ")", "evt", ".", "data", ".", "states", "=", "{", "}", ";", "evt", ".", "data", ".", "states", "[", "command", ".", "name", "+", "'@'", "+", "priority", "]", "=", "command", ".", "refreshJob", "(", "editor", ",", "priority", ",", "evt", ".", "data", ".", "path", ")", ";", "}", ",", "this", ",", "null", ",", "priority", ")", ";", "}", "// Since specific indent commands have no UI elements,\r", "// they need to be manually registered as a editor feature.\r", "editor", ".", "addFeature", "(", "command", ")", ";", "}", ")", "(", "this", ",", "commands", "[", "name", "]", ")", ";", "}", "}", ")", ";", "}" ]

[ "Registers", "content", "-", "specific", "commands", "as", "a", "part", "of", "the", "indentation", "system", "directed", "by", "generic", "commands", ".", "Once", "a", "command", "is", "registered", "it", "listens", "for", "events", "of", "a", "related", "generic", "command", "." ]

[ "function", "(", "editor", ",", "priority", ")", "{", "var", "job", "=", "this", ".", "jobs", "[", "priority", "]", ";", "if", "(", "job", ".", "state", "!=", "TRISTATE_DISABLED", ")", "return", "job", ".", "exec", ".", "call", "(", "this", ",", "editor", ")", ";", "}" ]

[ "Executes", "the", "content", "-", "specific", "procedure", "if", "the", "context", "is", "correct", ".", "It", "calls", "the", "exec", "function", "of", "a", "job", "of", "the", "given", "priority", "that", "modifies", "the", "DOM", "." ]

[ "function", "setupGenericListeners", "(", "editor", ",", "command", ")", "{", "var", "selection", ",", "bookmarks", ";", "// Set the command state according to content-specific\r", "// command states.\r", "command", ".", "on", "(", "'refresh'", ",", "function", "(", "evt", ")", "{", "// If no state comes with event data, disable command.\r", "var", "states", "=", "[", "TRISTATE_DISABLED", "]", ";", "for", "(", "var", "s", "in", "evt", ".", "data", ".", "states", ")", "states", ".", "push", "(", "evt", ".", "data", ".", "states", "[", "s", "]", ")", ";", "this", ".", "setState", "(", "CKEDITOR", ".", "tools", ".", "search", "(", "states", ",", "TRISTATE_OFF", ")", "?", "TRISTATE_OFF", ":", "TRISTATE_DISABLED", ")", ";", "}", ",", "command", ",", "null", ",", "100", ")", ";", "// Initialization. Save bookmarks and mark event as not handled\r", "// by any plugin (command) yet.\r", "command", ".", "on", "(", "'exec'", ",", "function", "(", "evt", ")", "{", "selection", "=", "editor", ".", "getSelection", "(", ")", ";", "bookmarks", "=", "selection", ".", "createBookmarks", "(", "1", ")", ";", "// Mark execution as not handled yet.\r", "if", "(", "!", "evt", ".", "data", ")", "evt", ".", "data", "=", "{", "}", ";", "evt", ".", "data", ".", "done", "=", "false", ";", "}", ",", "command", ",", "null", ",", "0", ")", ";", "// Housekeeping. Make sure selectionChange will be called.\r", "// Also re-select previously saved bookmarks.\r", "command", ".", "on", "(", "'exec'", ",", "function", "(", "evt", ")", "{", "editor", ".", "forceNextSelectionCheck", "(", ")", ";", "selection", ".", "selectBookmarks", "(", "bookmarks", ")", ";", "}", ",", "command", ",", "null", ",", "100", ")", ";", "}" ]

[ "Attaches", "event", "listeners", "for", "this", "generic", "command", ".", "Since", "the", "indentation", "system", "is", "event", "-", "oriented", "generic", "commands", "communicate", "with", "content", "-", "specific", "commands", "using", "the", "exec", "and", "refresh", "events", "." ]

[ "function", "(", "event", ",", "fn", ",", "context", ")", "{", "this", ".", "_events", "=", "this", ".", "_events", "||", "{", "}", ";", "var", "e", "=", "this", ".", "_events", "[", "event", "]", "||", "(", "this", ".", "_events", "[", "event", "]", "=", "[", "]", ")", ";", "e", ".", "push", "(", "[", "fn", ",", "context", "]", ")", ";", "}" ]

[ "Adds", "a", "callback", "to", "the", "event", "queue", "which", "is", "executed", "when", "an", "event", "fires" ]

[ "function", "(", "obj", ",", "event", ",", "fn", ",", "context", ")", "{", "var", "listeningTo", "=", "this", ".", "_listeningTo", "||", "(", "this", ".", "_listeningTo", "=", "{", "}", ")", ";", "var", "id", "=", "obj", ".", "_listenId", "||", "(", "obj", ".", "_listenId", "=", "eventIndex", "++", ")", ";", "listeningTo", "[", "id", "]", "=", "obj", ";", "if", "(", "!", "fn", "&&", "typeof", "event", "===", "'object'", ")", "{", "fn", "=", "this", ";", "}", "if", "(", "!", "context", ")", "{", "context", "=", "this", ";", "}", "obj", ".", "on", "(", "event", ",", "fn", ",", "context", ")", ";", "}" ]

[ "Observe", "another", "object", "by", "adding", "a", "callback", "to", "its", "event", "queue", "which", "is", "executed", "when", "an", "event", "fires" ]

[ "function", "(", "event", ",", "fn", ")", "{", "this", ".", "_events", "=", "this", ".", "_events", "||", "{", "}", ";", "var", "e", "=", "this", ".", "_events", "[", "event", "]", ";", "if", "(", "e", ")", "{", "for", "(", "var", "i", "=", "0", ",", "l", "=", "e", ".", "length", ";", "i", "<", "l", ";", "i", "++", ")", "{", "if", "(", "e", "[", "i", "]", "[", "0", "]", "===", "fn", ")", "{", "e", ".", "splice", "(", "i", ",", "1", ")", ";", "i", "--", ";", "l", "--", ";", "}", "}", "}", "}" ]

[ "Removes", "a", "callback", "from", "the", "event", "queue" ]

[ "function", "(", "obj", ",", "event", ",", "fn", ")", "{", "var", "listeningTo", "=", "this", ".", "_listeningTo", ";", "if", "(", "!", "listeningTo", ")", "{", "return", ";", "}", "var", "remove", "=", "!", "event", "&&", "!", "fn", ";", "if", "(", "!", "fn", "&&", "typeof", "event", "===", "'object'", ")", "{", "fn", "=", "this", ";", "}", "if", "(", "obj", ")", "{", "(", "listeningTo", "=", "{", "}", ")", "[", "obj", ".", "_listenId", "]", "=", "obj", ";", "}", "for", "(", "var", "id", "in", "listeningTo", ")", "{", "obj", "=", "listeningTo", "[", "id", "]", ";", "obj", ".", "off", "(", "event", ",", "fn", ",", "this", ")", ";", "if", "(", "remove", ")", "{", "delete", "this", ".", "_listeningTo", "[", "id", "]", ";", "}", "}", "}" ]

[ "Stop", "observing", "another", "object" ]

[ "function", "(", "event", "/*, args... */", ")", "{", "this", ".", "_events", "=", "this", ".", "_events", "||", "{", "}", ";", "var", "e", "=", "this", ".", "_events", "[", "event", "]", ";", "if", "(", "e", ")", "{", "for", "(", "var", "i", "=", "0", ",", "l", "=", "e", ".", "length", ";", "i", "<", "l", ";", "i", "++", ")", "{", "e", "[", "i", "]", "[", "0", "]", ".", "apply", "(", "e", "[", "i", "]", "[", "1", "]", "||", "this", ",", "slice", "(", "arguments", ",", "1", ")", ")", ";", "}", "}", "}" ]

[ "Trigger", "an", "event", "and", "execute", "all", "callbacks", "in", "the", "event", "queue" ]

[ "function", "Property", "(", "initValue", ")", "{", "if", "(", "arguments", ".", "length", ")", "{", "this", ".", "set", "(", "initValue", ")", ";", "}", "else", "{", "this", ".", "set", "(", "this", ".", "defaultValue", ")", ";", "}", "ok", ".", "Data", ".", "apply", "(", "this", ",", "arguments", ")", ";", "}" ]

[ "Optionally", "initialize", "this", "property", "with", "a", "value" ]

[ "function", "(", "newValue", ")", "{", "var", "oldValue", "=", "this", ".", "_value", ";", "if", "(", "oldValue", "!==", "newValue", ")", "{", "this", ".", "_value", "=", "newValue", ";", "this", ".", "trigger", "(", "EVENT_CHANGE", ",", "this", ",", "newValue", ",", "oldValue", ")", ";", "}", "}" ]

[ "Replace", "the", "internal", "property", "with", "a", "new", "value", "and", "trigger", "a", "change" ]

[ "function", "(", ")", "{", "var", "properties", "=", "this", ".", "properties", ";", "_", ".", "forEach", "(", "properties", ",", "function", "(", "prop", ",", "name", ")", "{", "prop", "=", "this", ".", "getProperty", "(", "name", ")", ";", "this", ".", "stopListening", "(", "prop", ",", "EVENT_CHANGE", ")", ";", "}", ",", "this", ")", ";", "}" ]

[ "Remove", "all", "events", "listeners" ]

[ "function", "(", "properties", ")", "{", "properties", "=", "properties", "||", "{", "}", ";", "_", ".", "forEach", "(", "properties", ",", "function", "(", "property", ",", "name", ")", "{", "this", ".", "initProperty", "(", "name", ",", "property", ")", ";", "}", ",", "this", ")", ";", "}" ]

[ "Declare", "the", "values", "of", "a", "hash", "of", "properties" ]

[ "function", "(", "name", ",", "value", ")", "{", "var", "prop", "=", "this", ".", "getProperty", "(", "name", ")", ";", "var", "Constructor", ";", "if", "(", "!", "prop", ")", "{", "Constructor", "=", "this", ".", "getConstructor", "(", "name", ",", "value", ")", ";", "prop", "=", "new", "Constructor", "(", ")", ";", "prop", "=", "this", ".", "setProperty", "(", "name", ",", "prop", ")", ";", "}", "if", "(", "typeof", "value", "!==", "'undefined'", ")", "{", "prop", ".", "set", "(", "value", ")", ";", "}", "return", "prop", ";", "}" ]

[ "Declare", "the", "value", "of", "a", "single", "property" ]

[ "function", "(", "name", ")", "{", "var", "args", "=", "arguments", ";", "var", "len", "=", "args", ".", "length", ";", "if", "(", "len", "===", "0", ")", "{", "return", "this", ".", "getMap", "(", ")", ";", "}", "else", "if", "(", "len", "===", "1", ")", "{", "return", "this", ".", "getValue", "(", "name", ")", ";", "}", "else", "{", "return", "this", ".", "getValues", ".", "apply", "(", "this", ",", "args", ")", ";", "}", "}" ]

[ "Get", "the", "values", "of", "one", "or", "more", "properties" ]

[ "function", "(", ")", "{", "var", "map", "=", "this", ".", "properties", ";", "var", "pairs", "=", "_", ".", "map", "(", "map", ",", "function", "(", "prop", ",", "name", ")", "{", "return", "[", "name", ",", "prop", ".", "get", "(", ")", "]", ";", "}", ")", ";", "var", "result", "=", "_", ".", "object", "(", "pairs", ")", ";", "return", "result", ";", "}" ]

[ "Get", "the", "values", "of", "all", "properties" ]

[ "function", "(", ")", "{", "var", "result", "=", "[", "]", ";", "var", "args", "=", "arguments", ";", "var", "l", "=", "args", ".", "length", ";", "var", "name", ",", "value", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "l", ";", "i", "++", ")", "{", "name", "=", "args", "[", "i", "]", ";", "value", "=", "this", ".", "getValue", "(", "name", ")", ";", "result", ".", "push", "(", "value", ")", ";", "}", "return", "result", ";", "}" ]

[ "Get", "the", "value", "of", "multiple", "properties" ]

[ "function", "(", "name", ",", "newValue", ")", "{", "if", "(", "arguments", ".", "length", ">", "1", ")", "{", "this", ".", "setValue", "(", "name", ",", "newValue", ")", ";", "}", "else", "{", "var", "attrs", "=", "name", ";", "this", ".", "setMap", "(", "attrs", ")", ";", "}", "}" ]

[ "Set", "the", "value", "of", "one", "or", "more", "properties" ]

[ "function", "(", "attrs", ")", "{", "attrs", "=", "attrs", "||", "{", "}", ";", "_", ".", "forEach", "(", "attrs", ",", "function", "(", "val", ",", "name", ")", "{", "this", ".", "setValue", "(", "name", ",", "val", ")", ";", "}", ",", "this", ")", ";", "}" ]

[ "Set", "values", "of", "properties", "using", "an", "object" ]

[ "function", "(", "name", ",", "newValue", ")", "{", "var", "property", "=", "this", ".", "getProperty", "(", "name", ")", ";", "if", "(", "!", "property", ")", "{", "this", ".", "initProperty", "(", "name", ",", "newValue", ")", ";", "}", "else", "{", "property", ".", "set", "(", "newValue", ")", ";", "}", "}" ]

[ "Set", "the", "value", "of", "a", "single", "property" ]

[ "function", "(", "name", ",", "prop", ")", "{", "this", ".", "unsetProperty", "(", "name", ")", ";", "this", ".", "properties", "[", "name", "]", "=", "prop", ";", "this", ".", "listenTo", "(", "prop", ",", "EVENT_CHANGE", ",", "this", ".", "change", ")", ";", "return", "prop", ";", "}" ]

[ "Set", "a", "single", "property", "to", "a", "new", "value" ]

[ "function", "(", "name", ")", "{", "var", "prop", "=", "this", ".", "properties", "[", "name", "]", ";", "if", "(", "prop", ")", "{", "this", ".", "stopListening", "(", "prop", ",", "EVENT_CHANGE", ",", "this", ".", "change", ")", ";", "delete", "this", ".", "properties", "[", "name", "]", ";", "return", "prop", ";", "}", "return", "null", ";", "}" ]

[ "Remove", "a", "single", "property", "from", "the", "map" ]

[ "function", "(", "/* items... */", ")", "{", "var", "items", "=", "slice", "(", "arguments", ")", ";", "var", "item", ";", "for", "(", "var", "i", "=", "0", ",", "l", "=", "items", ".", "length", ";", "i", "<", "l", ";", "i", "++", ")", "{", "item", "=", "items", "[", "i", "]", ";", "$Array", ".", "push", ".", "call", "(", "this", ",", "item", ")", ";", "this", ".", "trigger", "(", "EVENT_ADD", ",", "item", ",", "this", ".", "length", ")", ";", "}", "return", "this", ".", "length", ";", "}" ]

[ "Push", "new", "items", "to", "the", "top", "of", "the", "stack" ]

[ "function", "(", "start", ",", "length", ")", "{", "var", "removed", ",", "item", ";", "if", "(", "arguments", ".", "length", "<", "1", ")", "{", "start", "=", "0", ";", "}", "if", "(", "arguments", ".", "length", "<", "2", ")", "{", "length", "=", "this", ".", "length", "-", "start", ";", "}", "removed", "=", "[", "]", ";", "while", "(", "start", "<", "this", ".", "length", "&&", "length", "--", ">", "0", ")", "{", "item", "=", "this", "[", "start", "]", ";", "$Array", ".", "splice", ".", "call", "(", "this", ",", "start", ",", "1", ")", ";", "this", ".", "trigger", "(", "EVENT_REMOVE", ",", "item", ")", ";", "removed", ".", "push", "(", "item", ")", ";", "}", "return", "removed", ";", "}" ]

[ "Remove", "items", "from", "the", "array" ]

[ "function", "(", "start", "/*, items... */", ")", "{", "var", "items", "=", "slice", "(", "arguments", ",", "1", ")", ";", "var", "item", ",", "index", ";", "for", "(", "var", "i", "=", "0", ",", "l", "=", "items", ".", "length", ";", "i", "<", "l", ";", "i", "++", ")", "{", "item", "=", "items", "[", "i", "]", ";", "index", "=", "start", "+", "i", ";", "$Array", ".", "splice", ".", "call", "(", "this", ",", "index", ",", "0", ",", "item", ")", ";", "this", ".", "trigger", "(", "EVENT_ADD", ",", "item", ",", "index", ")", ";", "}", "return", "this", ".", "length", ";", "}" ]

[ "Insert", "items", "into", "the", "array" ]

[ "function", "(", "items", ")", "{", "var", "args", "=", "slice", "(", "items", ")", ";", "args", ".", "unshift", "(", "0", ")", ";", "this", ".", "empty", "(", ")", ";", "this", ".", "insert", ".", "apply", "(", "this", ",", "args", ")", ";", "return", "this", ".", "length", ";", "}" ]

[ "Set", "the", "contents", "of", "this", "array", ".", "Empties", "it", "first", "." ]

[ "function", "(", "index", ")", "{", "if", "(", "arguments", ".", "length", "<", "1", ")", "{", "return", "this", ";", "}", "if", "(", "index", "<", "0", ")", "{", "index", "=", "this", ".", "length", "+", "index", ";", "}", "if", "(", "hasProperty", "(", "this", ",", "index", ")", ")", "{", "return", "this", "[", "index", "]", ";", "}", "return", "null", ";", "}" ]

[ "Get", "the", "item", "at", "a", "given", "index", ".", "Can", "be", "negative", ".", "If", "no", "index", "is", "given", "a", "reference", "to", "the", "array", "will", "be", "returned", "." ]

[ "function", "Collection", "(", "items", ")", "{", "this", ".", "items", "=", "new", "ok", ".", "Items", "(", ")", ";", "this", ".", "start", "(", ")", ";", "if", "(", "items", ")", "{", "this", ".", "add", "(", "items", ")", ";", "}", "this", ".", "init", "(", ")", ";", "}" ]

[ "Initialize", "with", "items" ]

[ "function", "(", ")", "{", "this", ".", "stop", "(", ")", ";", "this", ".", "listenTo", "(", "this", ".", "items", ",", "EVENT_ADD", ",", "this", ".", "triggerAdd", ")", ";", "this", ".", "listenTo", "(", "this", ".", "items", ",", "EVENT_REMOVE", ",", "this", ".", "triggerRemove", ")", ";", "this", ".", "listenTo", "(", "this", ".", "items", ",", "EVENT_SORT", ",", "this", ".", "triggerSort", ")", ";", "this", ".", "listenTo", "(", "this", ".", "items", ",", "EVENT_ADD", ",", "this", ".", "updateLength", ")", ";", "this", ".", "listenTo", "(", "this", ".", "items", ",", "EVENT_REMOVE", ",", "this", ".", "updateLength", ")", ";", "this", ".", "listenTo", "(", "this", ".", "items", ",", "EVENT_ADD", ",", "this", ".", "watchItem", ")", ";", "this", ".", "listenTo", "(", "this", ".", "items", ",", "EVENT_REMOVE", ",", "this", ".", "unwatchItem", ")", ";", "}" ]

[ "Begin", "listening", "to", "changes", "on", "the", "internal", "items", "storage", "array" ]

[ "function", "(", ")", "{", "var", "items", "=", "_", ".", "flatten", "(", "arguments", ")", ";", "for", "(", "var", "i", "=", "0", ",", "l", "=", "items", ".", "length", ";", "i", "<", "l", ";", "i", "++", ")", "{", "this", ".", "addItem", "(", "items", "[", "i", "]", ",", "this", ".", "items", ".", "length", ")", ";", "}", "}" ]

[ "Add", "one", "or", "more", "items" ]

[ "function", "(", "item", "/*, index*/", ")", "{", "var", "old", "=", "item", ";", "var", "Constructor", ";", "if", "(", "!", "(", "item", "instanceof", "ok", ".", "Base", ")", ")", "{", "Constructor", "=", "this", ".", "getConstructor", "(", "item", ")", ";", "item", "=", "new", "Constructor", "(", "item", ")", ";", "}", "var", "identified", "=", "this", ".", "identify", "(", "item", ")", ";", "if", "(", "identified", ")", "{", "identified", ".", "set", "(", "old", ")", ";", "}", "else", "{", "var", "index", "=", "this", ".", "findInsertIndex", "(", "item", ")", ";", "this", ".", "items", ".", "insert", "(", "index", "+", "1", ",", "item", ")", ";", "}", "}" ]

[ "Add", "a", "single", "item", "to", "this", "collection" ]

[ "function", "(", "item", ")", "{", "var", "index", "=", "-", "1", ";", "this", ".", "items", ".", "forEach", "(", "function", "(", "comparedTo", ",", "newIndex", ")", "{", "if", "(", "this", ".", "comparator", "(", "comparedTo", ",", "item", ")", "<=", "0", ")", "{", "index", "=", "newIndex", ";", "return", "false", ";", "}", "}", ",", "this", ")", ";", "return", "index", ";", "}" ]

[ "Determine", "where", "a", "newly", "inserted", "item", "would", "fit", "in", "this", "collection", ".", "Find", "the", "index", "of", "the", "item", "to", "insert", "after", "or", "-", "1", "to", "insert", "at", "the", "first", "index", "." ]

[ "function", "(", "item", ")", "{", "var", "items", "=", "this", ".", "items", ";", "var", "removed", "=", "0", ";", "for", "(", "var", "i", "=", "0", ",", "l", "=", "items", ".", "length", ";", "i", "<", "l", ";", "i", "++", ")", "{", "if", "(", "items", "[", "i", "]", "===", "item", ")", "{", "items", ".", "splice", "(", "i", ",", "1", ")", ";", "i", "--", ";", "removed", "++", ";", "}", "}", "return", "removed", ";", "}" ]

[ "Remove", "a", "specific", "item", "from", "the", "collection" ]

[ "function", "(", ")", "{", "var", "message", "=", "this", ".", "message", ";", "var", "name", "=", "this", ".", "name", ";", "var", "url", "=", "this", ".", "url", ";", "var", "result", "=", "name", ";", "if", "(", "message", ")", "{", "result", "+=", "': '", "+", "message", ";", "}", "if", "(", "url", ")", "{", "result", "+=", "' ('", "+", "url", "+", "')'", ";", "}", "return", "result", ";", "}" ]

[ "Display", "the", "contents", "of", "this", "error", ".", "Always", "shows", "the", "name", ".", "If", "the", "message", "exists", "it", "is", "also", "displayed", ".", "A", "URL", "to", "for", "example", "help", "documentation", "can", "be", "displayed", "as", "well", "." ]

[ "function", "(", "err", ",", "files", ")", "{", "if", "(", "err", ")", "{", "grunt", ".", "fail", ".", "fatal", "(", "err", ")", ";", "}", "files", ".", "forEach", "(", "function", "(", "file", ")", "{", "var", "pathName", "=", "path", ".", "join", "(", "workspacePath", ",", "file", ")", ";", "if", "(", "fs", ".", "statSync", "(", "pathName", ")", ".", "isDirectory", "(", ")", ")", "{", "if", "(", "file", "===", "activeWebpackage", "&&", "choices", ".", "length", ">", "0", ")", "{", "choices", ".", "splice", "(", "0", ",", "0", ",", "file", ")", ";", "}", "else", "{", "choices", ".", "push", "(", "file", ")", ";", "}", "}", "}", ")", ";", "// get list of webpackages to upload from config", "var", "uploadWebpackages", "=", "grunt", ".", "config", ".", "get", "(", "'workspaceConfig.uploadWebpackages'", ")", ";", "var", "i", "=", "0", ";", "if", "(", "uploadWebpackages", "&&", "uploadWebpackages", ".", "length", ")", "{", "// create upload list from config", "grunt", ".", "log", ".", "writeln", "(", "'Webpackages to upload:'", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "uploadWebpackages", ".", "length", ";", "i", "++", ")", "{", "if", "(", "choices", ".", "indexOf", "(", "uploadWebpackages", "[", "i", "]", ")", ">=", "0", ")", "{", "webpackages", ".", "push", "(", "uploadWebpackages", "[", "i", "]", ")", ";", "grunt", ".", "log", ".", "writeln", "(", "(", "i", "+", "1", ")", "+", "') '", "+", "uploadWebpackages", "[", "i", "]", ")", ";", "}", "}", "startUploads", "(", ")", ";", "}", "else", "{", "// get user decision", "choices", ".", "push", "(", "'CANCEL'", ")", ";", "grunt", ".", "log", ".", "writeln", "(", "'Please select all webpackages to upload '", "+", "'or to CANCEL: '", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "choices", ".", "length", ";", "i", "++", ")", "{", "grunt", ".", "log", ".", "writeln", "(", "(", "i", "+", "1", ")", "+", "') '", "+", "choices", "[", "i", "]", ")", ";", "}", "var", "options", "=", "{", "questions", ":", "[", "{", "name", ":", "'selectedWebpackages'", ",", "type", ":", "'input'", ",", "message", ":", "'Answer:'", "}", "]", "}", ";", "inquirer", ".", "prompt", "(", "options", ".", "questions", ")", ".", "then", "(", "webpackagesSelected", ")", ";", "}", "}" ]

[ "get", "all", "webpackages" ]

[ "function", "EmitEvent", "(", "props", ")", "{", "const", "event", "=", "this", ";", "if", "(", "!", "(", "event", "instanceof", "EmitEvent", ")", ")", "{", "return", "new", "EmitEvent", "(", "props", ")", ";", "}", "if", "(", "props", "==", "undefined", ")", "{", "props", "=", "''", ";", "}", "if", "(", "typeof", "props", "==", "'string'", ")", "{", "props", "=", "{", "type", ":", "props", "}", ";", "}", "_extend", "(", "event", ",", "props", ")", ";", "event", ".", "timeStamp", "=", "Date", ".", "now", "(", ")", ";", "}" ]

[ "Event", "constructor", "." ]

[ "function", "_extend", "(", "obj", ",", "from", ")", "{", "for", "(", "let", "key", "in", "from", ")", "if", "(", "hop", ".", "call", "(", "from", ",", "key", ")", ")", "{", "obj", "[", "key", "]", "=", "from", "[", "key", "]", ";", "}", "return", "obj", ";", "}" ]

[ "Copy", "properties", "to", "obj", "from", "from" ]

[ "function", "_append", "(", "array", ",", "args", "/*, ...*/", ")", "{", "var", "i", "=", "array", ".", "length", ",", "j", ",", "k", "=", "1", ",", "l", ",", "m", "=", "arguments", ".", "length", ",", "a", ";", "for", "(", ";", "k", "<", "m", ";", "++", "k", ")", "{", "a", "=", "arguments", "[", "k", "]", ";", "array", ".", "length", "=", "l", "=", "i", "+", "a", ".", "length", ";", "for", "(", "j", "=", "0", ";", "i", "<", "l", ";", "++", "i", ",", "++", "j", ")", "{", "array", "[", "i", "]", "=", "a", "[", "j", "]", ";", "}", "}", "return", "array", ";", "}" ]

[ "Append", "elements", "of", "args", "to", "array", "." ]

[ "function", "(", "data", ",", "circuitbreakerState", ",", "callback", ")", "{", "const", "responder", "=", "(", "circuitbreakerState", "===", "CB", ".", "OPEN", ")", "?", "config", ".", "bypass", ":", "config", ".", "handler", ";", "// call the handler using its expected paradigm", "const", "promise", "=", "responder", ".", "length", ">", "1", "?", "new", "Promise", "(", "function", "(", "resolve", ",", "reject", ")", "{", "responder", "(", "data", ",", "function", "(", "err", ",", "result", ")", "{", "if", "(", "err", ")", "return", "reject", "(", "err", ")", ";", "resolve", "(", "result", ")", ";", "}", ")", ";", "}", ")", ":", "Promise", ".", "resolve", "(", "responder", "(", "data", ")", ")", ";", "// provide an asynchronous response in the expected paradigm", "if", "(", "typeof", "callback", "!==", "'function'", ")", "return", "promise", ";", "promise", ".", "then", "(", "function", "(", "data", ")", "{", "callback", "(", "null", ",", "data", ")", ";", "}", ",", "function", "(", "err", ")", "{", "callback", "(", "err", ",", "null", ")", ";", "}", ")", ";", "}" ]

[ "define", "the", "response", "function", "wrapper" ]

[ "function", "serviceConfig", "(", ")", "{", "var", "arg", "=", "ld", ".", "values", "(", "arguments", ")", ",", "cfg", "=", "{", "}", ";", "// try to load file from global directory", "if", "(", "typeof", "arg", "[", "0", "]", "===", "'string'", ")", "{", "var", "path", "=", "arg", ".", "shift", "(", ")", ";", "try", "{", "cfg", "=", "require", "(", "'/etc/paukan/'", "+", "path", "+", "'.json'", ")", ";", "}", "catch", "(", "err", ")", "{", "// try to load file directly if global fails", "try", "{", "cfg", "=", "require", "(", "path", ")", ";", "}", "catch", "(", "err", ")", "{", "}", "}", "}", "// append default settings", "var", "localCfg", "=", "arg", ".", "shift", "(", ")", ";", "if", "(", "!", "ld", ".", "isPlainObject", "(", "localCfg", ")", ")", "{", "throw", "new", "Error", "(", "'at least local config should be specified'", ")", ";", "}", "ld", ".", "defaults", "(", "cfg", ",", "localCfg", ")", ";", "// load specific field from package.json", "var", "packageCfg", "=", "arg", ".", "shift", "(", ")", ";", "if", "(", "ld", ".", "isPlainObject", "(", "packageCfg", ")", ")", "{", "ld", ".", "defaults", "(", "cfg", ",", "ld", ".", "pick", "(", "packageCfg", ",", "[", "'version'", ",", "'description'", ",", "'homepage'", ",", "'author'", "]", ")", ")", ";", "}", "return", "cfg", ";", "}" ]

[ "Take", "configuration", "files", "and", "service", "specific", "info", "from", "package", ".", "json" ]

[ "function", "StreamConsole", "(", "cfg", ")", "{", "cfg", "=", "cfg", "||", "{", "}", ";", "this", ".", "color", "=", "cfg", ".", "color", "||", "true", ";", "this", ".", "timestamp", "=", "(", "typeof", "cfg", ".", "timestamp", "===", "'undefined'", ")", "?", "'HH:mm:ss '", ":", "cfg", ".", "timestamp", ";", "}" ]

[ "Stream", "to", "console", "for", "bunyan", "logger" ]

[ "function", "InfiniteScrollSetup", "(", "options", ")", "{", "options", "||", "(", "options", "=", "{", "}", ")", ";", "var", "self", "=", "this", ";", "var", "gap", "=", "(", "options", ".", "gap", "||", "20", ")", ";", "// defaults to 20", "self", ".", "events", "=", "self", ".", "events", "||", "{", "}", ";", "assign", "(", "self", ".", "events", ",", "{", "scroll", ":", "'infiniteScroll'", "}", ")", ";", "self", ".", "infiniteScroll", "=", "function", "(", ")", "{", "if", "(", "this", ".", "el", ".", "scrollHeight", "-", "this", ".", "el", ".", "scrollTop", "<=", "this", ".", "el", ".", "clientHeight", "+", "gap", ")", "{", "this", ".", "collection", ".", "fetchPage", "(", "options", ")", ";", "}", "}", ";", "}" ]

[ "Setup", "the", "closure", "function", "for", "the", "Infinite", "Scroll", "callback" ]

[ "function", "InfiniteScrollView", "(", "options", ")", "{", "options", "||", "(", "options", "=", "{", "}", ")", ";", "BaseView", ".", "call", "(", "this", ",", "options", ")", ";", "InfiniteScrollSetup", ".", "call", "(", "this", ",", "options", ")", ";", "}" ]

[ "Infinite", "Scroll", "View", "constructor" ]

[ "function", "hyperRepeat", "(", "store", ")", "{", "this", ".", "compile", "=", "compile", ";", "this", ".", "state", "=", "function", "(", "config", ",", "state", ")", "{", "var", "res", "=", "store", ".", "get", "(", "config", ".", "path", ",", "state", ")", ";", "if", "(", "!", "res", ".", "completed", ")", "return", "false", ";", "return", "state", ".", "set", "(", "config", ".", "source", ",", "res", ".", "value", ")", ";", "}", ";", "this", ".", "children", "=", "function", "(", "config", ",", "state", ",", "children", ")", "{", "var", "items", "=", "state", ".", "get", "(", "config", ".", "source", ")", ";", "var", "arr", "=", "[", "]", ";", "if", "(", "!", "items", ")", "return", "arr", ";", "var", "target", "=", "config", ".", "target", ";", "var", "i", ",", "c", ",", "child", ";", "var", "path", "=", "[", "'state'", ",", "target", "]", ";", "for", "(", "i", "=", "0", ";", "i", "<", "items", ".", "length", ";", "i", "++", ")", "{", "function", "update", "(", ")", "{", "return", "items", "[", "i", "]", "}", ";", "for", "(", "c", "=", "0", ";", "c", "<", "children", ".", "length", ";", "c", "++", ")", "{", "child", "=", "children", "[", "c", "]", ";", "if", "(", "!", "child", ")", "continue", ";", "// TODO set the key prop", "child", "=", "child", ".", "updateIn", "(", "path", ",", "update", ")", ";", "arr", ".", "push", "(", "child", ")", ";", "}", "}", "return", "arr", ";", "}", ";", "}" ]

[ "Initialize", "the", "hyper", "-", "repeat", "directive" ]

[ "function", "compile", "(", "input", ")", "{", "var", "res", "=", "input", ".", "match", "(", "REGEX", ")", ";", "if", "(", "!", "res", ")", "throw", "new", "Error", "(", "'Invalid expression: \"'", "+", "input", "+", "'\"'", ")", ";", "var", "range", "=", "res", "[", "3", "]", ";", "var", "parsedRange", ";", "if", "(", "range", ")", "{", "parsedRange", "=", "parser", "(", "range", ")", ";", "if", "(", "parsedRange", "===", "null", ")", "throw", "new", "Error", "(", "'Invalid range expression: \"'", "+", "range", "+", "'\" in \"'", "+", "input", "+", "'\"'", ")", ";", "}", "var", "path", "=", "res", "[", "2", "]", ";", "var", "source", "=", "path", ".", "split", "(", "'.'", ")", ";", "// TODO support ranges", "if", "(", "parsedRange", ")", "console", ".", "warn", "(", "'data-hyper-repeat ranges are not supported at this time'", ")", ";", "return", "{", "target", ":", "res", "[", "1", "]", ",", "path", ":", "path", ",", "source", ":", "source", "[", "source", ".", "length", "-", "1", "]", ",", "range", ":", "parsedRange", "}", ";", "}" ]

[ "Compile", "a", "hyper", "-", "repeat", "expression" ]

[ "function", "(", "file", ",", "type", ")", "{", "var", "promise", "=", "new", "Parse", ".", "Promise", "(", ")", ";", "if", "(", "typeof", "(", "FileReader", ")", "===", "\"undefined\"", ")", "{", "return", "Parse", ".", "Promise", ".", "error", "(", "new", "Parse", ".", "Error", "(", "Parse", ".", "Error", ".", "FILE_READ_ERROR", ",", "\"Attempted to use a FileReader on an unsupported browser.\"", ")", ")", ";", "}", "var", "reader", "=", "new", "FileReader", "(", ")", ";", "reader", ".", "onloadend", "=", "function", "(", ")", "{", "if", "(", "reader", ".", "readyState", "!==", "2", ")", "{", "promise", ".", "reject", "(", "new", "Parse", ".", "Error", "(", "Parse", ".", "Error", ".", "FILE_READ_ERROR", ",", "\"Error reading file.\"", ")", ")", ";", "return", ";", "}", "var", "dataURL", "=", "reader", ".", "result", ";", "var", "matches", "=", "/", "^data:([^;]*);base64,(.*)$", "/", ".", "exec", "(", "dataURL", ")", ";", "if", "(", "!", "matches", ")", "{", "promise", ".", "reject", "(", "new", "Parse", ".", "Error", "(", "Parse", ".", "ERROR", ".", "FILE_READ_ERROR", ",", "\"Unable to interpret data URL: \"", "+", "dataURL", ")", ")", ";", "return", ";", "}", "promise", ".", "resolve", "(", "matches", "[", "2", "]", ",", "type", "||", "matches", "[", "1", "]", ")", ";", "}", ";", "reader", ".", "readAsDataURL", "(", "file", ")", ";", "return", "promise", ";", "}" ]

[ "Reads", "a", "File", "using", "a", "FileReader", "." ]

[ "function", "(", "options", ")", "{", "options", "=", "options", "||", "{", "}", ";", "var", "self", "=", "this", ";", "if", "(", "!", "self", ".", "_previousSave", ")", "{", "self", ".", "_previousSave", "=", "self", ".", "_source", ".", "then", "(", "function", "(", "base64", ",", "type", ")", "{", "var", "data", "=", "{", "base64", ":", "base64", ",", "_ContentType", ":", "type", "}", ";", "return", "Parse", ".", "_request", "(", "{", "route", ":", "\"files\"", ",", "className", ":", "self", ".", "_name", ",", "method", ":", "'POST'", ",", "data", ":", "data", ",", "useMasterKey", ":", "options", ".", "useMasterKey", "}", ")", ";", "}", ")", ".", "then", "(", "function", "(", "response", ")", "{", "self", ".", "_name", "=", "response", ".", "name", ";", "self", ".", "_url", "=", "response", ".", "url", ";", "return", "self", ";", "}", ")", ";", "}", "return", "self", ".", "_previousSave", ".", "_thenRunCallbacks", "(", "options", ")", ";", "}" ]

[ "Saves", "the", "file", "to", "the", "Parse", "cloud", "." ]

[ "function", "(", "operation", ",", "parameter", ")", "{", "// TODO the reference to operation.api is not available", "if", "(", "operation", ".", "api", "&&", "operation", ".", "api", ".", "parameterMacro", ")", "{", "return", "operation", ".", "api", ".", "parameterMacro", "(", "operation", ",", "parameter", ")", ";", "}", "else", "{", "return", "parameter", ".", "defaultValue", ";", "}", "}" ]

[ "allows", "override", "of", "the", "default", "value", "based", "on", "the", "parameter", "being", "supplied" ]

[ "function", "(", "model", ",", "property", ")", "{", "// TODO the reference to model.api is not available", "if", "(", "model", ".", "api", "&&", "model", ".", "api", ".", "modelPropertyMacro", ")", "{", "return", "model", ".", "api", ".", "modelPropertyMacro", "(", "model", ",", "property", ")", ";", "}", "else", "{", "return", "property", ".", "default", ";", "}", "}" ]

[ "allows", "overriding", "the", "default", "value", "of", "an", "model", "property" ]

[ "function", "baseIsEqual", "(", "value", ",", "other", ",", "customizer", ",", "isLoose", ",", "stackA", ",", "stackB", ")", "{", "// Exit early for identical values.", "if", "(", "value", "===", "other", ")", "{", "// Treat `+0` vs. `-0` as not equal.", "return", "value", "!==", "0", "||", "(", "1", "/", "value", "==", "1", "/", "other", ")", ";", "}", "var", "valType", "=", "typeof", "value", ",", "othType", "=", "typeof", "other", ";", "// Exit early for unlike primitive values.", "if", "(", "(", "valType", "!=", "'function'", "&&", "valType", "!=", "'object'", "&&", "othType", "!=", "'function'", "&&", "othType", "!=", "'object'", ")", "||", "value", "==", "null", "||", "other", "==", "null", ")", "{", "// Return `false` unless both values are `NaN`.", "return", "value", "!==", "value", "&&", "other", "!==", "other", ";", "}", "return", "baseIsEqualDeep", "(", "value", ",", "other", ",", "baseIsEqual", ",", "customizer", ",", "isLoose", ",", "stackA", ",", "stackB", ")", ";", "}" ]

[ "The", "base", "implementation", "of", "_", ".", "isEqual", "without", "support", "for", "this", "binding", "customizer", "functions", "." ]

[ "function", "baseMatchesProperty", "(", "key", ",", "value", ")", "{", "if", "(", "isStrictComparable", "(", "value", ")", ")", "{", "return", "function", "(", "object", ")", "{", "return", "object", "!=", "null", "&&", "object", "[", "key", "]", "===", "value", "&&", "(", "typeof", "value", "!=", "'undefined'", "||", "(", "key", "in", "toObject", "(", "object", ")", ")", ")", ";", "}", ";", "}", "return", "function", "(", "object", ")", "{", "return", "object", "!=", "null", "&&", "baseIsEqual", "(", "value", ",", "object", "[", "key", "]", ",", "null", ",", "true", ")", ";", "}", ";", "}" ]

[ "The", "base", "implementation", "of", "_", ".", "matchesProperty", "which", "does", "not", "coerce", "key", "to", "a", "string", "." ]

[ "function", "createBaseEach", "(", "eachFunc", ",", "fromRight", ")", "{", "return", "function", "(", "collection", ",", "iteratee", ")", "{", "var", "length", "=", "collection", "?", "collection", ".", "length", ":", "0", ";", "if", "(", "!", "isLength", "(", "length", ")", ")", "{", "return", "eachFunc", "(", "collection", ",", "iteratee", ")", ";", "}", "var", "index", "=", "fromRight", "?", "length", ":", "-", "1", ",", "iterable", "=", "toObject", "(", "collection", ")", ";", "while", "(", "(", "fromRight", "?", "index", "--", ":", "++", "index", "<", "length", ")", ")", "{", "if", "(", "iteratee", "(", "iterable", "[", "index", "]", ",", "index", ",", "iterable", ")", "===", "false", ")", "{", "break", ";", "}", "}", "return", "collection", ";", "}", ";", "}" ]

[ "Creates", "a", "baseEach", "or", "baseEachRight", "function", "." ]

[ "function", "(", "config", ",", "callback", ",", "patsy", ")", "{", "patsy", "=", "typeof", "config", "===", "'function'", "&&", "typeof", "callback", "===", "'object'", "?", "callback", ":", "patsy", ";", "callback", "=", "typeof", "config", "===", "'function'", "?", "config", ":", "callback", ";", "config", "=", "typeof", "config", "===", "'function'", "?", "undefined", ":", "config", ";", "if", "(", "typeof", "config", "!==", "'undefined'", "&&", "typeof", "callback", "!==", "'undefined'", "&&", "typeof", "callback", "===", "'function'", ")", "{", "try", "{", "config", "=", "this", ".", "bake", "(", "config", ")", ";", "fs", ".", "writeFileSync", "(", "\"patsy.json\"", ",", "JSON", ".", "stringify", "(", "config", ",", "null", ",", "2", ")", ")", ";", "callback", "(", "patsy", ")", ";", "}", "catch", "(", "e", ")", "{", "console", ".", "log", "(", "'config.create'", ",", "e", ")", ";", "return", "false", ";", "}", "}", "else", "{", "patsy", ".", "config", ".", "generateDefaultConfiguration", "(", ")", ";", "callback", "(", "patsy", ")", ";", "}", "}" ]

[ "Function", "to", "create", "a", "config", "file", "with", "given", "configuration", "object" ]

[ "function", "(", "patsy", ",", "project_path", ")", "{", "if", "(", "opts", ".", "verbose", ")", "{", "util", ".", "print", "(", "'>>'", ".", "cyan", "+", "' Loading project configuration...'", ")", ";", "}", "if", "(", "typeof", "project_path", "===", "'undefined'", ")", "{", "if", "(", "opts", ".", "verbose", ")", "{", "patsy", ".", "utils", ".", "notice", "(", ")", ";", "patsy", ".", "utils", ".", "notice", "(", "'No project path set, declaring path to CWD: '", ".", "white", "+", "String", "(", "process", ".", "cwd", "(", ")", "+", "path", ".", "sep", ")", ".", "inverse", ".", "cyan", "+", "''", ")", ";", "}", "project_path", "=", "opts", ".", "project_path", "||", "process", ".", "cwd", "(", ")", "+", "path", ".", "sep", ";", "}", "else", "{", "if", "(", "opts", ".", "verbose", ")", "{", "patsy", ".", "utils", ".", "ok", "(", ")", ";", "}", "}", "var", "_path_to_config", "=", "project_path", "+", "'patsy.json'", ";", "if", "(", "opts", ".", "verbose", ")", "{", "util", ".", "print", "(", "'>>'", ".", "cyan", "+", "' Reading project configuration file: '", "+", "_path_to_config", ".", "inverse", ".", "cyan", "+", "'...\\n'", ")", ";", "}", "if", "(", "!", "fs", ".", "existsSync", "(", "_path_to_config", ")", ")", "{", "patsy", ".", "utils", ".", "notice", "(", ")", ";", "if", "(", "opts", ".", "verbose", ")", "{", "patsy", ".", "utils", ".", "notice", "(", "'Configuration file not found here, looking elsewhere: '", "+", "_path_to_config", ".", "inverse", ".", "cyan", "+", "'...\\n'", ")", ";", "}", "patsy", ".", "scripture", ".", "print", "(", "'[Patsy]'", ".", "yellow", "+", "': <stumbling forward>\\n'", ")", ";", "_path_to_config", "=", "this", ".", "searchForConfigFile", "(", "patsy", ")", ";", "}", "if", "(", "fs", ".", "existsSync", "(", "_path_to_config", ")", ")", "{", "if", "(", "opts", ".", "verbose", ")", "{", "patsy", ".", "utils", ".", "ok", "(", "'File found here: '", "+", "_path_to_config", ".", "inverse", ".", "cyan", ")", ";", "util", ".", "print", "(", "'>>'", ".", "cyan", "+", "' Loading project configuration...'", ")", ";", "}", "// Read file synchroneously, parse contents as JSON and return config", "var", "_config_json", ";", "try", "{", "_config_json", "=", "require", "(", "_path_to_config", ")", ";", "}", "catch", "(", "e", ")", "{", "patsy", ".", "utils", ".", "fail", "(", ")", ";", "}", "if", "(", "this", ".", "validate", "(", "_config_json", ")", ")", "{", "if", "(", "opts", ".", "verbose", ")", "{", "patsy", ".", "utils", ".", "ok", "(", ")", ";", "}", "}", "else", "{", "if", "(", "opts", ".", "verbose", ")", "{", "patsy", ".", "utils", ".", "fail", "(", "'Configuration file is not valid!'", ")", ";", "}", "patsy", ".", "scripture", ".", "print", "(", "'[Patsy]'", ".", "yellow", "+", "': Sire! The configuration script is not valid! We have to turn around!\\n'", ")", ";", "process", ".", "exit", "(", "1", ")", ";", "}", "_config_json", ".", "project", ".", "environment", ".", "rel_path", "=", "path", ".", "relative", "(", "_config_json", ".", "appPath", "||", "''", ",", "_config_json", ".", "project", ".", "environment", ".", "abs_path", ")", "+", "path", ".", "sep", ";", "return", "_config_json", ";", "}", "else", "{", "if", "(", "opts", ".", "verbose", ")", "{", "util", ".", "print", "(", "'>> FAIL'", ".", "red", "+", "': Loading project configuration: Could not find configuration file!'", ".", "white", "+", "'\\n'", ")", ";", "}", "return", "undefined", ";", "}", "}" ]

[ "Function", "to", "load", "patsy", "configuration" ]

[ "function", "(", ")", "{", "var", "defaultConfig", "=", "JSON", ".", "parse", "(", "fs", ".", "readFileSync", "(", "__dirname", "+", "'/../patsy.default.json'", ",", "'utf8'", ")", ")", ";", "var", "projectSpecificSettings", "=", "{", "\"project\"", ":", "{", "\"details\"", ":", "{", "\"name\"", ":", "path", ".", "basename", "(", "process", ".", "cwd", "(", ")", ")", "}", ",", "\"environment\"", ":", "{", "\"root\"", ":", "path", ".", "basename", "(", "process", ".", "cwd", "(", ")", ")", ",", "\"abs_path\"", ":", "process", ".", "cwd", "(", ")", "+", "path", ".", "sep", "}", "}", "}", ";", "var", "almostDefaultConfig", "=", "require", "(", "'./utils'", ")", ".", "deepExtend", "(", "defaultConfig", ",", "projectSpecificSettings", ")", ";", "almostDefaultConfig", "=", "JSON", ".", "stringify", "(", "almostDefaultConfig", ",", "null", ",", "2", ")", ";", "fs", ".", "writeFileSync", "(", "\"patsy.json\"", ",", "almostDefaultConfig", ")", ";", "}" ]

[ "Generates", "a", "default", "patsy", ".", "json", "configuration", "file", "in", "the", "root", "of", "the", "current", "project", "." ]

[ "function", "dispatch", "(", "request", ",", "response", ")", "{", "return", "Promise", ".", "resolve", "(", ")", ".", "then", "(", "resolveRouters", ".", "bind", "(", "this", ",", "request", ")", ")", ".", "then", "(", "callAction", ".", "bind", "(", "this", ",", "request", ",", "response", ")", ")", ";", "}" ]

[ "Dispatch", "request", "in", "good", "action", "using", "routers" ]

[ "function", "resolveRouters", "(", "request", ")", "{", "for", "(", "var", "i", "=", "0", ",", "l", "=", "routers", ".", "length", ";", "i", "<", "l", ";", "i", "++", ")", "{", "var", "callback", "=", "routers", "[", "i", "]", ".", "resolve", "(", "request", ")", ";", "if", "(", "null", "!=", "callback", ")", "{", "return", "Promise", ".", "resolve", "(", "callback", ")", ";", "}", "}", "return", "Promise", ".", "reject", "(", "'Route not defined for \"'", "+", "request", ".", "url", "+", "'\"'", ")", ";", "}" ]

[ "Resolve", "uri", "using", "routers" ]

[ "function", "callAction", "(", "request", ",", "response", ",", "callback", ")", "{", "if", "(", "typeof", "callback", "==", "'function'", ")", "{", "return", "Promive", ".", "resolve", "(", ")", ".", "then", "(", "callback", ".", "bind", "(", "null", ",", "request", ",", "response", ")", ")", ";", "}", "try", "{", "var", "Action", "=", "require", "(", "ACTION_PATH", "+", "'/'", "+", "callback", ".", "action", "+", "'.js'", ")", ";", "}", "catch", "(", "error", ")", "{", "if", "(", "error", ".", "message", "==", "'Cannot find module \\''", "+", "ACTION_PATH", "+", "'/'", "+", "callback", ".", "action", "+", "'.js\\''", ")", "{", "return", "Promise", ".", "reject", "(", "'Action '", "+", "callback", ".", "action", "+", "' does not exist.'", ")", ".", "catch", "(", "this", ".", "onPageNotFound", ".", "bind", "(", "this", ",", "request", ",", "response", ")", ")", ";", "}", "return", "Promise", ".", "reject", "(", "error", ")", ".", "catch", "(", "this", ".", "onError", ".", "bind", "(", "this", ",", "request", ",", "response", ")", ")", ";", "}", "var", "instance", "=", "new", "Action", "(", "request", ",", "response", ")", ";", "// Test if method exists", "if", "(", "!", "instance", "[", "callback", ".", "method", "]", ")", "{", "return", "Promise", ".", "reject", "(", "new", "Error", "(", "'Method \"'", "+", "callback", ".", "method", "+", "'\" not found in action \"'", "+", "callback", ".", "action", "+", "'\"'", ")", ")", ";", "}", "var", "promise", "=", "Promise", ".", "resolve", "(", ")", ";", "if", "(", "instance", ".", "init", "&&", "'function'", "==", "typeof", "instance", ".", "init", ")", "{", "promise", "=", "promise", ".", "then", "(", "function", "(", ")", "{", "return", "instance", ".", "init", "(", ")", ";", "}", ")", ";", "}", "promise", "=", "promise", ".", "then", "(", "function", "(", ")", "{", "return", "instance", "[", "callback", ".", "method", "]", ".", "apply", "(", "instance", ",", "callback", ".", "arguments", ")", ";", "}", ")", ";", "if", "(", "instance", ".", "onError", "&&", "'function'", "==", "typeof", "instance", ".", "onError", ")", "{", "promise", "=", "promise", ".", "catch", "(", "function", "(", "error", ")", "{", "return", "instance", ".", "onError", ".", "call", "(", "instance", ",", "error", ")", "}", ")", ";", "}", "promise", "=", "promise", ".", "catch", "(", "this", ".", "onError", ".", "bind", "(", "this", ",", "request", ",", "response", ")", ")", ";", "return", "promise", ";", "}" ]

[ "Call", "action", "and", "method", "form", "resolved", "route" ]

[ "function", "postDecode", "(", "request", ")", "{", "return", "new", "Promise", "(", "function", "promisePostDecode", "(", "resolve", ")", "{", "var", "postData", "=", "''", ";", "if", "(", "request", ".", "method", "===", "'POST'", ")", "{", "request", ".", "on", "(", "'data'", ",", "function", "(", "chunk", ")", "{", "// append the current chunk of data to the fullBody variable", "postData", "+=", "chunk", ".", "toString", "(", ")", ";", "}", ")", ";", "request", ".", "on", "(", "'end'", ",", "function", "(", ")", "{", "request", ".", "body", "=", "qs", ".", "parse", "(", "postData", ")", ";", "resolve", "(", ")", ";", "}", ")", ";", "}", "else", "{", "resolve", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Decode", "post", "data", "and", "add", "input", "into", "request" ]

[ "function", "runHooks", "(", "request", ",", "response", ",", "hooks", ")", "{", "var", "promise", "=", "Promise", ".", "resolve", "(", ")", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "hooks", ".", "length", ";", "i", "++", ")", "{", "promise", "=", "promise", ".", "then", "(", "hooks", "[", "i", "]", ".", "bind", "(", "this", ",", "request", ",", "response", ")", ")", ";", "}", "return", "promise", ";", "}" ]

[ "Run", "given", "hooks" ]

[ "function", "pad", "(", "text", ",", "width", ")", "{", "var", "space", "=", "(", "width", "-", "text", ".", "length", ")", "+", "5", ";", "return", "text", "+", "Array", "(", "space", ")", ".", "join", "(", "\" \"", ")", ";", "}" ]

[ "Appends", "padding", "space", "to", "some", "text", "." ]

[ "function", "generate", "(", ")", "{", "var", "rnum", "=", "Math", ".", "floor", "(", "Math", ".", "random", "(", ")", "*", "10", ")", ";", "var", "mood", "=", "rnum", "<=", "8", "?", "\"good\"", ":", "\"bad\"", ";", "var", "sentences", "=", "[", "_sentence_mgr2", ".", "default", ".", "feeling", "(", "mood", ")", ",", "_word_library2", ".", "default", ".", "warning", "(", ")", ",", "nu", ".", "chooseFrom", "(", "[", "_sentence_mgr2", ".", "default", ".", "relationship", "(", "mood", ")", ",", "_sentence_mgr2", ".", "default", ".", "encounter", "(", "mood", ")", "]", ")", "]", ";", "// randomize (shuffle) the array", "sentences", "=", "nu", ".", "shuffle", "(", "sentences", ")", ";", "// Select 2 or 3 sentences, to add to the random feel", "var", "num_s", "=", "Math", ".", "floor", "(", "Math", ".", "random", "(", ")", "*", "2", ")", "+", "2", ";", "sentences", "=", "sentences", ".", "slice", "(", "0", ",", "num_s", ")", ";", "sentences", "=", "sentences", ".", "join", "(", "\" \"", ")", ";", "sentences", "+=", "\" \"", "+", "_sentence_mgr2", ".", "default", ".", "datePredict", "(", ")", ";", "debug", "(", "sentences", ")", ";", "return", "sentences", ";", "}" ]

[ "Generate", "a", "three", "to", "four", "sentence", "horoscope", "." ]

[ "function", "FileListController", "(", "$scope", ",", "mediator", ",", "$stateParams", ",", "$window", ",", "userClient", ",", "fileMediatorService", ",", "$timeout", ",", "mobileCamera", ",", "desktopCamera", ",", "FILE_CONFIG", ")", "{", "var", "self", "=", "this", ";", "self", ".", "files", "=", "null", ";", "var", "_files", ";", "self", ".", "uploadEnabled", "=", "FILE_CONFIG", ".", "uploadEnabled", ";", "userClient", ".", "getProfile", "(", ")", ".", "then", "(", "function", "(", "profileData", ")", "{", "var", "userFilter", ";", "if", "(", "FILE_CONFIG", ".", "userMode", ")", "{", "userFilter", "=", "profileData", ".", "id", ";", "}", "function", "refreshFiles", "(", ")", "{", "fileMediatorService", ".", "listFiles", "(", "userFilter", ")", ".", "then", "(", "function", "(", "files", ")", "{", "$timeout", "(", "function", "(", ")", "{", "_files", "=", "files", ";", "self", ".", "files", "=", "files", ";", "}", ")", ";", "}", ")", ";", "}", "refreshFiles", "(", ")", ";", "fileMediatorService", ".", "subscribeToFileCRUDDoneTopics", "(", "$scope", ",", "refreshFiles", ")", ";", "self", ".", "selectFile", "=", "function", "(", "event", ",", "file", ")", "{", "self", ".", "selectedFileId", "=", "file", ".", "id", ";", "mediator", ".", "publish", "(", "fileMediatorService", ".", "fileUITopics", ".", "getTopic", "(", "CONSTANTS", ".", "TOPICS", ".", "SELECTED", ")", ",", "file", ")", ";", "}", ";", "//TODO: Move to service", "self", ".", "applyFilter", "=", "function", "(", "term", ")", "{", "term", "=", "term", ".", "toLowerCase", "(", ")", ";", "self", ".", "files", "=", "_files", ".", "filter", "(", "function", "(", "file", ")", "{", "return", "String", "(", "file", ".", "name", ")", ".", "toLowerCase", "(", ")", ".", "indexOf", "(", "term", ")", "!==", "-", "1", "||", "String", "(", "file", ".", "id", ")", ".", "indexOf", "(", "term", ")", "!==", "-", "1", ";", "}", ")", ";", "}", ";", "$scope", ".", "$parent", ".", "selected", "=", "{", "id", ":", "null", "}", ";", "var", "captureThenUpload", "=", "function", "(", ")", "{", "if", "(", "$window", ".", "cordova", ")", "{", "return", "mobileCamera", ".", "capture", "(", ")", ".", "then", "(", "function", "(", "capture", ")", "{", "var", "fileData", "=", "{", "userId", ":", "profileData", ".", "id", ",", "fileURI", ":", "capture", ".", "fileURI", ",", "options", ":", "{", "fileName", ":", "capture", ".", "fileName", "}", "}", ";", "fileMediatorService", ".", "createFile", "(", "fileData", ")", ";", "}", ")", ";", "}", "else", "{", "return", "desktopCamera", ".", "capture", "(", ")", ".", "then", "(", "function", "(", "dataUrl", ")", "{", "return", "fileMediatorService", ".", "createFile", "(", "{", "userId", ":", "profileData", ".", "id", ",", "dataUrl", ":", "dataUrl", "}", ")", ";", "}", ")", ";", "}", "}", ";", "self", ".", "capturePhoto", "=", "function", "(", ")", "{", "captureThenUpload", "(", ")", ".", "then", "(", "function", "(", ")", "{", "}", ",", "function", "(", "error", ")", "{", "console", ".", "error", "(", "error", ")", ";", "}", ")", ";", "}", ";", "}", ")", ";", "}" ]

[ "Controller", "for", "listing", "Files" ]

[ "function", "optionResult", "(", "options", ",", "option", ")", "{", "var", "result", "=", "options", "[", "option", "]", ";", "// If the returned value is a function, call it with the dest option parameter", "if", "(", "_", ".", "isFunction", "(", "result", ")", ")", "{", "result", "=", "result", "(", "options", ".", "dest", ")", ";", "}", "return", "result", ";", "}" ]

[ "Get", "option", "result", "from", "options" ]

[ "function", "build_shell", "(", "fields", ")", "{", "var", "$fields", "=", "Array", ".", "isArray", "(", "fields", ")", "?", "normalizeFields", "(", "fields", ")", ":", "[", "'ProcessId'", ",", "'Name'", ",", "'Path'", ",", "'ParentProcessId'", ",", "'Priority'", "]", ";", "var", "args", "=", "command", ".", "shell_arg", ".", "split", "(", "' '", ")", ";", "args", ".", "push", "(", "`", "${", "command", ".", "ps", "}", "${", "command", ".", "select", "}", "${", "$fields", ".", "join", "(", "','", ")", "}", "${", "command", ".", "convert", "}", "`", ")", ";", "return", "shell", "(", "command", ".", "shell", ",", "args", ")", ";", "}" ]

[ "Build", "shell", "command" ]

[ "function", "(", "options", ")", "{", "options", "=", "extend", "(", "{", "src", ":", "''", ",", "output", ":", "''", ",", "is3d", ":", "false", ",", "failOnWarn", ":", "false", ",", "overwrite", ":", "false", ",", "reporter", ":", "'default'", "}", ",", "options", ")", ";", "if", "(", "!", "options", ".", "src", "||", "!", "options", ".", "output", ")", "{", "throw", "new", "Error", "(", "'Must specify source file and output directory'", ")", ";", "}", "var", "reporterConstructor", ";", "if", "(", "options", ".", "reporter", "===", "'default'", ")", "{", "reporterConstructor", "=", "require", "(", "'./reporter.js'", ")", ".", "Reporter", ";", "}", "else", "{", "reporterConstructor", "=", "require", "(", "'./reporters/'", "+", "options", ".", "reporter", "+", "'.js'", ")", ";", "}", "if", "(", "reporterConstructor", "===", "undefined", ")", "{", "throw", "new", "Error", "(", "'Invalid reporter given'", ")", ";", "}", "this", ".", "reporter", "=", "new", "reporterConstructor", "(", "options", ".", "failOnWarn", ")", ";", "this", ".", "sourceCode", "=", "fs", ".", "readFileSync", "(", "options", ".", "src", ",", "'utf-8'", ")", ";", "this", ".", "psykickVersion", "=", "(", "options", ".", "is3d", ")", "?", "'3d'", ":", "'2d'", ";", "this", ".", "sourcePath", "=", "options", ".", "src", ";", "this", ".", "outputPath", "=", "options", ".", "output", ";", "this", ".", "overwrite", "=", "options", ".", "overwrite", ";", "this", ".", "ast", "=", "null", ";", "this", ".", "compiler", "=", "null", ";", "this", ".", "writer", "=", "null", ";", "}" ]

[ "Exposes", "Clairvoyant", "as", "a", "module", "to", "use", "programatically" ]

[ "function", "handleRejects", "(", "PromiseFunc", ",", "Obj", ",", "Err", ",", "Options", ")", "{", "var", "rejectOpts", "=", "Options", ".", "Reject", "||", "rejectConfig", ";", "switch", "(", "rejectOpts", ".", "rejectBehaviour", ")", "{", "case", "\"reject\"", ":", "// Every time a promise finishes start the first one from the currentPromiseArrays[typeKey]Array that hasnt been started yet; ", "if", "(", "Obj", ".", "isRunning", ")", "return", "Obj", ".", "rejectResult", "(", "Err", ")", ";", "break", ";", "case", "\"resolve\"", ":", "if", "(", "Obj", ".", "isRunning", ")", "return", "Obj", ".", "resolveResult", "(", "rejectOpts", ".", "returnOnReject", ")", ";", "break", ";", "case", "\"retry\"", ":", "if", "(", "Obj", ".", "isRunning", ")", "return", "retryPromiseRejected", "(", "PromiseFunc", ",", "Obj", ",", "Options", ",", "Err", ")", ";", "break", ";", "case", "\"none\"", ":", "break", ";", "}", "}" ]

[ "Handle", "rejects", "will", "determine", "how", "a", "promise", "is", "beeing", "handled", "after", "it", "the", "PromiseFunc", "has", "been", "rejected" ]

[ "function", "getHandler", "(", "method", ")", "{", "var", "taxonomy", "=", "{", "create", ":", "store", ".", "set", ",", "read", ":", "store", ".", "get", ",", "update", ":", "store", ".", "set", ",", "'delete'", ":", "store", ".", "remove", ",", "patch", ":", "store", ".", "set", ",", "findAll", ":", "store", ".", "all", ",", "findById", ":", "store", ".", "get", "}", ";", "return", "store", "[", "method", "]", "||", "taxonomy", "[", "method", "]", ";", "}" ]

[ "normalize", "the", "api", "taxonomy", "with", "a", "convenience", "that", "returns", "the", "correct", "function", "for", "a", "store", "." ]

[ "function", "valid_leader", "(", "durations", ")", "{", "var", "on", "=", "durations", "[", "0", "]", ";", "var", "off", "=", "durations", "[", "1", "]", ";", "return", "(", "8900", "<", "on", "&&", "on", "<", "9200", ")", "&&", "(", "-", "4600", "<", "off", "&&", "off", "<", "-", "4350", ")", ";", "}" ]

[ "validate", "the", "leader", "bit" ]

[ "function", "command_id_from_buffer", "(", "data", ")", "{", "var", "durations", "=", "command_durations_from_hex_buffer", "(", "data", ")", ";", "if", "(", "!", "valid_leader", "(", "durations", ")", ")", "return", ";", "var", "binary", "=", "binary_from_durations", "(", "durations", ")", ";", "if", "(", "!", "valid_binary", "(", "binary", ")", ")", "return", ";", "var", "bytes", "=", "bytes_from_binary", "(", "binary", ")", ";", "if", "(", "!", "valid_bytes", "(", "bytes", ")", ")", "return", ";", "if", "(", "!", "valid_codes", "(", "bytes", ")", ")", "return", ";", "return", "command_id_from_bytes", "(", "bytes", ")", ";", "}" ]

[ "a", "small", "implementation", "of", "the", "whole", "flow" ]

[ "function", "continue_from_buffer", "(", "data", ")", "{", "var", "durations", "=", "continue_durations_from_hex_buffer", "(", "data", ")", ";", "var", "on", "=", "durations", "[", "0", "]", ";", "var", "off", "=", "durations", "[", "1", "]", ";", "var", "stop", "=", "durations", "[", "2", "]", ";", "return", "(", "8900", "<", "on", "&&", "on", "<", "9200", ")", "&&", "(", "-", "2350", "<", "off", "&&", "off", "<", "-", "2100", ")", "&&", "(", "500", "<", "stop", "&&", "stop", "<", "650", ")", ";", "}" ]

[ "determine", "whether", "or", "not", "the", "buffer", "is", "a", "valid", "continuation", "code" ]

[ "function", "versions", "(", "a", ",", "b", ")", "{", "if", "(", "!", "a", "||", "!", "b", ")", "return", "false", ";", "a", "=", "Array", ".", "isArray", "(", "a", ")", "?", "a", ":", "Object", ".", "keys", "(", "a", ")", ";", "b", "=", "Array", ".", "isArray", "(", "a", ")", "?", "a", ":", "Object", ".", "keys", "(", "a", ")", ";", "return", "a", ".", "length", "===", "b", ".", "length", "&&", "a", ".", "reduce", "(", "function", "has", "(", "memo", ",", "item", ")", "{", "return", "memo", "&&", "~", "b", ".", "indexOf", "(", "item", ")", ";", "}", ",", "true", ")", ";", "}" ]

[ "Unpublished", "modules", "will", "have", "no", "versions", "modified", "time", "should", "be", "equal", "." ]

[ "function", "dereference", "(", "file", ",", "opts", ",", "cb", ")", "{", "parser", ".", "dereference", "(", "file", ".", "path", ",", "opts", ",", "(", "err", ",", "schema", ")", "=>", "{", "if", "(", "err", ")", "{", "this", ".", "emit", "(", "'error'", ",", "new", "gutil", ".", "PluginError", "(", "'gulp-jsonschema-deref'", ",", "err", ",", "{", "fileName", ":", "file", ".", "path", "}", ")", ")", ";", "}", "else", "{", "file", ".", "contents", "=", "Buffer", ".", "from", "(", "JSON", ".", "stringify", "(", "schema", ")", ")", ";", "this", ".", "push", "(", "file", ")", ";", "}", "cb", "(", ")", ";", "}", ")", ";", "}" ]

[ "Dereference", "a", "jsonschema" ]

[ "function", "breadcrumbs", "(", "target", ",", "path", ")", "{", "path", "=", "pathToArray", "(", "path", ")", ";", "const", "result", "=", "[", "target", "]", ";", "let", "part", ";", "let", "value", "=", "target", ";", "if", "(", "!", "isObject", "(", "value", ")", ")", "{", "return", "result", ";", "}", "for", "(", "let", "i", "=", "0", ",", "l", "=", "path", ".", "length", ";", "i", "<", "l", ";", "i", "++", ")", "{", "part", "=", "path", "[", "i", "]", ";", "if", "(", "!", "value", ".", "hasOwnProperty", "(", "part", ")", ")", "{", "break", ";", "}", "result", ".", "push", "(", "value", "[", "part", "]", ")", ";", "value", "=", "value", "[", "part", "]", ";", "}", "return", "result", ";", "}" ]

[ "breadcrumbs", "-", "Extract", "nested", "value", "by", "path", "and", "return", "as", "array", ".", "If", "target", "is", "not", "an", "object", "or", "path", "is", "empty", "returns", "empty", "array", "." ]

[ "function", "hasPath", "(", "target", ",", "path", ")", "{", "path", "=", "pathToArray", "(", "path", ")", ";", "const", "result", "=", "breadcrumbs", "(", "target", ",", "path", ")", ";", "return", "result", ".", "length", "===", "path", ".", "length", "+", "1", ";", "}" ]

[ "hasPath", "-", "Set", "deeply", "nested", "value", "into", "target", "object", ".", "If", "nested", "properties", "are", "not", "an", "objects", "or", "not", "exists", "creates", "them", "." ]

[ "function", "setByPath", "(", "target", ",", "path", ",", "value", ")", "{", "path", "=", "pathToArray", "(", "path", ")", ";", "if", "(", "!", "path", ".", "length", ")", "{", "return", "value", ";", "}", "const", "key", "=", "path", "[", "0", "]", ";", "if", "(", "isNumber", "(", "key", ")", ")", "{", "if", "(", "!", "Array", ".", "isArray", "(", "target", ")", ")", "{", "target", "=", "[", "]", ";", "}", "}", "else", "if", "(", "!", "isObject", "(", "target", ")", ")", "{", "target", "=", "{", "}", ";", "}", "if", "(", "path", ".", "length", ">", "1", ")", "{", "target", "[", "key", "]", "=", "setByPath", "(", "target", "[", "key", "]", ",", "path", ".", "slice", "(", "1", ")", ",", "value", ")", ";", "}", "else", "{", "target", "[", "key", "]", "=", "value", ";", "}", "return", "target", ";", "}" ]

[ "setByPath", "-", "Set", "deeply", "nested", "value", "into", "target", "object", ".", "If", "nested", "properties", "are", "not", "an", "objects", "or", "not", "exists", "creates", "them", "." ]

[ "function", "pushByPath", "(", "target", ",", "path", ",", "value", ")", "{", "path", "=", "pathToArray", "(", "path", ")", ";", "if", "(", "!", "path", ".", "length", ")", "{", "if", "(", "!", "Array", ".", "isArray", "(", "target", ")", ")", "{", "return", "[", "value", "]", ";", "}", "else", "{", "target", ".", "push", "(", "value", ")", ";", "return", "target", ";", "}", "}", "if", "(", "!", "isObject", "(", "target", ")", ")", "{", "target", "=", "{", "}", ";", "}", "return", "at", "(", "target", ",", "path", ",", "function", "(", "finalTarget", ",", "key", ")", "{", "if", "(", "Array", ".", "isArray", "(", "finalTarget", "[", "key", "]", ")", ")", "{", "finalTarget", "[", "key", "]", ".", "push", "(", "value", ")", ";", "}", "else", "{", "finalTarget", "[", "key", "]", "=", "[", "value", "]", ";", "}", "return", "finalTarget", ";", "}", ")", ";", "}" ]

[ "Push", "deeply", "nested", "value", "into", "target", "object", ".", "If", "nested", "properties", "are", "not", "an", "objects", "or", "not", "exists", "creates", "them", "." ]

[ "function", "getByPath", "(", "target", ",", "path", ")", "{", "path", "=", "pathToArray", "(", "path", ")", ";", "const", "values", "=", "breadcrumbs", "(", "target", ",", "path", ")", ";", "return", "values", "[", "values", ".", "length", "-", "1", "]", ";", "}" ]

[ "getByPath", "-", "Get", "value", "from", "target", "by", "path", "." ]

[ "function", "methodByPath", "(", "target", ",", "path", ")", "{", "path", "=", "pathToArray", "(", "path", ")", ";", "const", "values", "=", "breadcrumbs", "(", "target", ",", "path", ")", ";", "if", "(", "values", ".", "length", "<", "path", ".", "length", ")", "{", "return", "noop", ";", "}", "if", "(", "typeof", "values", "[", "values", ".", "length", "-", "1", "]", "!==", "'function'", ")", "{", "return", "noop", ";", "}", "if", "(", "values", ".", "length", ">", "1", ")", "{", "return", "values", "[", "values", ".", "length", "-", "1", "]", ".", "bind", "(", "values", "[", "values", ".", "length", "-", "2", "]", ")", ";", "}", "else", "{", "return", "values", "[", "0", "]", ".", "bind", "(", "target", ")", ";", "}", "}" ]

[ "methodByPath", "-", "Receive", "method", "from", "deeply", "nested", "object", "as", "function", "with", "captured", "context", "as", "the", "method", "s", "owner", "object", "." ]

[ "function", "callByPath", "(", "target", ",", "path", ",", "args", ")", "{", "var", "fn", "=", "methodByPath", "(", "target", ",", "path", ")", ";", "if", "(", "!", "fn", ")", "{", "return", ";", "}", "return", "fn", ".", "apply", "(", "null", ",", "args", ")", ";", "}" ]

[ "callByPath", "-", "Call", "method", "by", "it", "s", "path", "in", "nested", "object", "." ]

[ "function", "(", "point", ")", "{", "var", "d2r", "=", "Math", ".", "PI", "/", "180.0", ";", "var", "lat1rad", "=", "this", ".", "latitude", "*", "d2r", ";", "var", "long1rad", "=", "this", ".", "longitude", "*", "d2r", ";", "var", "lat2rad", "=", "point", ".", "latitude", "*", "d2r", ";", "var", "long2rad", "=", "point", ".", "longitude", "*", "d2r", ";", "var", "deltaLat", "=", "lat1rad", "-", "lat2rad", ";", "var", "deltaLong", "=", "long1rad", "-", "long2rad", ";", "var", "sinDeltaLatDiv2", "=", "Math", ".", "sin", "(", "deltaLat", "/", "2", ")", ";", "var", "sinDeltaLongDiv2", "=", "Math", ".", "sin", "(", "deltaLong", "/", "2", ")", ";", "// Square of half the straight line chord distance between both points.", "var", "a", "=", "(", "(", "sinDeltaLatDiv2", "*", "sinDeltaLatDiv2", ")", "+", "(", "Math", ".", "cos", "(", "lat1rad", ")", "*", "Math", ".", "cos", "(", "lat2rad", ")", "*", "sinDeltaLongDiv2", "*", "sinDeltaLongDiv2", ")", ")", ";", "a", "=", "Math", ".", "min", "(", "1.0", ",", "a", ")", ";", "return", "2", "*", "Math", ".", "asin", "(", "Math", ".", "sqrt", "(", "a", ")", ")", ";", "}" ]

[ "Returns", "the", "distance", "from", "this", "GeoPoint", "to", "another", "in", "radians", "." ]

[ "function", "throwError", "(", "name", ",", "message", ")", "{", "var", "error", "=", "new", "Error", "(", "message", ")", ";", "error", ".", "name", "=", "name", ";", "error", ".", "stack", "=", "formaterrors", ".", "stackFilter", "(", "error", ".", "stack", ",", "[", "\"exceptions.js\"", "]", ",", "false", ")", ";", "throw", "error", ";", "}" ]

[ "Throw", "an", "error", ".", "This", "method", "ensures", "that", "no", "exceptions", ".", "js", "lines", "are", "included", "in", "the", "stack", "trace", "of", "the", "thrown", "error", "." ]

[ "function", "regret", "(", "name", ",", "input", ")", "{", "var", "matchers", ",", "res", "=", "null", ",", "re", ",", "matches", ",", "matcher", ";", "if", "(", "typeof", "name", ".", "exec", "===", "'function'", ")", "{", "matchers", "=", "Object", ".", "keys", "(", "regret", ".", "matchers", ")", ".", "filter", "(", "function", "(", "m", ")", "{", "return", "name", ".", "test", "(", "m", ")", ";", "}", ")", ".", "map", "(", "function", "(", "m", ")", "{", "return", "regret", ".", "matchers", "[", "m", "]", ";", "}", ")", ";", "}", "else", "{", "matchers", "=", "regret", ".", "matchers", "[", "name", "]", "?", "[", "regret", ".", "matchers", "[", "name", "]", "]", ":", "[", "]", ";", "}", "if", "(", "matchers", ".", "length", "===", "0", ")", "{", "return", "undefined", ";", "}", "while", "(", "matchers", ".", "length", ">", "0", ")", "{", "matcher", "=", "matchers", ".", "shift", "(", ")", ";", "matches", "=", "matcher", ".", "pattern", ".", "exec", "(", "input", ")", ";", "if", "(", "!", "matches", ")", "{", "continue", ";", "}", "res", "=", "{", "}", ";", "// pop off the input string", "matches", ".", "shift", "(", ")", ";", "matches", ".", "map", "(", "function", "(", "p", ",", "i", ")", "{", "res", "[", "matcher", ".", "captures", "[", "i", "]", "]", "=", "p", ";", "}", ")", ";", "break", ";", "}", "return", "res", ";", "}" ]

[ "Don", "t", "let", "the", "regex", "party", "get", "out", "of", "control", "." ]

[ "function", "seqActions", "(", "actions", ",", "seed", ",", "onCompleted", ")", "{", "var", "index", "=", "0", ";", "function", "invokeNext", "(", "v", ")", "{", "var", "action", "=", "actions", "[", "index", "]", ";", "action", "(", "v", ",", "function", "(", "res", ")", "{", "index", "=", "index", "+", "1", ";", "if", "(", "index", "<", "actions", ".", "length", ")", "{", "invokeNext", "(", "res", ")", ";", "}", "else", "{", "onCompleted", "(", "res", ")", ";", "}", "}", ")", ";", "}", "invokeNext", "(", "seed", ")", ";", "}" ]

[ "chain", "a", "sequence", "of", "asynchronous", "actions" ]

[ "function", "RestApi", "(", "config", ",", "cb", ")", "{", "var", "self", "=", "this", ";", "self", ".", "routes", "=", "{", "}", ";", "self", ".", "bindTo", "=", "(", "config", "&&", "config", ".", "bindTo", ")", "?", "config", ".", "bindTo", ":", "undefined", ";", "self", ".", "port", "=", "(", "config", "&&", "config", ".", "port", ")", "?", "config", ".", "port", ":", "DEFAULT_PORT", ";", "// create the HTTP server object and on every request, try to match the", "// request with a known route. If there is no match, return a 404 error.", "self", ".", "HttpServer", "=", "http", ".", "createServer", "(", "function", "(", "req", ",", "res", ")", "{", "var", "uriPath", ";", "var", "queryStr", ";", "var", "urlParts", "=", "url", ".", "parse", "(", "req", ".", "url", ",", "true", ")", ";", "if", "(", "is", ".", "obj", "(", "urlParts", ")", ")", "{", "uriPath", "=", "urlParts", ".", "pathname", "||", "undefined", ";", "queryStr", "=", "urlParts", ".", "query", "||", "undefined", ";", "debug", "(", "'queryStr: '", "+", "inspect", "(", "queryStr", ")", ")", ";", "}", "else", "{", "// no match was found, return a 404 error.", "res", ".", "writeHead", "(", "400", ",", "{", "'Content-Type'", ":", "'application/json; charset=utf-8'", "}", ")", ";", "res", ".", "end", "(", "'{status:400, message:\"Bad URI path.\"}'", ",", "'utf8'", ")", ";", "return", ";", "}", "// try to match the request & method with a handler", "for", "(", "var", "path", "in", "self", ".", "routes", "[", "req", ".", "method", "]", ")", "{", "if", "(", "path", "===", "uriPath", ")", "{", "self", ".", "routes", "[", "req", ".", "method", "]", "[", "path", "]", "(", "req", ",", "res", ",", "queryStr", ")", ";", "return", ";", "}", "}", "// no match was found, return a 404 error.", "res", ".", "writeHead", "(", "404", ",", "{", "'Content-Type'", ":", "'application/json; charset=utf-8'", "}", ")", ";", "res", ".", "end", "(", "'{status:404, message:\"Content not found.\"}'", ",", "'utf8'", ")", ";", "}", ")", ";", "if", "(", "cb", ")", "self", ".", "listen", "(", "cb", ")", ";", "}" ]

[ "RestApi", "constructor", ".", "Creates", "the", "HTTP", "server", "objects", "and", "starts", "listening", "on", "the", "socket", "." ]

[ "function", "Rule", "(", "subrules", ",", "type", ",", "handler", ",", "props", ",", "groupProps", ",", "encoding", ")", "{", "var", "self", "=", "this", "var", "n", "=", "subrules", ".", "length", "this", ".", "props", "=", "props", "this", ".", "debug", "=", "false", "// Used for cloning", "this", ".", "subrules", "=", "subrules", "// Required by Atok#_resolveRules", "for", "(", "var", "p", "in", "groupProps", ")", "this", "[", "p", "]", "=", "groupProps", "[", "p", "]", "// Runtime values for continue props", "this", ".", "continue", "=", "this", ".", "props", ".", "continue", "[", "0", "]", "this", ".", "continueOnFail", "=", "this", ".", "props", ".", "continue", "[", "1", "]", "this", ".", "type", "=", "type", "this", ".", "handler", "=", "handler", "// For debug", "this", ".", "prevHandler", "=", "null", "this", ".", "id", "=", "this", ".", "type", "!==", "null", "?", "this", ".", "type", ":", "handler", "// Id for debug", "this", ".", "_id", "=", "(", "handler", "!==", "null", "?", "(", "handler", ".", "name", "||", "'#emit()'", ")", ":", "this", ".", "type", ")", "// Subrule pattern index that matched (-1 if only 1 pattern)", "this", ".", "idx", "=", "-", "1", "// Single subrule: special case for trimRight", "this", ".", "single", "=", "(", "n", "===", "1", ")", "// First subrule", "var", "subrule", "=", "this", ".", "first", "=", "n", ">", "0", "?", "SubRule", ".", "firstSubRule", "(", "subrules", "[", "0", "]", ",", "this", ".", "props", ",", "encoding", ",", "this", ".", "single", ")", "// Special case: no rule given -> passthrough", ":", "SubRule", ".", "emptySubRule", "// Special case: one empty rule -> tokenize whole buffer", "if", "(", "n", "===", "1", "&&", "subrule", ".", "length", "===", "0", ")", "{", "subrule", "=", "this", ".", "first", "=", "SubRule", ".", "allSubRule", "// Make infinite loop detection ignore this", "this", ".", "length", "=", "-", "1", "}", "else", "{", "// First subrule pattern length (max of all patterns if many)", "// - used in infinite loop detection", "this", ".", "length", "=", "this", ".", "first", ".", "length", "}", "// Instantiate and link the subrules", "// { test: {Function}", "// , next: {SubRule|undefined}", "// }", "var", "prev", "=", "subrule", "// Many subrules or none", "for", "(", "var", "i", "=", "1", ";", "i", "<", "n", ";", "i", "++", ")", "{", "subrule", "=", "SubRule", ".", "SubRule", "(", "subrules", "[", "i", "]", ",", "this", ".", "props", ",", "encoding", ")", "prev", ".", "next", "=", "subrule", "subrule", ".", "prev", "=", "prev", "// Useful in some edge cases", "prev", "=", "subrule", "if", "(", "this", ".", "length", "<", "subrule", ".", "length", ")", "this", ".", "length", "=", "subrule", ".", "length", "}", "// Last subrule (used for trimRight and matched idx)", "this", ".", "last", "=", "subrule", "// Set the first and last subrules length based on trim properties", "if", "(", "!", "this", ".", "props", ".", "trimLeft", ")", "this", ".", "first", ".", "length", "=", "0", "if", "(", "!", "this", ".", "single", "&&", "!", "this", ".", "props", ".", "trimRight", ")", "this", ".", "last", ".", "length", "=", "0", "this", ".", "next", "=", "null", "this", ".", "nextFail", "=", "null", "this", ".", "currentRule", "=", "null", "}" ]

[ "Atok", "Rule", "constructor" ]

[ "function", "initializeItemSerializer", "(", "hasItems", ")", "{", "// Is there is a itemSerializer specified, we MUST use it.", "// If existing data and no itemSerializer specified, this is an old JSON database,", "// so \"fake\" the compatible JSON serializer", "var", "providerInfo", "=", "storageProvider", ".", "getMetadata", "(", "namespace", ")", ";", "// TODO I hate this!", "var", "itemSerializerName", "=", "providerInfo", "?", "providerInfo", ".", "itemSerializer", ":", "hasItems", "?", "\"JSONSerializer\"", ":", "null", ";", "storageProvider", ".", "itemSerializer", "=", "itemSerializerName", ";", "}" ]

[ "Read", "in", "the", "base", "namespace", "key", "." ]

[ "function", "_yield", "(", "name", ",", "context", ")", "{", "var", "prop", "=", "this", ".", "props", "[", "name", "||", "'children'", "]", ";", "if", "(", "typeof", "prop", "!==", "'function'", ")", "return", "prop", ";", "var", "args", "=", "Array", ".", "prototype", ".", "slice", ".", "call", "(", "arguments", ",", "2", ")", ";", "return", "prop", ".", "apply", "(", "context", ",", "args", ")", ";", "}" ]

[ "Wrap", "the", "yield", "function" ]

[ "function", "getJsonResource", "(", "url", ")", "{", "var", "protocol", "=", "url", ".", "match", "(", "/", "^(.*?):", "/", ")", "protocol", "=", "(", "protocol", "&&", "protocol", "[", "1", "]", ")", "||", "'file'", "const", "defaultLoader", "=", "defaultOptions", ".", "loaders", "[", "protocol", "]", "const", "loader", "=", "options", ".", "loaders", "[", "protocol", "]", "return", "Promise", ".", "resolve", "(", "cache", "[", "url", "]", ")", ".", "then", "(", "cached", "=>", "{", "if", "(", "cached", ")", "{", "return", "cached", "}", "else", "{", "return", "loader", "(", "url", ",", "defaultOptions", ".", "loaders", ")", ".", "then", "(", "json", "=>", "cache", "[", "url", "]", "=", "{", "raw", ":", "json", ",", "parsed", ":", "Array", ".", "isArray", "(", "json", ")", "?", "[", "]", ":", "{", "}", "}", ")", "}", "}", ")", "}" ]

[ "Gets", "raw", "and", "parsed", "json", "from", "cache" ]