diff options
Diffstat (limited to 'devtools/shared/jsbeautify/src')
| -rw-r--r-- | devtools/shared/jsbeautify/src/beautify-css.js | 367 | ||||
| -rw-r--r-- | devtools/shared/jsbeautify/src/beautify-html.js | 822 | ||||
| -rw-r--r-- | devtools/shared/jsbeautify/src/beautify-js.js | 1662 | ||||
| -rw-r--r-- | devtools/shared/jsbeautify/src/beautify-tests.js | 2096 | ||||
| -rw-r--r-- | devtools/shared/jsbeautify/src/moz.build | 12 |
5 files changed, 4959 insertions, 0 deletions
diff --git a/devtools/shared/jsbeautify/src/beautify-css.js b/devtools/shared/jsbeautify/src/beautify-css.js new file mode 100644 index 000000000..faf9ac0f2 --- /dev/null +++ b/devtools/shared/jsbeautify/src/beautify-css.js @@ -0,0 +1,367 @@ +/*jshint curly:true, eqeqeq:true, laxbreak:true, noempty:false */ +/* + + The MIT License (MIT) + + Copyright (c) 2007-2013 Einar Lielmanis and contributors. + + Permission is hereby granted, free of charge, to any person + obtaining a copy of this software and associated documentation files + (the "Software"), to deal in the Software without restriction, + including without limitation the rights to use, copy, modify, merge, + publish, distribute, sublicense, and/or sell copies of the Software, + and to permit persons to whom the Software is furnished to do so, + subject to the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. + + + CSS Beautifier +--------------- + + Written by Harutyun Amirjanyan, (amirjanyan@gmail.com) + + Based on code initially developed by: Einar Lielmanis, <einar@jsbeautifier.org> + http://jsbeautifier.org/ + + Usage: + css_beautify(source_text); + css_beautify(source_text, options); + + The options are (default in brackets): + indent_size (4) — indentation size, + indent_char (space) — character to indent with, + selector_separator_newline (true) - separate selectors with newline or + not (e.g. "a,\nbr" or "a, br") + end_with_newline (false) - end with a newline + + e.g + + css_beautify(css_source_text, { + 'indent_size': 1, + 'indent_char': '\t', + 'selector_separator': ' ', + 'end_with_newline': false, + }); +*/ + +// http://www.w3.org/TR/CSS21/syndata.html#tokenization +// http://www.w3.org/TR/css3-syntax/ + +(function () { + function css_beautify(source_text, options) { + options = options || {}; + var indentSize = options.indent_size || 4; + var indentCharacter = options.indent_char || ' '; + var selectorSeparatorNewline = (options.selector_separator_newline === undefined) ? true : options.selector_separator_newline; + var endWithNewline = (options.end_with_newline === undefined) ? false : options.end_with_newline; + + // compatibility + if (typeof indentSize === "string") { + indentSize = parseInt(indentSize, 10); + } + + + // tokenizer + var whiteRe = /^\s+$/; + var wordRe = /[\w$\-_]/; + + var pos = -1, + ch; + + function next() { + ch = source_text.charAt(++pos); + return ch; + } + + function peek() { + return source_text.charAt(pos + 1); + } + + function eatString(endChar) { + var start = pos; + while (next()) { + if (ch === "\\") { + next(); + next(); + } else if (ch === endChar) { + break; + } else if (ch === "\n") { + break; + } + } + return source_text.substring(start, pos + 1); + } + + function eatWhitespace() { + var start = pos; + while (whiteRe.test(peek())) { + pos++; + } + return pos !== start; + } + + function skipWhitespace() { + var start = pos; + do {} while (whiteRe.test(next())); + return pos !== start + 1; + } + + function eatComment(singleLine) { + var start = pos; + next(); + while (next()) { + if (ch === "*" && peek() === "/") { + pos++; + break; + } else if (singleLine && ch === "\n") { + break; + } + } + + return source_text.substring(start, pos + 1); + } + + + function lookBack(str) { + return source_text.substring(pos - str.length, pos).toLowerCase() === + str; + } + + function isCommentOnLine() { + var endOfLine = source_text.indexOf('\n', pos); + if (endOfLine === -1) { + return false; + } + var restOfLine = source_text.substring(pos, endOfLine); + return restOfLine.indexOf('//') !== -1; + } + + // printer + var indentString = source_text.match(/^[\r\n]*[\t ]*/)[0]; + var singleIndent = new Array(indentSize + 1).join(indentCharacter); + var indentLevel = 0; + var nestedLevel = 0; + + function indent() { + indentLevel++; + indentString += singleIndent; + } + + function outdent() { + indentLevel--; + indentString = indentString.slice(0, -indentSize); + } + + var print = {}; + print["{"] = function (ch) { + print.singleSpace(); + output.push(ch); + print.newLine(); + }; + print["}"] = function (ch) { + print.newLine(); + output.push(ch); + print.newLine(); + }; + + print._lastCharWhitespace = function () { + return whiteRe.test(output[output.length - 1]); + }; + + print.newLine = function (keepWhitespace) { + if (!keepWhitespace) { + while (print._lastCharWhitespace()) { + output.pop(); + } + } + + if (output.length) { + output.push('\n'); + } + if (indentString) { + output.push(indentString); + } + }; + print.singleSpace = function () { + if (output.length && !print._lastCharWhitespace()) { + output.push(' '); + } + }; + var output = []; + if (indentString) { + output.push(indentString); + } + /*_____________________--------------------_____________________*/ + + var insideRule = false; + var enteringConditionalGroup = false; + + while (true) { + var isAfterSpace = skipWhitespace(); + + if (!ch) { + break; + } else if (ch === '/' && peek() === '*') { /* css comment */ + print.newLine(); + output.push(eatComment(), "\n", indentString); + var header = lookBack(""); + if (header) { + print.newLine(); + } + } else if (ch === '/' && peek() === '/') { // single line comment + output.push(eatComment(true), indentString); + } else if (ch === '@') { + // strip trailing space, if present, for hash property checks + var atRule = eatString(" ").replace(/ $/, ''); + + // pass along the space we found as a separate item + output.push(atRule, ch); + + // might be a nesting at-rule + if (atRule in css_beautify.NESTED_AT_RULE) { + nestedLevel += 1; + if (atRule in css_beautify.CONDITIONAL_GROUP_RULE) { + enteringConditionalGroup = true; + } + } + } else if (ch === '{') { + eatWhitespace(); + if (peek() === '}') { + next(); + output.push(" {}"); + } else { + indent(); + print["{"](ch); + // when entering conditional groups, only rulesets are allowed + if (enteringConditionalGroup) { + enteringConditionalGroup = false; + insideRule = (indentLevel > nestedLevel); + } else { + // otherwise, declarations are also allowed + insideRule = (indentLevel >= nestedLevel); + } + } + } else if (ch === '}') { + outdent(); + print["}"](ch); + insideRule = false; + if (nestedLevel) { + nestedLevel--; + } + } else if (ch === ":") { + eatWhitespace(); + if (insideRule || enteringConditionalGroup) { + // 'property: value' delimiter + // which could be in a conditional group query + output.push(ch, " "); + } else { + if (peek() === ":") { + // pseudo-element + next(); + output.push("::"); + } else { + // pseudo-class + output.push(ch); + } + } + } else if (ch === '"' || ch === '\'') { + output.push(eatString(ch)); + } else if (ch === ';') { + if (isCommentOnLine()) { + var beforeComment = eatString('/'); + var comment = eatComment(true); + output.push(beforeComment, comment.substring(1, comment.length - 1), '\n', indentString); + } else { + output.push(ch, '\n', indentString); + } + } else if (ch === '(') { // may be a url + if (lookBack("url")) { + output.push(ch); + eatWhitespace(); + if (next()) { + if (ch !== ')' && ch !== '"' && ch !== '\'') { + output.push(eatString(')')); + } else { + pos--; + } + } + } else { + if (isAfterSpace) { + print.singleSpace(); + } + output.push(ch); + eatWhitespace(); + } + } else if (ch === ')') { + output.push(ch); + } else if (ch === ',') { + eatWhitespace(); + output.push(ch); + if (!insideRule && selectorSeparatorNewline) { + print.newLine(); + } else { + print.singleSpace(); + } + } else if (ch === ']') { + output.push(ch); + } else if (ch === '[') { + if (isAfterSpace) { + print.singleSpace(); + } + output.push(ch); + } else if (ch === '=') { // no whitespace before or after + eatWhitespace(); + output.push(ch); + } else { + if (isAfterSpace) { + print.singleSpace(); + } + + output.push(ch); + } + } + + + var sweetCode = output.join('').replace(/[\n ]+$/, ''); + + // establish end_with_newline + var should = endWithNewline; + var actually = /\n$/.test(sweetCode); + if (should && !actually) { + sweetCode += "\n"; + } else if (!should && actually) { + sweetCode = sweetCode.slice(0, -1); + } + + return sweetCode; + } + + // https://developer.mozilla.org/en-US/docs/Web/CSS/At-rule + css_beautify.NESTED_AT_RULE = { + "@page": true, + "@font-face": true, + "@keyframes": true, + // also in CONDITIONAL_GROUP_RULE below + "@media": true, + "@supports": true, + "@document": true + }; + css_beautify.CONDITIONAL_GROUP_RULE = { + "@media": true, + "@supports": true, + "@document": true + }; + + exports.cssBeautify = css_beautify; +}()); diff --git a/devtools/shared/jsbeautify/src/beautify-html.js b/devtools/shared/jsbeautify/src/beautify-html.js new file mode 100644 index 000000000..4967c3e3d --- /dev/null +++ b/devtools/shared/jsbeautify/src/beautify-html.js @@ -0,0 +1,822 @@ +/*jshint curly:true, eqeqeq:true, laxbreak:true, noempty:false */ +/* + + The MIT License (MIT) + + Copyright (c) 2007-2013 Einar Lielmanis and contributors. + + Permission is hereby granted, free of charge, to any person + obtaining a copy of this software and associated documentation files + (the "Software"), to deal in the Software without restriction, + including without limitation the rights to use, copy, modify, merge, + publish, distribute, sublicense, and/or sell copies of the Software, + and to permit persons to whom the Software is furnished to do so, + subject to the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. + + + Style HTML +--------------- + + Written by Nochum Sossonko, (nsossonko@hotmail.com) + + Based on code initially developed by: Einar Lielmanis, <einar@jsbeautifier.org> + http://jsbeautifier.org/ + + Usage: + style_html(html_source); + + style_html(html_source, options); + + The options are: + indent_inner_html (default false) — indent <head> and <body> sections, + indent_size (default 4) — indentation size, + indent_char (default space) — character to indent with, + wrap_line_length (default 250) - maximum amount of characters per line (0 = disable) + brace_style (default "collapse") - "collapse" | "expand" | "end-expand" + put braces on the same line as control statements (default), or put braces on own line (Allman / ANSI style), or just put end braces on own line. + unformatted (defaults to inline tags) - list of tags, that shouldn't be reformatted + indent_scripts (default normal) - "keep"|"separate"|"normal" + preserve_newlines (default true) - whether existing line breaks before elements should be preserved + Only works before elements, not inside tags or for text. + max_preserve_newlines (default unlimited) - maximum number of line breaks to be preserved in one chunk + indent_handlebars (default false) - format and indent {{#foo}} and {{/foo}} + + e.g. + + style_html(html_source, { + 'indent_inner_html': false, + 'indent_size': 2, + 'indent_char': ' ', + 'wrap_line_length': 78, + 'brace_style': 'expand', + 'unformatted': ['a', 'sub', 'sup', 'b', 'i', 'u'], + 'preserve_newlines': true, + 'max_preserve_newlines': 5, + 'indent_handlebars': false + }); +*/ + +(function() { + + function trim(s) { + return s.replace(/^\s+|\s+$/g, ''); + } + + function ltrim(s) { + return s.replace(/^\s+/g, ''); + } + + function style_html(html_source, options, js_beautify, css_beautify) { + //Wrapper function to invoke all the necessary constructors and deal with the output. + + var multi_parser, + indent_inner_html, + indent_size, + indent_character, + wrap_line_length, + brace_style, + unformatted, + preserve_newlines, + max_preserve_newlines, + indent_handlebars; + + options = options || {}; + + // backwards compatibility to 1.3.4 + if ((options.wrap_line_length === undefined || parseInt(options.wrap_line_length, 10) === 0) && + (options.max_char !== undefined && parseInt(options.max_char, 10) !== 0)) { + options.wrap_line_length = options.max_char; + } + + indent_inner_html = (options.indent_inner_html === undefined) ? false : options.indent_inner_html; + indent_size = (options.indent_size === undefined) ? 4 : parseInt(options.indent_size, 10); + indent_character = (options.indent_char === undefined) ? ' ' : options.indent_char; + brace_style = (options.brace_style === undefined) ? 'collapse' : options.brace_style; + wrap_line_length = parseInt(options.wrap_line_length, 10) === 0 ? 32786 : parseInt(options.wrap_line_length || 250, 10); + unformatted = options.unformatted || ['a', 'span', 'bdo', 'em', 'strong', 'dfn', 'code', 'samp', 'kbd', 'var', 'cite', 'abbr', 'acronym', 'q', 'sub', 'sup', 'tt', 'i', 'b', 'big', 'small', 'u', 's', 'strike', 'font', 'ins', 'del', 'pre', 'address', 'dt', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6']; + preserve_newlines = (options.preserve_newlines === undefined) ? true : options.preserve_newlines; + max_preserve_newlines = preserve_newlines ? + (isNaN(parseInt(options.max_preserve_newlines, 10)) ? 32786 : parseInt(options.max_preserve_newlines, 10)) + : 0; + indent_handlebars = (options.indent_handlebars === undefined) ? false : options.indent_handlebars; + + function Parser() { + + this.pos = 0; //Parser position + this.token = ''; + this.current_mode = 'CONTENT'; //reflects the current Parser mode: TAG/CONTENT + this.tags = { //An object to hold tags, their position, and their parent-tags, initiated with default values + parent: 'parent1', + parentcount: 1, + parent1: '' + }; + this.tag_type = ''; + this.token_text = this.last_token = this.last_text = this.token_type = ''; + this.newlines = 0; + this.indent_content = indent_inner_html; + + this.Utils = { //Uilities made available to the various functions + whitespace: "\n\r\t ".split(''), + single_token: 'br,input,link,meta,!doctype,basefont,base,area,hr,wbr,param,img,isindex,?xml,embed,?php,?,?='.split(','), //all the single tags for HTML + extra_liners: 'head,body,/html'.split(','), //for tags that need a line of whitespace before them + in_array: function(what, arr) { + for (var i = 0; i < arr.length; i++) { + if (what === arr[i]) { + return true; + } + } + return false; + } + }; + + this.traverse_whitespace = function() { + var input_char = ''; + + input_char = this.input.charAt(this.pos); + if (this.Utils.in_array(input_char, this.Utils.whitespace)) { + this.newlines = 0; + while (this.Utils.in_array(input_char, this.Utils.whitespace)) { + if (preserve_newlines && input_char === '\n' && this.newlines <= max_preserve_newlines) { + this.newlines += 1; + } + + this.pos++; + input_char = this.input.charAt(this.pos); + } + return true; + } + return false; + }; + + this.get_content = function() { //function to capture regular content between tags + + var input_char = '', + content = [], + space = false; //if a space is needed + + while (this.input.charAt(this.pos) !== '<') { + if (this.pos >= this.input.length) { + return content.length ? content.join('') : ['', 'TK_EOF']; + } + + if (this.traverse_whitespace()) { + if (content.length) { + space = true; + } + continue; //don't want to insert unnecessary space + } + + if (indent_handlebars) { + // Handlebars parsing is complicated. + // {{#foo}} and {{/foo}} are formatted tags. + // {{something}} should get treated as content, except: + // {{else}} specifically behaves like {{#if}} and {{/if}} + var peek3 = this.input.substr(this.pos, 3); + if (peek3 === '{{#' || peek3 === '{{/') { + // These are tags and not content. + break; + } else if (this.input.substr(this.pos, 2) === '{{') { + if (this.get_tag(true) === '{{else}}') { + break; + } + } + } + + input_char = this.input.charAt(this.pos); + this.pos++; + + if (space) { + if (this.line_char_count >= this.wrap_line_length) { //insert a line when the wrap_line_length is reached + this.print_newline(false, content); + this.print_indentation(content); + } else { + this.line_char_count++; + content.push(' '); + } + space = false; + } + this.line_char_count++; + content.push(input_char); //letter at-a-time (or string) inserted to an array + } + return content.length ? content.join('') : ''; + }; + + this.get_contents_to = function(name) { //get the full content of a script or style to pass to js_beautify + if (this.pos === this.input.length) { + return ['', 'TK_EOF']; + } + var input_char = ''; + var content = ''; + var reg_match = new RegExp('</' + name + '\\s*>', 'igm'); + reg_match.lastIndex = this.pos; + var reg_array = reg_match.exec(this.input); + var end_script = reg_array ? reg_array.index : this.input.length; //absolute end of script + if (this.pos < end_script) { //get everything in between the script tags + content = this.input.substring(this.pos, end_script); + this.pos = end_script; + } + return content; + }; + + this.record_tag = function(tag) { //function to record a tag and its parent in this.tags Object + if (this.tags[tag + 'count']) { //check for the existence of this tag type + this.tags[tag + 'count']++; + this.tags[tag + this.tags[tag + 'count']] = this.indent_level; //and record the present indent level + } else { //otherwise initialize this tag type + this.tags[tag + 'count'] = 1; + this.tags[tag + this.tags[tag + 'count']] = this.indent_level; //and record the present indent level + } + this.tags[tag + this.tags[tag + 'count'] + 'parent'] = this.tags.parent; //set the parent (i.e. in the case of a div this.tags.div1parent) + this.tags.parent = tag + this.tags[tag + 'count']; //and make this the current parent (i.e. in the case of a div 'div1') + }; + + this.retrieve_tag = function(tag) { //function to retrieve the opening tag to the corresponding closer + if (this.tags[tag + 'count']) { //if the openener is not in the Object we ignore it + var temp_parent = this.tags.parent; //check to see if it's a closable tag. + while (temp_parent) { //till we reach '' (the initial value); + if (tag + this.tags[tag + 'count'] === temp_parent) { //if this is it use it + break; + } + temp_parent = this.tags[temp_parent + 'parent']; //otherwise keep on climbing up the DOM Tree + } + if (temp_parent) { //if we caught something + this.indent_level = this.tags[tag + this.tags[tag + 'count']]; //set the indent_level accordingly + this.tags.parent = this.tags[temp_parent + 'parent']; //and set the current parent + } + delete this.tags[tag + this.tags[tag + 'count'] + 'parent']; //delete the closed tags parent reference... + delete this.tags[tag + this.tags[tag + 'count']]; //...and the tag itself + if (this.tags[tag + 'count'] === 1) { + delete this.tags[tag + 'count']; + } else { + this.tags[tag + 'count']--; + } + } + }; + + this.indent_to_tag = function(tag) { + // Match the indentation level to the last use of this tag, but don't remove it. + if (!this.tags[tag + 'count']) { + return; + } + var temp_parent = this.tags.parent; + while (temp_parent) { + if (tag + this.tags[tag + 'count'] === temp_parent) { + break; + } + temp_parent = this.tags[temp_parent + 'parent']; + } + if (temp_parent) { + this.indent_level = this.tags[tag + this.tags[tag + 'count']]; + } + }; + + this.get_tag = function(peek) { //function to get a full tag and parse its type + var input_char = '', + content = [], + comment = '', + space = false, + tag_start, tag_end, + tag_start_char, + orig_pos = this.pos, + orig_line_char_count = this.line_char_count; + + peek = peek !== undefined ? peek : false; + + do { + if (this.pos >= this.input.length) { + if (peek) { + this.pos = orig_pos; + this.line_char_count = orig_line_char_count; + } + return content.length ? content.join('') : ['', 'TK_EOF']; + } + + input_char = this.input.charAt(this.pos); + this.pos++; + + if (this.Utils.in_array(input_char, this.Utils.whitespace)) { //don't want to insert unnecessary space + space = true; + continue; + } + + if (input_char === "'" || input_char === '"') { + input_char += this.get_unformatted(input_char); + space = true; + + } + + if (input_char === '=') { //no space before = + space = false; + } + + if (content.length && content[content.length - 1] !== '=' && input_char !== '>' && space) { + //no space after = or before > + if (this.line_char_count >= this.wrap_line_length) { + this.print_newline(false, content); + this.print_indentation(content); + } else { + content.push(' '); + this.line_char_count++; + } + space = false; + } + + if (indent_handlebars && tag_start_char === '<') { + // When inside an angle-bracket tag, put spaces around + // handlebars not inside of strings. + if ((input_char + this.input.charAt(this.pos)) === '{{') { + input_char += this.get_unformatted('}}'); + if (content.length && content[content.length - 1] !== ' ' && content[content.length - 1] !== '<') { + input_char = ' ' + input_char; + } + space = true; + } + } + + if (input_char === '<' && !tag_start_char) { + tag_start = this.pos - 1; + tag_start_char = '<'; + } + + if (indent_handlebars && !tag_start_char) { + if (content.length >= 2 && content[content.length - 1] === '{' && content[content.length - 2] == '{') { + if (input_char === '#' || input_char === '/') { + tag_start = this.pos - 3; + } else { + tag_start = this.pos - 2; + } + tag_start_char = '{'; + } + } + + this.line_char_count++; + content.push(input_char); //inserts character at-a-time (or string) + + if (content[1] && content[1] === '!') { //if we're in a comment, do something special + // We treat all comments as literals, even more than preformatted tags + // we just look for the appropriate close tag + content = [this.get_comment(tag_start)]; + break; + } + + if (indent_handlebars && tag_start_char === '{' && content.length > 2 && content[content.length - 2] === '}' && content[content.length - 1] === '}') { + break; + } + } while (input_char !== '>'); + + var tag_complete = content.join(''); + var tag_index; + var tag_offset; + + if (tag_complete.indexOf(' ') !== -1) { //if there's whitespace, thats where the tag name ends + tag_index = tag_complete.indexOf(' '); + } else if (tag_complete[0] === '{') { + tag_index = tag_complete.indexOf('}'); + } else { //otherwise go with the tag ending + tag_index = tag_complete.indexOf('>'); + } + if (tag_complete[0] === '<' || !indent_handlebars) { + tag_offset = 1; + } else { + tag_offset = tag_complete[2] === '#' ? 3 : 2; + } + var tag_check = tag_complete.substring(tag_offset, tag_index).toLowerCase(); + if (tag_complete.charAt(tag_complete.length - 2) === '/' || + this.Utils.in_array(tag_check, this.Utils.single_token)) { //if this tag name is a single tag type (either in the list or has a closing /) + if (!peek) { + this.tag_type = 'SINGLE'; + } + } else if (indent_handlebars && tag_complete[0] === '{' && tag_check === 'else') { + if (!peek) { + this.indent_to_tag('if'); + this.tag_type = 'HANDLEBARS_ELSE'; + this.indent_content = true; + this.traverse_whitespace(); + } + } else if (tag_check === 'script' && + (tag_complete.search('type') === -1 || + (tag_complete.search('type') > -1 && + tag_complete.search(/\b(text|application)\/(x-)?(javascript|ecmascript|jscript|livescript)/) > -1))) { + if (!peek) { + this.record_tag(tag_check); + this.tag_type = 'SCRIPT'; + } + } else if (tag_check === 'style' && + (tag_complete.search('type') === -1 || + (tag_complete.search('type') > -1 && tag_complete.search('text/css') > -1))) { + if (!peek) { + this.record_tag(tag_check); + this.tag_type = 'STYLE'; + } + } else if (this.is_unformatted(tag_check, unformatted)) { // do not reformat the "unformatted" tags + comment = this.get_unformatted('</' + tag_check + '>', tag_complete); //...delegate to get_unformatted function + content.push(comment); + // Preserve collapsed whitespace either before or after this tag. + if (tag_start > 0 && this.Utils.in_array(this.input.charAt(tag_start - 1), this.Utils.whitespace)) { + content.splice(0, 0, this.input.charAt(tag_start - 1)); + } + tag_end = this.pos - 1; + if (this.Utils.in_array(this.input.charAt(tag_end + 1), this.Utils.whitespace)) { + content.push(this.input.charAt(tag_end + 1)); + } + this.tag_type = 'SINGLE'; + } else if (tag_check.charAt(0) === '!') { //peek for <! comment + // for comments content is already correct. + if (!peek) { + this.tag_type = 'SINGLE'; + this.traverse_whitespace(); + } + } else if (!peek) { + if (tag_check.charAt(0) === '/') { //this tag is a double tag so check for tag-ending + this.retrieve_tag(tag_check.substring(1)); //remove it and all ancestors + this.tag_type = 'END'; + this.traverse_whitespace(); + } else { //otherwise it's a start-tag + this.record_tag(tag_check); //push it on the tag stack + if (tag_check.toLowerCase() !== 'html') { + this.indent_content = true; + } + this.tag_type = 'START'; + + // Allow preserving of newlines after a start tag + this.traverse_whitespace(); + } + if (this.Utils.in_array(tag_check, this.Utils.extra_liners)) { //check if this double needs an extra line + this.print_newline(false, this.output); + if (this.output.length && this.output[this.output.length - 2] !== '\n') { + this.print_newline(true, this.output); + } + } + } + + if (peek) { + this.pos = orig_pos; + this.line_char_count = orig_line_char_count; + } + + return content.join(''); //returns fully formatted tag + }; + + this.get_comment = function(start_pos) { //function to return comment content in its entirety + // this is will have very poor perf, but will work for now. + var comment = '', + delimiter = '>', + matched = false; + + this.pos = start_pos; + input_char = this.input.charAt(this.pos); + this.pos++; + + while (this.pos <= this.input.length) { + comment += input_char; + + // only need to check for the delimiter if the last chars match + if (comment[comment.length - 1] === delimiter[delimiter.length - 1] && + comment.indexOf(delimiter) !== -1) { + break; + } + + // only need to search for custom delimiter for the first few characters + if (!matched && comment.length < 10) { + if (comment.indexOf('<![if') === 0) { //peek for <![if conditional comment + delimiter = '<![endif]>'; + matched = true; + } else if (comment.indexOf('<![cdata[') === 0) { //if it's a <[cdata[ comment... + delimiter = ']]>'; + matched = true; + } else if (comment.indexOf('<![') === 0) { // some other ![ comment? ... + delimiter = ']>'; + matched = true; + } else if (comment.indexOf('<!--') === 0) { // <!-- comment ... + delimiter = '-->'; + matched = true; + } + } + + input_char = this.input.charAt(this.pos); + this.pos++; + } + + return comment; + }; + + this.get_unformatted = function(delimiter, orig_tag) { //function to return unformatted content in its entirety + + if (orig_tag && orig_tag.toLowerCase().indexOf(delimiter) !== -1) { + return ''; + } + var input_char = ''; + var content = ''; + var min_index = 0; + var space = true; + do { + + if (this.pos >= this.input.length) { + return content; + } + + input_char = this.input.charAt(this.pos); + this.pos++; + + if (this.Utils.in_array(input_char, this.Utils.whitespace)) { + if (!space) { + this.line_char_count--; + continue; + } + if (input_char === '\n' || input_char === '\r') { + content += '\n'; + /* Don't change tab indention for unformatted blocks. If using code for html editing, this will greatly affect <pre> tags if they are specified in the 'unformatted array' + for (var i=0; i<this.indent_level; i++) { + content += this.indent_string; + } + space = false; //...and make sure other indentation is erased + */ + this.line_char_count = 0; + continue; + } + } + content += input_char; + this.line_char_count++; + space = true; + + if (indent_handlebars && input_char === '{' && content.length && content[content.length - 2] === '{') { + // Handlebars expressions in strings should also be unformatted. + content += this.get_unformatted('}}'); + // These expressions are opaque. Ignore delimiters found in them. + min_index = content.length; + } + } while (content.toLowerCase().indexOf(delimiter, min_index) === -1); + return content; + }; + + this.get_token = function() { //initial handler for token-retrieval + var token; + + if (this.last_token === 'TK_TAG_SCRIPT' || this.last_token === 'TK_TAG_STYLE') { //check if we need to format javascript + var type = this.last_token.substr(7); + token = this.get_contents_to(type); + if (typeof token !== 'string') { + return token; + } + return [token, 'TK_' + type]; + } + if (this.current_mode === 'CONTENT') { + token = this.get_content(); + if (typeof token !== 'string') { + return token; + } else { + return [token, 'TK_CONTENT']; + } + } + + if (this.current_mode === 'TAG') { + token = this.get_tag(); + if (typeof token !== 'string') { + return token; + } else { + var tag_name_type = 'TK_TAG_' + this.tag_type; + return [token, tag_name_type]; + } + } + }; + + this.get_full_indent = function(level) { + level = this.indent_level + level || 0; + if (level < 1) { + return ''; + } + + return Array(level + 1).join(this.indent_string); + }; + + this.is_unformatted = function(tag_check, unformatted) { + //is this an HTML5 block-level link? + if (!this.Utils.in_array(tag_check, unformatted)) { + return false; + } + + if (tag_check.toLowerCase() !== 'a' || !this.Utils.in_array('a', unformatted)) { + return true; + } + + //at this point we have an tag; is its first child something we want to remain + //unformatted? + var next_tag = this.get_tag(true /* peek. */ ); + + // test next_tag to see if it is just html tag (no external content) + var tag = (next_tag || "").match(/^\s*<\s*\/?([a-z]*)\s*[^>]*>\s*$/); + + // if next_tag comes back but is not an isolated tag, then + // let's treat the 'a' tag as having content + // and respect the unformatted option + if (!tag || this.Utils.in_array(tag, unformatted)) { + return true; + } else { + return false; + } + }; + + this.printer = function(js_source, indent_character, indent_size, wrap_line_length, brace_style) { //handles input/output and some other printing functions + + this.input = js_source || ''; //gets the input for the Parser + this.output = []; + this.indent_character = indent_character; + this.indent_string = ''; + this.indent_size = indent_size; + this.brace_style = brace_style; + this.indent_level = 0; + this.wrap_line_length = wrap_line_length; + this.line_char_count = 0; //count to see if wrap_line_length was exceeded + + for (var i = 0; i < this.indent_size; i++) { + this.indent_string += this.indent_character; + } + + this.print_newline = function(force, arr) { + this.line_char_count = 0; + if (!arr || !arr.length) { + return; + } + if (force || (arr[arr.length - 1] !== '\n')) { //we might want the extra line + arr.push('\n'); + } + }; + + this.print_indentation = function(arr) { + for (var i = 0; i < this.indent_level; i++) { + arr.push(this.indent_string); + this.line_char_count += this.indent_string.length; + } + }; + + this.print_token = function(text) { + if (text || text !== '') { + if (this.output.length && this.output[this.output.length - 1] === '\n') { + this.print_indentation(this.output); + text = ltrim(text); + } + } + this.print_token_raw(text); + }; + + this.print_token_raw = function(text) { + if (text && text !== '') { + if (text.length > 1 && text[text.length - 1] === '\n') { + // unformatted tags can grab newlines as their last character + this.output.push(text.slice(0, -1)); + this.print_newline(false, this.output); + } else { + this.output.push(text); + } + } + + for (var n = 0; n < this.newlines; n++) { + this.print_newline(n > 0, this.output); + } + this.newlines = 0; + }; + + this.indent = function() { + this.indent_level++; + }; + + this.unindent = function() { + if (this.indent_level > 0) { + this.indent_level--; + } + }; + }; + return this; + } + + /*_____________________--------------------_____________________*/ + + multi_parser = new Parser(); //wrapping functions Parser + multi_parser.printer(html_source, indent_character, indent_size, wrap_line_length, brace_style); //initialize starting values + + while (true) { + var t = multi_parser.get_token(); + multi_parser.token_text = t[0]; + multi_parser.token_type = t[1]; + + if (multi_parser.token_type === 'TK_EOF') { + break; + } + + switch (multi_parser.token_type) { + case 'TK_TAG_START': + multi_parser.print_newline(false, multi_parser.output); + multi_parser.print_token(multi_parser.token_text); + if (multi_parser.indent_content) { + multi_parser.indent(); + multi_parser.indent_content = false; + } + multi_parser.current_mode = 'CONTENT'; + break; + case 'TK_TAG_STYLE': + case 'TK_TAG_SCRIPT': + multi_parser.print_newline(false, multi_parser.output); + multi_parser.print_token(multi_parser.token_text); + multi_parser.current_mode = 'CONTENT'; + break; + case 'TK_TAG_END': + //Print new line only if the tag has no content and has child + if (multi_parser.last_token === 'TK_CONTENT' && multi_parser.last_text === '') { + var tag_name = multi_parser.token_text.match(/\w+/)[0]; + var tag_extracted_from_last_output = null; + if (multi_parser.output.length) { + tag_extracted_from_last_output = multi_parser.output[multi_parser.output.length - 1].match(/(?:<|{{#)\s*(\w+)/); + } + if (tag_extracted_from_last_output === null || + tag_extracted_from_last_output[1] !== tag_name) { + multi_parser.print_newline(false, multi_parser.output); + } + } + multi_parser.print_token(multi_parser.token_text); + multi_parser.current_mode = 'CONTENT'; + break; + case 'TK_TAG_SINGLE': + // Don't add a newline before elements that should remain unformatted. + var tag_check = multi_parser.token_text.match(/^\s*<([a-z]+)/i); + if (!tag_check || !multi_parser.Utils.in_array(tag_check[1], unformatted)) { + multi_parser.print_newline(false, multi_parser.output); + } + multi_parser.print_token(multi_parser.token_text); + multi_parser.current_mode = 'CONTENT'; + break; + case 'TK_TAG_HANDLEBARS_ELSE': + multi_parser.print_token(multi_parser.token_text); + if (multi_parser.indent_content) { + multi_parser.indent(); + multi_parser.indent_content = false; + } + multi_parser.current_mode = 'CONTENT'; + break; + case 'TK_CONTENT': + multi_parser.print_token(multi_parser.token_text); + multi_parser.current_mode = 'TAG'; + break; + case 'TK_STYLE': + case 'TK_SCRIPT': + if (multi_parser.token_text !== '') { + multi_parser.print_newline(false, multi_parser.output); + var text = multi_parser.token_text, + _beautifier, + script_indent_level = 1; + if (multi_parser.token_type === 'TK_SCRIPT') { + _beautifier = typeof js_beautify === 'function' && js_beautify; + } else if (multi_parser.token_type === 'TK_STYLE') { + _beautifier = typeof css_beautify === 'function' && css_beautify; + } + + if (options.indent_scripts === "keep") { + script_indent_level = 0; + } else if (options.indent_scripts === "separate") { + script_indent_level = -multi_parser.indent_level; + } + + var indentation = multi_parser.get_full_indent(script_indent_level); + if (_beautifier) { + // call the Beautifier if avaliable + text = _beautifier(text.replace(/^\s*/, indentation), options); + } else { + // simply indent the string otherwise + var white = text.match(/^\s*/)[0]; + var _level = white.match(/[^\n\r]*$/)[0].split(multi_parser.indent_string).length - 1; + var reindent = multi_parser.get_full_indent(script_indent_level - _level); + text = text.replace(/^\s*/, indentation) + .replace(/\r\n|\r|\n/g, '\n' + reindent) + .replace(/\s+$/, ''); + } + if (text) { + multi_parser.print_token_raw(indentation + trim(text)); + multi_parser.print_newline(false, multi_parser.output); + } + } + multi_parser.current_mode = 'TAG'; + break; + } + multi_parser.last_token = multi_parser.token_type; + multi_parser.last_text = multi_parser.token_text; + } + return multi_parser.output.join(''); + } + + var beautify = require('devtools/shared/jsbeautify/beautify'); + + exports.htmlBeautify = function(html_source, options) { + return style_html(html_source, options, beautify.js, beautify.css); + }; +}()); diff --git a/devtools/shared/jsbeautify/src/beautify-js.js b/devtools/shared/jsbeautify/src/beautify-js.js new file mode 100644 index 000000000..053d973e0 --- /dev/null +++ b/devtools/shared/jsbeautify/src/beautify-js.js @@ -0,0 +1,1662 @@ +/*jshint curly:true, eqeqeq:true, laxbreak:true, noempty:false */ + +"use strict"; + +const acorn = require("acorn/acorn"); + +/* + + The MIT License (MIT) + + Copyright (c) 2007-2013 Einar Lielmanis and contributors. + + Permission is hereby granted, free of charge, to any person + obtaining a copy of this software and associated documentation files + (the "Software"), to deal in the Software without restriction, + including without limitation the rights to use, copy, modify, merge, + publish, distribute, sublicense, and/or sell copies of the Software, + and to permit persons to whom the Software is furnished to do so, + subject to the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. + + JS Beautifier +--------------- + + + Written by Einar Lielmanis, <einar@jsbeautifier.org> + http://jsbeautifier.org/ + + Originally converted to javascript by Vital, <vital76@gmail.com> + "End braces on own line" added by Chris J. Shull, <chrisjshull@gmail.com> + Parsing improvements for brace-less statements by Liam Newman <bitwiseman@gmail.com> + + + Usage: + js_beautify(js_source_text); + js_beautify(js_source_text, options); + + The options are: + indent_size (default 4) - indentation size, + indent_char (default space) - character to indent with, + preserve_newlines (default true) - whether existing line breaks should be preserved, + max_preserve_newlines (default unlimited) - maximum number of line breaks to be preserved in one chunk, + + jslint_happy (default false) - if true, then jslint-stricter mode is enforced. + + jslint_happy !jslint_happy + --------------------------------- + function () function() + + brace_style (default "collapse") - "collapse" | "expand" | "end-expand" + put braces on the same line as control statements (default), or put braces on own line (Allman / ANSI style), or just put end braces on own line. + + space_before_conditional (default true) - should the space before conditional statement be added, "if(true)" vs "if (true)", + + unescape_strings (default false) - should printable characters in strings encoded in \xNN notation be unescaped, "example" vs "\x65\x78\x61\x6d\x70\x6c\x65" + + wrap_line_length (default unlimited) - lines should wrap at next opportunity after this number of characters. + NOTE: This is not a hard limit. Lines will continue until a point where a newline would + be preserved if it were present. + + e.g + + js_beautify(js_source_text, { + 'indent_size': 1, + 'indent_char': '\t' + }); + +*/ + +var js_beautify = function js_beautify(js_source_text, options) { + var beautifier = new Beautifier(js_source_text, options); + return beautifier.beautify(); +}; + +exports.jsBeautify = js_beautify; + +function Beautifier(js_source_text, options) { + var input, output_lines; + var token_text, token_type, last_type, last_last_text, indent_string; + var flags, previous_flags, flag_store; + var whitespace, wordchar, punct, parser_pos, line_starters, reserved_words, digits; + var prefix; + var input_wanted_newline; + var output_space_before_token; + var input_length, n_newlines, whitespace_before_token; + var handlers, MODE, opt; + var preindent_string = ''; + + + + whitespace = "\n\r\t ".split(''); + wordchar = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_$'.split(''); + digits = '0123456789'.split(''); + + punct = '+ - * / % & ++ -- = += -= *= /= %= == === != !== > < >= <= >> << >>> >>>= >>= <<= && &= | || ! ~ , : ? ^ ^= |= :: =>'; + punct += ' <%= <% %> <?= <? ?>'; // try to be a good boy and try not to break the markup language identifiers + punct = punct.split(' '); + + // words which should always start on new line. + line_starters = 'continue,try,throw,return,var,let,const,if,switch,case,default,for,while,break,function,yield'.split(','); + reserved_words = line_starters.concat(['do', 'in', 'else', 'get', 'set', 'new', 'catch', 'finally', 'typeof']); + + + MODE = { + BlockStatement: 'BlockStatement', // 'BLOCK' + Statement: 'Statement', // 'STATEMENT' + ObjectLiteral: 'ObjectLiteral', // 'OBJECT', + ArrayLiteral: 'ArrayLiteral', //'[EXPRESSION]', + ForInitializer: 'ForInitializer', //'(FOR-EXPRESSION)', + Conditional: 'Conditional', //'(COND-EXPRESSION)', + Expression: 'Expression' //'(EXPRESSION)' + }; + + handlers = { + 'TK_START_EXPR': handle_start_expr, + 'TK_END_EXPR': handle_end_expr, + 'TK_START_BLOCK': handle_start_block, + 'TK_END_BLOCK': handle_end_block, + 'TK_WORD': handle_word, + 'TK_RESERVED': handle_word, + 'TK_SEMICOLON': handle_semicolon, + 'TK_STRING': handle_string, + 'TK_EQUALS': handle_equals, + 'TK_OPERATOR': handle_operator, + 'TK_COMMA': handle_comma, + 'TK_BLOCK_COMMENT': handle_block_comment, + 'TK_INLINE_COMMENT': handle_inline_comment, + 'TK_COMMENT': handle_comment, + 'TK_DOT': handle_dot, + 'TK_UNKNOWN': handle_unknown + }; + + function create_flags(flags_base, mode) { + var next_indent_level = 0; + if (flags_base) { + next_indent_level = flags_base.indentation_level; + if (!just_added_newline() && + flags_base.line_indent_level > next_indent_level) { + next_indent_level = flags_base.line_indent_level; + } + } + + var next_flags = { + mode: mode, + parent: flags_base, + last_text: flags_base ? flags_base.last_text : '', // last token text + last_word: flags_base ? flags_base.last_word : '', // last 'TK_WORD' passed + declaration_statement: false, + declaration_assignment: false, + in_html_comment: false, + multiline_frame: false, + if_block: false, + else_block: false, + do_block: false, + do_while: false, + in_case_statement: false, // switch(..){ INSIDE HERE } + in_case: false, // we're on the exact line with "case 0:" + case_body: false, // the indented case-action block + indentation_level: next_indent_level, + line_indent_level: flags_base ? flags_base.line_indent_level : next_indent_level, + start_line_index: output_lines.length, + had_comment: false, + ternary_depth: 0 + }; + return next_flags; + } + + // Using object instead of string to allow for later expansion of info about each line + + function create_output_line() { + return { + text: [] + }; + } + + // Some interpreters have unexpected results with foo = baz || bar; + options = options ? options : {}; + opt = {}; + + // compatibility + if (options.space_after_anon_function !== undefined && options.jslint_happy === undefined) { + options.jslint_happy = options.space_after_anon_function; + } + if (options.braces_on_own_line !== undefined) { //graceful handling of deprecated option + opt.brace_style = options.braces_on_own_line ? "expand" : "collapse"; + } + opt.brace_style = options.brace_style ? options.brace_style : (opt.brace_style ? opt.brace_style : "collapse"); + + // graceful handling of deprecated option + if (opt.brace_style === "expand-strict") { + opt.brace_style = "expand"; + } + + + opt.indent_size = options.indent_size ? parseInt(options.indent_size, 10) : 4; + opt.indent_char = options.indent_char ? options.indent_char : ' '; + opt.preserve_newlines = (options.preserve_newlines === undefined) ? true : options.preserve_newlines; + opt.break_chained_methods = (options.break_chained_methods === undefined) ? false : options.break_chained_methods; + opt.max_preserve_newlines = (options.max_preserve_newlines === undefined) ? 0 : parseInt(options.max_preserve_newlines, 10); + opt.space_in_paren = (options.space_in_paren === undefined) ? false : options.space_in_paren; + opt.space_in_empty_paren = (options.space_in_empty_paren === undefined) ? false : options.space_in_empty_paren; + opt.jslint_happy = (options.jslint_happy === undefined) ? false : options.jslint_happy; + opt.keep_array_indentation = (options.keep_array_indentation === undefined) ? false : options.keep_array_indentation; + opt.space_before_conditional = (options.space_before_conditional === undefined) ? true : options.space_before_conditional; + opt.unescape_strings = (options.unescape_strings === undefined) ? false : options.unescape_strings; + opt.wrap_line_length = (options.wrap_line_length === undefined) ? 0 : parseInt(options.wrap_line_length, 10); + opt.e4x = (options.e4x === undefined) ? false : options.e4x; + + if(options.indent_with_tabs){ + opt.indent_char = '\t'; + opt.indent_size = 1; + } + + //---------------------------------- + indent_string = ''; + while (opt.indent_size > 0) { + indent_string += opt.indent_char; + opt.indent_size -= 1; + } + + while (js_source_text && (js_source_text.charAt(0) === ' ' || js_source_text.charAt(0) === '\t')) { + preindent_string += js_source_text.charAt(0); + js_source_text = js_source_text.substring(1); + } + input = js_source_text; + // cache the source's length. + input_length = js_source_text.length; + + last_type = 'TK_START_BLOCK'; // last token type + last_last_text = ''; // pre-last token text + output_lines = [create_output_line()]; + output_space_before_token = false; + whitespace_before_token = []; + + // Stack of parsing/formatting states, including MODE. + // We tokenize, parse, and output in an almost purely a forward-only stream of token input + // and formatted output. This makes the beautifier less accurate than full parsers + // but also far more tolerant of syntax errors. + // + // For example, the default mode is MODE.BlockStatement. If we see a '{' we push a new frame of type + // MODE.BlockStatement on the the stack, even though it could be object literal. If we later + // encounter a ":", we'll switch to to MODE.ObjectLiteral. If we then see a ";", + // most full parsers would die, but the beautifier gracefully falls back to + // MODE.BlockStatement and continues on. + flag_store = []; + set_mode(MODE.BlockStatement); + + parser_pos = 0; + + this.beautify = function() { + /*jshint onevar:true */ + var t, i, keep_whitespace, sweet_code; + + while (true) { + t = get_next_token(); + token_text = t[0]; + token_type = t[1]; + + if (token_type === 'TK_EOF') { + // Unwind any open statements + while (flags.mode === MODE.Statement) { + restore_mode(); + } + break; + } + + keep_whitespace = opt.keep_array_indentation && is_array(flags.mode); + input_wanted_newline = n_newlines > 0; + + if (keep_whitespace) { + for (i = 0; i < n_newlines; i += 1) { + print_newline(i > 0); + } + } else { + if (opt.max_preserve_newlines && n_newlines > opt.max_preserve_newlines) { + n_newlines = opt.max_preserve_newlines; + } + + if (opt.preserve_newlines) { + if (n_newlines > 1) { + print_newline(); + for (i = 1; i < n_newlines; i += 1) { + print_newline(true); + } + } + } + } + + handlers[token_type](); + + // The cleanest handling of inline comments is to treat them as though they aren't there. + // Just continue formatting and the behavior should be logical. + // Also ignore unknown tokens. Again, this should result in better behavior. + if (token_type !== 'TK_INLINE_COMMENT' && token_type !== 'TK_COMMENT' && + token_type !== 'TK_BLOCK_COMMENT' && token_type !== 'TK_UNKNOWN') { + last_last_text = flags.last_text; + last_type = token_type; + flags.last_text = token_text; + } + flags.had_comment = (token_type === 'TK_INLINE_COMMENT' || token_type === 'TK_COMMENT' + || token_type === 'TK_BLOCK_COMMENT'); + } + + + sweet_code = output_lines[0].text.join(''); + for (var line_index = 1; line_index < output_lines.length; line_index++) { + sweet_code += '\n' + output_lines[line_index].text.join(''); + } + sweet_code = sweet_code.replace(/[\r\n ]+$/, ''); + return sweet_code; + }; + + function trim_output(eat_newlines) { + eat_newlines = (eat_newlines === undefined) ? false : eat_newlines; + + if (output_lines.length) { + trim_output_line(output_lines[output_lines.length - 1], eat_newlines); + + while (eat_newlines && output_lines.length > 1 && + output_lines[output_lines.length - 1].text.length === 0) { + output_lines.pop(); + trim_output_line(output_lines[output_lines.length - 1], eat_newlines); + } + } + } + + function trim_output_line(line) { + while (line.text.length && + (line.text[line.text.length - 1] === ' ' || + line.text[line.text.length - 1] === indent_string || + line.text[line.text.length - 1] === preindent_string)) { + line.text.pop(); + } + } + + function trim(s) { + return s.replace(/^\s+|\s+$/g, ''); + } + + // we could use just string.split, but + // IE doesn't like returning empty strings + + function split_newlines(s) { + //return s.split(/\x0d\x0a|\x0a/); + + s = s.replace(/\x0d/g, ''); + var out = [], + idx = s.indexOf("\n"); + while (idx !== -1) { + out.push(s.substring(0, idx)); + s = s.substring(idx + 1); + idx = s.indexOf("\n"); + } + if (s.length) { + out.push(s); + } + return out; + } + + function just_added_newline() { + var line = output_lines[output_lines.length - 1]; + return line.text.length === 0; + } + + function just_added_blankline() { + if (just_added_newline()) { + if (output_lines.length === 1) { + return true; // start of the file and newline = blank + } + + var line = output_lines[output_lines.length - 2]; + return line.text.length === 0; + } + return false; + } + + function allow_wrap_or_preserved_newline(force_linewrap) { + force_linewrap = (force_linewrap === undefined) ? false : force_linewrap; + if (opt.wrap_line_length && !force_linewrap) { + var line = output_lines[output_lines.length - 1]; + var proposed_line_length = 0; + // never wrap the first token of a line. + if (line.text.length > 0) { + proposed_line_length = line.text.join('').length + token_text.length + + (output_space_before_token ? 1 : 0); + if (proposed_line_length >= opt.wrap_line_length) { + force_linewrap = true; + } + } + } + if (((opt.preserve_newlines && input_wanted_newline) || force_linewrap) && !just_added_newline()) { + print_newline(false, true); + + } + } + + function print_newline(force_newline, preserve_statement_flags) { + output_space_before_token = false; + + if (!preserve_statement_flags) { + if (flags.last_text !== ';' && flags.last_text !== ',' && flags.last_text !== '=' && last_type !== 'TK_OPERATOR') { + while (flags.mode === MODE.Statement && !flags.if_block && !flags.do_block) { + restore_mode(); + } + } + } + + if (output_lines.length === 1 && just_added_newline()) { + return; // no newline on start of file + } + + if (force_newline || !just_added_newline()) { + flags.multiline_frame = true; + output_lines.push(create_output_line()); + } + } + + function print_token_line_indentation() { + if (just_added_newline()) { + var line = output_lines[output_lines.length - 1]; + if (opt.keep_array_indentation && is_array(flags.mode) && input_wanted_newline) { + // prevent removing of this whitespace as redundant + line.text.push(''); + for (var i = 0; i < whitespace_before_token.length; i += 1) { + line.text.push(whitespace_before_token[i]); + } + } else { + if (preindent_string) { + line.text.push(preindent_string); + } + + print_indent_string(flags.indentation_level); + } + } + } + + function print_indent_string(level) { + // Never indent your first output indent at the start of the file + if (output_lines.length > 1) { + var line = output_lines[output_lines.length - 1]; + + flags.line_indent_level = level; + for (var i = 0; i < level; i += 1) { + line.text.push(indent_string); + } + } + } + + function print_token_space_before() { + var line = output_lines[output_lines.length - 1]; + if (output_space_before_token && line.text.length) { + var last_output = line.text[line.text.length - 1]; + if (last_output !== ' ' && last_output !== indent_string) { // prevent occassional duplicate space + line.text.push(' '); + } + } + } + + function print_token(printable_token) { + printable_token = printable_token || token_text; + print_token_line_indentation(); + print_token_space_before(); + output_space_before_token = false; + output_lines[output_lines.length - 1].text.push(printable_token); + } + + function indent() { + flags.indentation_level += 1; + } + + function deindent() { + if (flags.indentation_level > 0 && + ((!flags.parent) || flags.indentation_level > flags.parent.indentation_level)) + flags.indentation_level -= 1; + } + + function remove_redundant_indentation(frame) { + // This implementation is effective but has some issues: + // - less than great performance due to array splicing + // - can cause line wrap to happen too soon due to indent removal + // after wrap points are calculated + // These issues are minor compared to ugly indentation. + + if (frame.multiline_frame) return; + + // remove one indent from each line inside this section + var index = frame.start_line_index; + var splice_index = 0; + var line; + + while (index < output_lines.length) { + line = output_lines[index]; + index++; + + // skip empty lines + if (line.text.length === 0) { + continue; + } + + // skip the preindent string if present + if (preindent_string && line.text[0] === preindent_string) { + splice_index = 1; + } else { + splice_index = 0; + } + + // remove one indent, if present + if (line.text[splice_index] === indent_string) { + line.text.splice(splice_index, 1); + } + } + } + + function set_mode(mode) { + if (flags) { + flag_store.push(flags); + previous_flags = flags; + } else { + previous_flags = create_flags(null, mode); + } + + flags = create_flags(previous_flags, mode); + } + + function is_array(mode) { + return mode === MODE.ArrayLiteral; + } + + function is_expression(mode) { + return in_array(mode, [MODE.Expression, MODE.ForInitializer, MODE.Conditional]); + } + + function restore_mode() { + if (flag_store.length > 0) { + previous_flags = flags; + flags = flag_store.pop(); + if (previous_flags.mode === MODE.Statement) { + remove_redundant_indentation(previous_flags); + } + } + } + + function start_of_object_property() { + return flags.parent.mode === MODE.ObjectLiteral && flags.mode === MODE.Statement && flags.last_text === ':' && + flags.ternary_depth === 0; + } + + function start_of_statement() { + if ( + (last_type === 'TK_RESERVED' && in_array(flags.last_text, ['var', 'let', 'const']) && token_type === 'TK_WORD') || + (last_type === 'TK_RESERVED' && flags.last_text === 'do') || + (last_type === 'TK_RESERVED' && flags.last_text === 'return' && !input_wanted_newline) || + (last_type === 'TK_RESERVED' && flags.last_text === 'else' && !(token_type === 'TK_RESERVED' && token_text === 'if')) || + (last_type === 'TK_END_EXPR' && (previous_flags.mode === MODE.ForInitializer || previous_flags.mode === MODE.Conditional)) || + (last_type === 'TK_WORD' && flags.mode === MODE.BlockStatement + && !flags.in_case + && !(token_text === '--' || token_text === '++') + && token_type !== 'TK_WORD' && token_type !== 'TK_RESERVED') || + (flags.mode === MODE.ObjectLiteral && flags.last_text === ':' && flags.ternary_depth === 0) + + ) { + + set_mode(MODE.Statement); + indent(); + + if (last_type === 'TK_RESERVED' && in_array(flags.last_text, ['var', 'let', 'const']) && token_type === 'TK_WORD') { + flags.declaration_statement = true; + } + + // Issue #276: + // If starting a new statement with [if, for, while, do], push to a new line. + // if (a) if (b) if(c) d(); else e(); else f(); + if (!start_of_object_property()) { + allow_wrap_or_preserved_newline( + token_type === 'TK_RESERVED' && in_array(token_text, ['do', 'for', 'if', 'while'])); + } + + return true; + } + return false; + } + + function all_lines_start_with(lines, c) { + for (var i = 0; i < lines.length; i++) { + var line = trim(lines[i]); + if (line.charAt(0) !== c) { + return false; + } + } + return true; + } + + function each_line_matches_indent(lines, indent) { + var i = 0, + len = lines.length, + line; + for (; i < len; i++) { + line = lines[i]; + // allow empty lines to pass through + if (line && line.indexOf(indent) !== 0) { + return false; + } + } + return true; + } + + function is_special_word(word) { + return in_array(word, ['case', 'return', 'do', 'if', 'throw', 'else']); + } + + function in_array(what, arr) { + for (var i = 0; i < arr.length; i += 1) { + if (arr[i] === what) { + return true; + } + } + return false; + } + + function unescape_string(s) { + var esc = false, + out = '', + pos = 0, + s_hex = '', + escaped = 0, + c; + + while (esc || pos < s.length) { + + c = s.charAt(pos); + pos++; + + if (esc) { + esc = false; + if (c === 'x') { + // simple hex-escape \x24 + s_hex = s.substr(pos, 2); + pos += 2; + } else if (c === 'u') { + // unicode-escape, \u2134 + s_hex = s.substr(pos, 4); + pos += 4; + } else { + // some common escape, e.g \n + out += '\\' + c; + continue; + } + if (!s_hex.match(/^[0123456789abcdefABCDEF]+$/)) { + // some weird escaping, bail out, + // leaving whole string intact + return s; + } + + escaped = parseInt(s_hex, 16); + + if (escaped >= 0x00 && escaped < 0x20) { + // leave 0x00...0x1f escaped + if (c === 'x') { + out += '\\x' + s_hex; + } else { + out += '\\u' + s_hex; + } + continue; + } else if (escaped === 0x22 || escaped === 0x27 || escaped === 0x5c) { + // single-quote, apostrophe, backslash - escape these + out += '\\' + String.fromCharCode(escaped); + } else if (c === 'x' && escaped > 0x7e && escaped <= 0xff) { + // we bail out on \x7f..\xff, + // leaving whole string escaped, + // as it's probably completely binary + return s; + } else { + out += String.fromCharCode(escaped); + } + } else if (c === '\\') { + esc = true; + } else { + out += c; + } + } + return out; + } + + function is_next(find) { + var local_pos = parser_pos; + var c = input.charAt(local_pos); + while (in_array(c, whitespace) && c !== find) { + local_pos++; + if (local_pos >= input_length) { + return false; + } + c = input.charAt(local_pos); + } + return c === find; + } + + function get_next_token() { + var i, resulting_string; + + n_newlines = 0; + + if (parser_pos >= input_length) { + return ['', 'TK_EOF']; + } + + input_wanted_newline = false; + whitespace_before_token = []; + + var c = input.charAt(parser_pos); + parser_pos += 1; + + while (in_array(c, whitespace)) { + + if (c === '\n') { + n_newlines += 1; + whitespace_before_token = []; + } else if (n_newlines) { + if (c === indent_string) { + whitespace_before_token.push(indent_string); + } else if (c !== '\r') { + whitespace_before_token.push(' '); + } + } + + if (parser_pos >= input_length) { + return ['', 'TK_EOF']; + } + + c = input.charAt(parser_pos); + parser_pos += 1; + } + + // NOTE: because beautifier doesn't fully parse, it doesn't use acorn.isIdentifierStart. + // It just treats all identifiers and numbers and such the same. + if (acorn.isIdentifierChar(input.charCodeAt(parser_pos-1))) { + if (parser_pos < input_length) { + while (acorn.isIdentifierChar(input.charCodeAt(parser_pos))) { + c += input.charAt(parser_pos); + parser_pos += 1; + if (parser_pos === input_length) { + break; + } + } + } + + // small and surprisingly unugly hack for 1E-10 representation + if (parser_pos !== input_length && c.match(/^[0-9]+[Ee]$/) && (input.charAt(parser_pos) === '-' || input.charAt(parser_pos) === '+')) { + + var sign = input.charAt(parser_pos); + parser_pos += 1; + + var t = get_next_token(); + c += sign + t[0]; + return [c, 'TK_WORD']; + } + + if (!(last_type === 'TK_DOT' || + (last_type === 'TK_RESERVED' && in_array(flags.last_text, ['set', 'get']))) + && in_array(c, reserved_words)) { + if (c === 'in') { // hack for 'in' operator + return [c, 'TK_OPERATOR']; + } + return [c, 'TK_RESERVED']; + } + return [c, 'TK_WORD']; + } + + if (c === '(' || c === '[') { + return [c, 'TK_START_EXPR']; + } + + if (c === ')' || c === ']') { + return [c, 'TK_END_EXPR']; + } + + if (c === '{') { + return [c, 'TK_START_BLOCK']; + } + + if (c === '}') { + return [c, 'TK_END_BLOCK']; + } + + if (c === ';') { + return [c, 'TK_SEMICOLON']; + } + + if (c === '/') { + var comment = ''; + // peek for comment /* ... */ + var inline_comment = true; + if (input.charAt(parser_pos) === '*') { + parser_pos += 1; + if (parser_pos < input_length) { + while (parser_pos < input_length && !(input.charAt(parser_pos) === '*' && input.charAt(parser_pos + 1) && input.charAt(parser_pos + 1) === '/')) { + c = input.charAt(parser_pos); + comment += c; + if (c === "\n" || c === "\r") { + inline_comment = false; + } + parser_pos += 1; + if (parser_pos >= input_length) { + break; + } + } + } + parser_pos += 2; + if (inline_comment && n_newlines === 0) { + return ['/*' + comment + '*/', 'TK_INLINE_COMMENT']; + } else { + return ['/*' + comment + '*/', 'TK_BLOCK_COMMENT']; + } + } + // peek for comment // ... + if (input.charAt(parser_pos) === '/') { + comment = c; + while (input.charAt(parser_pos) !== '\r' && input.charAt(parser_pos) !== '\n') { + comment += input.charAt(parser_pos); + parser_pos += 1; + if (parser_pos >= input_length) { + break; + } + } + return [comment, 'TK_COMMENT']; + } + + } + + + if (c === '`' || c === "'" || c === '"' || // string + ( + (c === '/') || // regexp + (opt.e4x && c === "<" && input.slice(parser_pos - 1).match(/^<([-a-zA-Z:0-9_.]+|{[^{}]*}|!\[CDATA\[[\s\S]*?\]\])\s*([-a-zA-Z:0-9_.]+=('[^']*'|"[^"]*"|{[^{}]*})\s*)*\/?\s*>/)) // xml + ) && ( // regex and xml can only appear in specific locations during parsing + (last_type === 'TK_RESERVED' && is_special_word(flags.last_text)) || + (last_type === 'TK_END_EXPR' && in_array(previous_flags.mode, [MODE.Conditional, MODE.ForInitializer])) || + (in_array(last_type, ['TK_COMMENT', 'TK_START_EXPR', 'TK_START_BLOCK', + 'TK_END_BLOCK', 'TK_OPERATOR', 'TK_EQUALS', 'TK_EOF', 'TK_SEMICOLON', 'TK_COMMA' + ])) + )) { + + var sep = c, + esc = false, + has_char_escapes = false; + + resulting_string = c; + + if (parser_pos < input_length) { + if (sep === '/') { + // + // handle regexp + // + var in_char_class = false; + while (esc || in_char_class || input.charAt(parser_pos) !== sep) { + resulting_string += input.charAt(parser_pos); + if (!esc) { + esc = input.charAt(parser_pos) === '\\'; + if (input.charAt(parser_pos) === '[') { + in_char_class = true; + } else if (input.charAt(parser_pos) === ']') { + in_char_class = false; + } + } else { + esc = false; + } + parser_pos += 1; + if (parser_pos >= input_length) { + // incomplete string/rexp when end-of-file reached. + // bail out with what had been received so far. + return [resulting_string, 'TK_STRING']; + } + } + } else if (opt.e4x && sep === '<') { + // + // handle e4x xml literals + // + var xmlRegExp = /<(\/?)([-a-zA-Z:0-9_.]+|{[^{}]*}|!\[CDATA\[[\s\S]*?\]\])\s*([-a-zA-Z:0-9_.]+=('[^']*'|"[^"]*"|{[^{}]*})\s*)*(\/?)\s*>/g; + var xmlStr = input.slice(parser_pos - 1); + var match = xmlRegExp.exec(xmlStr); + if (match && match.index === 0) { + var rootTag = match[2]; + var depth = 0; + while (match) { + var isEndTag = !! match[1]; + var tagName = match[2]; + var isSingletonTag = ( !! match[match.length - 1]) || (tagName.slice(0, 8) === "![CDATA["); + if (tagName === rootTag && !isSingletonTag) { + if (isEndTag) { + --depth; + } else { + ++depth; + } + } + if (depth <= 0) { + break; + } + match = xmlRegExp.exec(xmlStr); + } + var xmlLength = match ? match.index + match[0].length : xmlStr.length; + parser_pos += xmlLength - 1; + return [xmlStr.slice(0, xmlLength), "TK_STRING"]; + } + } else { + // + // handle string + // + while (esc || input.charAt(parser_pos) !== sep) { + resulting_string += input.charAt(parser_pos); + if (esc) { + if (input.charAt(parser_pos) === 'x' || input.charAt(parser_pos) === 'u') { + has_char_escapes = true; + } + esc = false; + } else { + esc = input.charAt(parser_pos) === '\\'; + } + parser_pos += 1; + if (parser_pos >= input_length) { + // incomplete string/rexp when end-of-file reached. + // bail out with what had been received so far. + return [resulting_string, 'TK_STRING']; + } + } + + } + } + + parser_pos += 1; + resulting_string += sep; + + if (has_char_escapes && opt.unescape_strings) { + resulting_string = unescape_string(resulting_string); + } + + if (sep === '/') { + // regexps may have modifiers /regexp/MOD , so fetch those, too + while (parser_pos < input_length && in_array(input.charAt(parser_pos), wordchar)) { + resulting_string += input.charAt(parser_pos); + parser_pos += 1; + } + } + return [resulting_string, 'TK_STRING']; + } + + if (c === '#') { + + + if (output_lines.length === 1 && output_lines[0].text.length === 0 && + input.charAt(parser_pos) === '!') { + // shebang + resulting_string = c; + while (parser_pos < input_length && c !== '\n') { + c = input.charAt(parser_pos); + resulting_string += c; + parser_pos += 1; + } + return [trim(resulting_string) + '\n', 'TK_UNKNOWN']; + } + + + + // Spidermonkey-specific sharp variables for circular references + // https://developer.mozilla.org/En/Sharp_variables_in_JavaScript + // http://dxr.mozilla.org/mozilla-central/source/js/src/jsscan.cpp around line 1935 + var sharp = '#'; + if (parser_pos < input_length && in_array(input.charAt(parser_pos), digits)) { + do { + c = input.charAt(parser_pos); + sharp += c; + parser_pos += 1; + } while (parser_pos < input_length && c !== '#' && c !== '='); + if (c === '#') { + // + } else if (input.charAt(parser_pos) === '[' && input.charAt(parser_pos + 1) === ']') { + sharp += '[]'; + parser_pos += 2; + } else if (input.charAt(parser_pos) === '{' && input.charAt(parser_pos + 1) === '}') { + sharp += '{}'; + parser_pos += 2; + } + return [sharp, 'TK_WORD']; + } + } + + if (c === '<' && input.substring(parser_pos - 1, parser_pos + 3) === '<!--') { + parser_pos += 3; + c = '<!--'; + while (input.charAt(parser_pos) !== '\n' && parser_pos < input_length) { + c += input.charAt(parser_pos); + parser_pos++; + } + flags.in_html_comment = true; + return [c, 'TK_COMMENT']; + } + + if (c === '-' && flags.in_html_comment && input.substring(parser_pos - 1, parser_pos + 2) === '-->') { + flags.in_html_comment = false; + parser_pos += 2; + return ['-->', 'TK_COMMENT']; + } + + if (c === '.') { + return [c, 'TK_DOT']; + } + + if (in_array(c, punct)) { + while (parser_pos < input_length && in_array(c + input.charAt(parser_pos), punct)) { + c += input.charAt(parser_pos); + parser_pos += 1; + if (parser_pos >= input_length) { + break; + } + } + + if (c === ',') { + return [c, 'TK_COMMA']; + } else if (c === '=') { + return [c, 'TK_EQUALS']; + } else { + return [c, 'TK_OPERATOR']; + } + } + + return [c, 'TK_UNKNOWN']; + } + + function handle_start_expr() { + if (start_of_statement()) { + // The conditional starts the statement if appropriate. + } + + var next_mode = MODE.Expression; + if (token_text === '[') { + + if (last_type === 'TK_WORD' || flags.last_text === ')') { + // this is array index specifier, break immediately + // a[x], fn()[x] + if (last_type === 'TK_RESERVED' && in_array(flags.last_text, line_starters)) { + output_space_before_token = true; + } + set_mode(next_mode); + print_token(); + indent(); + if (opt.space_in_paren) { + output_space_before_token = true; + } + return; + } + + next_mode = MODE.ArrayLiteral; + if (is_array(flags.mode)) { + if (flags.last_text === '[' || + (flags.last_text === ',' && (last_last_text === ']' || last_last_text === '}'))) { + // ], [ goes to new line + // }, [ goes to new line + if (!opt.keep_array_indentation) { + print_newline(); + } + } + } + + } else { + if (last_type === 'TK_RESERVED' && flags.last_text === 'for') { + next_mode = MODE.ForInitializer; + } else if (last_type === 'TK_RESERVED' && in_array(flags.last_text, ['if', 'while'])) { + next_mode = MODE.Conditional; + } else { + // next_mode = MODE.Expression; + } + } + + if (flags.last_text === ';' || last_type === 'TK_START_BLOCK') { + print_newline(); + } else if (last_type === 'TK_END_EXPR' || last_type === 'TK_START_EXPR' || last_type === 'TK_END_BLOCK' || flags.last_text === '.') { + // TODO: Consider whether forcing this is required. Review failing tests when removed. + allow_wrap_or_preserved_newline(input_wanted_newline); + // do nothing on (( and )( and ][ and ]( and .( + } else if (!(last_type === 'TK_RESERVED' && token_text === '(') && last_type !== 'TK_WORD' && last_type !== 'TK_OPERATOR') { + output_space_before_token = true; + } else if ((last_type === 'TK_RESERVED' && (flags.last_word === 'function' || flags.last_word === 'typeof')) || + (flags.last_text === '*' && last_last_text === 'function')) { + // function() vs function () + if (opt.jslint_happy) { + output_space_before_token = true; + } + } else if (last_type === 'TK_RESERVED' && (in_array(flags.last_text, line_starters) || flags.last_text === 'catch')) { + if (opt.space_before_conditional) { + output_space_before_token = true; + } + } + + // Support of this kind of newline preservation. + // a = (b && + // (c || d)); + if (token_text === '(') { + if (last_type === 'TK_EQUALS' || last_type === 'TK_OPERATOR') { + if (!start_of_object_property()) { + allow_wrap_or_preserved_newline(); + } + } + } + + set_mode(next_mode); + print_token(); + if (opt.space_in_paren) { + output_space_before_token = true; + } + + // In all cases, if we newline while inside an expression it should be indented. + indent(); + } + + function handle_end_expr() { + // statements inside expressions are not valid syntax, but... + // statements must all be closed when their container closes + while (flags.mode === MODE.Statement) { + restore_mode(); + } + + if (flags.multiline_frame) { + allow_wrap_or_preserved_newline(token_text === ']' && is_array(flags.mode) && !opt.keep_array_indentation); + } + + if (opt.space_in_paren) { + if (last_type === 'TK_START_EXPR' && ! opt.space_in_empty_paren) { + // () [] no inner space in empty parens like these, ever, ref #320 + trim_output(); + output_space_before_token = false; + } else { + output_space_before_token = true; + } + } + if (token_text === ']' && opt.keep_array_indentation) { + print_token(); + restore_mode(); + } else { + restore_mode(); + print_token(); + } + remove_redundant_indentation(previous_flags); + + // do {} while () // no statement required after + if (flags.do_while && previous_flags.mode === MODE.Conditional) { + previous_flags.mode = MODE.Expression; + flags.do_block = false; + flags.do_while = false; + + } + } + + function handle_start_block() { + set_mode(MODE.BlockStatement); + + var empty_braces = is_next('}'); + var empty_anonymous_function = empty_braces && flags.last_word === 'function' && + last_type === 'TK_END_EXPR'; + + if (opt.brace_style === "expand") { + if (last_type !== 'TK_OPERATOR' && + (empty_anonymous_function || + last_type === 'TK_EQUALS' || + (last_type === 'TK_RESERVED' && is_special_word(flags.last_text) && flags.last_text !== 'else'))) { + output_space_before_token = true; + } else { + print_newline(false, true); + } + } else { // collapse + if (last_type !== 'TK_OPERATOR' && last_type !== 'TK_START_EXPR') { + if (last_type === 'TK_START_BLOCK') { + print_newline(); + } else { + output_space_before_token = true; + } + } else { + // if TK_OPERATOR or TK_START_EXPR + if (is_array(previous_flags.mode) && flags.last_text === ',') { + if (last_last_text === '}') { + // }, { in array context + output_space_before_token = true; + } else { + print_newline(); // [a, b, c, { + } + } + } + } + print_token(); + indent(); + } + + function handle_end_block() { + // statements must all be closed when their container closes + while (flags.mode === MODE.Statement) { + restore_mode(); + } + var empty_braces = last_type === 'TK_START_BLOCK'; + + if (opt.brace_style === "expand") { + if (!empty_braces) { + print_newline(); + } + } else { + // skip {} + if (!empty_braces) { + if (is_array(flags.mode) && opt.keep_array_indentation) { + // we REALLY need a newline here, but newliner would skip that + opt.keep_array_indentation = false; + print_newline(); + opt.keep_array_indentation = true; + + } else { + print_newline(); + } + } + } + restore_mode(); + print_token(); + } + + function handle_word() { + if (start_of_statement()) { + // The conditional starts the statement if appropriate. + } else if (input_wanted_newline && !is_expression(flags.mode) && + (last_type !== 'TK_OPERATOR' || (flags.last_text === '--' || flags.last_text === '++')) && + last_type !== 'TK_EQUALS' && + (opt.preserve_newlines || !(last_type === 'TK_RESERVED' && in_array(flags.last_text, ['var', 'let', 'const', 'set', 'get'])))) { + + print_newline(); + } + + if (flags.do_block && !flags.do_while) { + if (token_type === 'TK_RESERVED' && token_text === 'while') { + // do {} ## while () + output_space_before_token = true; + print_token(); + output_space_before_token = true; + flags.do_while = true; + return; + } else { + // do {} should always have while as the next word. + // if we don't see the expected while, recover + print_newline(); + flags.do_block = false; + } + } + + // if may be followed by else, or not + // Bare/inline ifs are tricky + // Need to unwind the modes correctly: if (a) if (b) c(); else d(); else e(); + if (flags.if_block) { + if (!flags.else_block && (token_type === 'TK_RESERVED' && token_text === 'else')) { + flags.else_block = true; + } else { + while (flags.mode === MODE.Statement) { + restore_mode(); + } + flags.if_block = false; + flags.else_block = false; + } + } + + if (token_type === 'TK_RESERVED' && (token_text === 'case' || (token_text === 'default' && flags.in_case_statement))) { + print_newline(); + if (flags.case_body || opt.jslint_happy) { + // switch cases following one another + deindent(); + flags.case_body = false; + } + print_token(); + flags.in_case = true; + flags.in_case_statement = true; + return; + } + + if (token_type === 'TK_RESERVED' && token_text === 'function') { + if (in_array(flags.last_text, ['}', ';']) || (just_added_newline() && ! in_array(flags.last_text, ['{', ':', '=', ',']))) { + // make sure there is a nice clean space of at least one blank line + // before a new function definition + if ( ! just_added_blankline() && ! flags.had_comment) { + print_newline(); + print_newline(true); + } + } + if (last_type === 'TK_RESERVED' || last_type === 'TK_WORD') { + if (last_type === 'TK_RESERVED' && in_array(flags.last_text, ['get', 'set', 'new', 'return'])) { + output_space_before_token = true; + } else { + print_newline(); + } + } else if (last_type === 'TK_OPERATOR' || flags.last_text === '=') { + // foo = function + output_space_before_token = true; + } else if (is_expression(flags.mode)) { + // (function + } else { + print_newline(); + } + } + + if (last_type === 'TK_COMMA' || last_type === 'TK_START_EXPR' || last_type === 'TK_EQUALS' || last_type === 'TK_OPERATOR') { + if (!start_of_object_property()) { + allow_wrap_or_preserved_newline(); + } + } + + if (token_type === 'TK_RESERVED' && token_text === 'function') { + print_token(); + flags.last_word = token_text; + return; + } + + prefix = 'NONE'; + + if (last_type === 'TK_END_BLOCK') { + if (!(token_type === 'TK_RESERVED' && in_array(token_text, ['else', 'catch', 'finally']))) { + prefix = 'NEWLINE'; + } else { + if (opt.brace_style === "expand" || opt.brace_style === "end-expand") { + prefix = 'NEWLINE'; + } else { + prefix = 'SPACE'; + output_space_before_token = true; + } + } + } else if (last_type === 'TK_SEMICOLON' && flags.mode === MODE.BlockStatement) { + // TODO: Should this be for STATEMENT as well? + prefix = 'NEWLINE'; + } else if (last_type === 'TK_SEMICOLON' && is_expression(flags.mode)) { + prefix = 'SPACE'; + } else if (last_type === 'TK_STRING') { + prefix = 'NEWLINE'; + } else if (last_type === 'TK_RESERVED' || last_type === 'TK_WORD' || + (flags.last_text === '*' && last_last_text === 'function')) { + prefix = 'SPACE'; + } else if (last_type === 'TK_START_BLOCK') { + prefix = 'NEWLINE'; + } else if (last_type === 'TK_END_EXPR') { + output_space_before_token = true; + prefix = 'NEWLINE'; + } + + if (token_type === 'TK_RESERVED' && in_array(token_text, line_starters) && flags.last_text !== ')') { + if (flags.last_text === 'else') { + prefix = 'SPACE'; + } else { + prefix = 'NEWLINE'; + } + + } + + if (token_type === 'TK_RESERVED' && in_array(token_text, ['else', 'catch', 'finally'])) { + if (last_type !== 'TK_END_BLOCK' || opt.brace_style === "expand" || opt.brace_style === "end-expand") { + print_newline(); + } else { + trim_output(true); + var line = output_lines[output_lines.length - 1]; + // If we trimmed and there's something other than a close block before us + // put a newline back in. Handles '} // comment' scenario. + if (line.text[line.text.length - 1] !== '}') { + print_newline(); + } + output_space_before_token = true; + } + } else if (prefix === 'NEWLINE') { + if (last_type === 'TK_RESERVED' && is_special_word(flags.last_text)) { + // no newline between 'return nnn' + output_space_before_token = true; + } else if (last_type !== 'TK_END_EXPR') { + if ((last_type !== 'TK_START_EXPR' || !(token_type === 'TK_RESERVED' && in_array(token_text, ['var', 'let', 'const']))) && flags.last_text !== ':') { + // no need to force newline on 'var': for (var x = 0...) + if (token_type === 'TK_RESERVED' && token_text === 'if' && flags.last_word === 'else' && flags.last_text !== '{') { + // no newline for } else if { + output_space_before_token = true; + } else { + print_newline(); + } + } + } else if (token_type === 'TK_RESERVED' && in_array(token_text, line_starters) && flags.last_text !== ')') { + print_newline(); + } + } else if (is_array(flags.mode) && flags.last_text === ',' && last_last_text === '}') { + print_newline(); // }, in lists get a newline treatment + } else if (prefix === 'SPACE') { + output_space_before_token = true; + } + print_token(); + flags.last_word = token_text; + + if (token_type === 'TK_RESERVED' && token_text === 'do') { + flags.do_block = true; + } + + if (token_type === 'TK_RESERVED' && token_text === 'if') { + flags.if_block = true; + } + } + + function handle_semicolon() { + if (start_of_statement()) { + // The conditional starts the statement if appropriate. + // Semicolon can be the start (and end) of a statement + output_space_before_token = false; + } + while (flags.mode === MODE.Statement && !flags.if_block && !flags.do_block) { + restore_mode(); + } + print_token(); + if (flags.mode === MODE.ObjectLiteral) { + // if we're in OBJECT mode and see a semicolon, its invalid syntax + // recover back to treating this as a BLOCK + flags.mode = MODE.BlockStatement; + } + } + + function handle_string() { + if (start_of_statement()) { + // The conditional starts the statement if appropriate. + // One difference - strings want at least a space before + output_space_before_token = true; + } else if (last_type === 'TK_RESERVED' || last_type === 'TK_WORD') { + output_space_before_token = true; + } else if (last_type === 'TK_COMMA' || last_type === 'TK_START_EXPR' || last_type === 'TK_EQUALS' || last_type === 'TK_OPERATOR') { + if (!start_of_object_property()) { + allow_wrap_or_preserved_newline(); + } + } else { + print_newline(); + } + print_token(); + } + + function handle_equals() { + if (start_of_statement()) { + // The conditional starts the statement if appropriate. + } + + if (flags.declaration_statement) { + // just got an '=' in a var-line, different formatting/line-breaking, etc will now be done + flags.declaration_assignment = true; + } + output_space_before_token = true; + print_token(); + output_space_before_token = true; + } + + function handle_comma() { + if (flags.declaration_statement) { + if (is_expression(flags.parent.mode)) { + // do not break on comma, for(var a = 1, b = 2) + flags.declaration_assignment = false; + } + + print_token(); + + if (flags.declaration_assignment) { + flags.declaration_assignment = false; + print_newline(false, true); + } else { + output_space_before_token = true; + } + return; + } + + print_token(); + if (flags.mode === MODE.ObjectLiteral || + (flags.mode === MODE.Statement && flags.parent.mode === MODE.ObjectLiteral)) { + if (flags.mode === MODE.Statement) { + restore_mode(); + } + print_newline(); + } else { + // EXPR or DO_BLOCK + output_space_before_token = true; + } + + } + + function handle_operator() { + // Check if this is a BlockStatement that should be treated as a ObjectLiteral + if (token_text === ':' && flags.mode === MODE.BlockStatement && + last_last_text === '{' && + (last_type === 'TK_WORD' || last_type === 'TK_RESERVED')){ + flags.mode = MODE.ObjectLiteral; + } + + if (start_of_statement()) { + // The conditional starts the statement if appropriate. + } + + var space_before = true; + var space_after = true; + if (last_type === 'TK_RESERVED' && is_special_word(flags.last_text)) { + // "return" had a special handling in TK_WORD. Now we need to return the favor + output_space_before_token = true; + print_token(); + return; + } + + // hack for actionscript's import .*; + if (token_text === '*' && last_type === 'TK_DOT' && !last_last_text.match(/^\d+$/)) { + print_token(); + return; + } + + if (token_text === ':' && flags.in_case) { + flags.case_body = true; + indent(); + print_token(); + print_newline(); + flags.in_case = false; + return; + } + + if (token_text === '::') { + // no spaces around exotic namespacing syntax operator + print_token(); + return; + } + + // http://www.ecma-international.org/ecma-262/5.1/#sec-7.9.1 + // if there is a newline between -- or ++ and anything else we should preserve it. + if (input_wanted_newline && (token_text === '--' || token_text === '++')) { + print_newline(); + } + + // Allow line wrapping between operators + if (last_type === 'TK_OPERATOR') { + allow_wrap_or_preserved_newline(); + } + + if (in_array(token_text, ['--', '++', '!', '~']) || (in_array(token_text, ['-', '+']) && (in_array(last_type, ['TK_START_BLOCK', 'TK_START_EXPR', 'TK_EQUALS', 'TK_OPERATOR']) || in_array(flags.last_text, line_starters) || flags.last_text === ','))) { + // unary operators (and binary +/- pretending to be unary) special cases + + space_before = false; + space_after = false; + + if (flags.last_text === ';' && is_expression(flags.mode)) { + // for (;; ++i) + // ^^^ + space_before = true; + } + + if (last_type === 'TK_RESERVED') { + space_before = true; + } + + if ((flags.mode === MODE.BlockStatement || flags.mode === MODE.Statement) && (flags.last_text === '{' || flags.last_text === ';')) { + // { foo; --i } + // foo(); --bar; + print_newline(); + } + } else if (token_text === ':') { + if (flags.ternary_depth === 0) { + if (flags.mode === MODE.BlockStatement) { + flags.mode = MODE.ObjectLiteral; + } + space_before = false; + } else { + flags.ternary_depth -= 1; + } + } else if (token_text === '?') { + flags.ternary_depth += 1; + } else if (token_text === '*' && last_type === 'TK_RESERVED' && flags.last_text === 'function') { + space_before = false; + space_after = false; + } + output_space_before_token = output_space_before_token || space_before; + print_token(); + output_space_before_token = space_after; + } + + function handle_block_comment() { + var lines = split_newlines(token_text); + var j; // iterator for this case + var javadoc = false; + var starless = false; + var lastIndent = whitespace_before_token.join(''); + var lastIndentLength = lastIndent.length; + + // block comment starts with a new line + print_newline(false, true); + if (lines.length > 1) { + if (all_lines_start_with(lines.slice(1), '*')) { + javadoc = true; + } + else if (each_line_matches_indent(lines.slice(1), lastIndent)) { + starless = true; + } + } + + // first line always indented + print_token(lines[0]); + for (j = 1; j < lines.length; j++) { + print_newline(false, true); + if (javadoc) { + // javadoc: reformat and re-indent + print_token(' ' + trim(lines[j])); + } else if (starless && lines[j].length > lastIndentLength) { + // starless: re-indent non-empty content, avoiding trim + print_token(lines[j].substring(lastIndentLength)); + } else { + // normal comments output raw + output_lines[output_lines.length - 1].text.push(lines[j]); + } + } + + // for comments of more than one line, make sure there's a new line after + print_newline(false, true); + } + + function handle_inline_comment() { + output_space_before_token = true; + print_token(); + output_space_before_token = true; + } + + function handle_comment() { + if (input_wanted_newline) { + print_newline(false, true); + } else { + trim_output(true); + } + + output_space_before_token = true; + print_token(); + print_newline(false, true); + } + + function handle_dot() { + if (start_of_statement()) { + // The conditional starts the statement if appropriate. + } + + if (last_type === 'TK_RESERVED' && is_special_word(flags.last_text)) { + output_space_before_token = true; + } else { + // allow preserved newlines before dots in general + // force newlines on dots after close paren when break_chained - for bar().baz() + allow_wrap_or_preserved_newline(flags.last_text === ')' && opt.break_chained_methods); + } + + print_token(); + } + + function handle_unknown() { + print_token(); + + if (token_text[token_text.length - 1] === '\n') { + print_newline(); + } + } +} diff --git a/devtools/shared/jsbeautify/src/beautify-tests.js b/devtools/shared/jsbeautify/src/beautify-tests.js new file mode 100644 index 000000000..254a9ca94 --- /dev/null +++ b/devtools/shared/jsbeautify/src/beautify-tests.js @@ -0,0 +1,2096 @@ +/*global js_beautify: true */ + +function run_beautifier_tests(test_obj, Urlencoded, js_beautify, html_beautify, css_beautify) +{ + + var opts = { + indent_size: 4, + indent_char: ' ', + preserve_newlines: true, + jslint_happy: false, + keep_array_indentation: false, + brace_style: 'collapse', + space_before_conditional: true, + break_chained_methods: false, + selector_separator: '\n', + end_with_newline: true + }; + + function test_js_beautifier(input) + { + return js_beautify(input, opts); + } + + function test_html_beautifier(input) + { + return html_beautify(input, opts); + } + + function test_css_beautifier(input) + { + return css_beautify(input, opts); + } + + var sanitytest; + + // test the input on beautifier with the current flag settings + // does not check the indentation / surroundings as bt() does + function test_fragment(input, expected) + { + expected = expected || input; + sanitytest.expect(input, expected); + // if the expected is different from input, run it again + // expected output should be unchanged when run twice. + if (expected != input) { + sanitytest.expect(expected, expected); + } + } + + + + // test the input on beautifier with the current flag settings + // test both the input as well as { input } wrapping + function bt(input, expectation) + { + var wrapped_input, wrapped_expectation; + + expectation = expectation || input; + sanitytest.test_function(test_js_beautifier, 'js_beautify'); + test_fragment(input, expectation); + + // test also the returned indentation + // e.g if input = "asdf();" + // then test that this remains properly formatted as well: + // { + // asdf(); + // indent; + // } + + if (opts.indent_size === 4 && input) { + wrapped_input = '{\n' + input.replace(/^(.+)$/mg, ' $1') + '\n foo = bar;\n}'; + wrapped_expectation = '{\n' + expectation.replace(/^(.+)$/mg, ' $1') + '\n foo = bar;\n}'; + test_fragment(wrapped_input, wrapped_expectation); + } + + } + + // test html + function bth(input, expectation) + { + var wrapped_input, wrapped_expectation, field_input, field_expectation; + + expectation = expectation || input; + sanitytest.test_function(test_html_beautifier, 'html_beautify'); + test_fragment(input, expectation); + + if (opts.indent_size === 4 && input) { + wrapped_input = '<div>\n' + input.replace(/^(.+)$/mg, ' $1') + '\n <span>inline</span>\n</div>'; + wrapped_expectation = '<div>\n' + expectation.replace(/^(.+)$/mg, ' $1') + '\n <span>inline</span>\n</div>'; + test_fragment(wrapped_input, wrapped_expectation); + } + + // Test that handlebars non-block {{}} tags act as content and do not + // get any spacing or line breaks. + if (input.indexOf('content') != -1) { + // Just {{field}} + field_input = input.replace(/content/g, '{{field}}'); + field_expectation = expectation.replace(/content/g, '{{field}}'); + test_fragment(field_input, field_expectation); + + // handlebars comment + field_input = input.replace(/content/g, '{{! comment}}'); + field_expectation = expectation.replace(/content/g, '{{! comment}}'); + test_fragment(field_input, field_expectation); + + // mixed {{field}} and content + field_input = input.replace(/content/g, 'pre{{field1}} {{field2}} {{field3}}post'); + field_expectation = expectation.replace(/content/g, 'pre{{field1}} {{field2}} {{field3}}post'); + test_fragment(field_input, field_expectation); + } + } + + // test css + function btc(input, expectation) + { + var wrapped_input, wrapped_expectation; + + expectation = expectation || input; + sanitytest.test_function(test_css_beautifier, 'css_beautify'); + test_fragment(input, expectation); + } + + // test the input on beautifier with the current flag settings, + // but dont't + function bt_braces(input, expectation) + { + var braces_ex = opts.brace_style; + opts.brace_style = 'expand'; + bt(input, expectation); + opts.brace_style = braces_ex; + } + + function beautifier_tests() + { + sanitytest = test_obj; + + opts.indent_size = 4; + opts.indent_char = ' '; + opts.preserve_newlines = true; + opts.jslint_happy = false; + opts.keep_array_indentation = false; + opts.brace_style = "collapse"; + + + // unicode support + bt('var ' + String.fromCharCode(3232) + '_' + String.fromCharCode(3232) + ' = "hi";'); + bt('var ' + String.fromCharCode(228) + 'x = {\n ' + String.fromCharCode(228) + 'rgerlich: true\n};'); + + bt(''); + bt('return .5'); + test_fragment(' return .5'); + test_fragment(' return .5;\n a();'); + bt('a = 1', 'a = 1'); + bt('a=1', 'a = 1'); + bt("a();\n\nb();", "a();\n\nb();"); + bt('var a = 1 var b = 2', "var a = 1\nvar b = 2"); + bt('var a=1, b=c[d], e=6;', 'var a = 1,\n b = c[d],\n e = 6;'); + bt('var a,\n b,\n c;'); + bt('let a = 1 let b = 2', "let a = 1\nlet b = 2"); + bt('let a=1, b=c[d], e=6;', 'let a = 1,\n b = c[d],\n e = 6;'); + bt('let a,\n b,\n c;'); + bt('const a = 1 const b = 2', "const a = 1\nconst b = 2"); + bt('const a=1, b=c[d], e=6;', 'const a = 1,\n b = c[d],\n e = 6;'); + bt('const a,\n b,\n c;'); + bt('a = " 12345 "'); + bt("a = ' 12345 '"); + bt('if (a == 1) b = 2;', "if (a == 1) b = 2;"); + bt('if(1){2}else{3}', "if (1) {\n 2\n} else {\n 3\n}"); + bt('if(1||2);', 'if (1 || 2);'); + bt('(a==1)||(b==2)', '(a == 1) || (b == 2)'); + bt('var a = 1 if (2) 3;', "var a = 1\nif (2) 3;"); + bt('a = a + 1'); + bt('a = a == 1'); + bt('/12345[^678]*9+/.match(a)'); + bt('a /= 5'); + bt('a = 0.5 * 3'); + bt('a *= 10.55'); + bt('a < .5'); + bt('a <= .5'); + bt('a<.5', 'a < .5'); + bt('a<=.5', 'a <= .5'); + bt('a = 0xff;'); + bt('a=0xff+4', 'a = 0xff + 4'); + bt('a = [1, 2, 3, 4]'); + bt('F*(g/=f)*g+b', 'F * (g /= f) * g + b'); + bt('a.b({c:d})', 'a.b({\n c: d\n})'); + bt('a.b\n(\n{\nc:\nd\n}\n)', 'a.b({\n c: d\n})'); + bt('a.b({c:"d"})', 'a.b({\n c: "d"\n})'); + bt('a.b\n(\n{\nc:\n"d"\n}\n)', 'a.b({\n c: "d"\n})'); + bt('a=!b', 'a = !b'); + bt('a=!!b', 'a = !!b'); + bt('a?b:c', 'a ? b : c'); + bt('a?1:2', 'a ? 1 : 2'); + bt('a?(b):c', 'a ? (b) : c'); + bt('x={a:1,b:w=="foo"?x:y,c:z}', 'x = {\n a: 1,\n b: w == "foo" ? x : y,\n c: z\n}'); + bt('x=a?b?c?d:e:f:g;', 'x = a ? b ? c ? d : e : f : g;'); + bt('x=a?b?c?d:{e1:1,e2:2}:f:g;', 'x = a ? b ? c ? d : {\n e1: 1,\n e2: 2\n} : f : g;'); + bt('function void(void) {}'); + bt('if(!a)foo();', 'if (!a) foo();'); + bt('a=~a', 'a = ~a'); + bt('a;/*comment*/b;', "a; /*comment*/\nb;"); + bt('a;/* comment */b;', "a; /* comment */\nb;"); + test_fragment('a;/*\ncomment\n*/b;', "a;\n/*\ncomment\n*/\nb;"); // simple comments don't get touched at all + bt('a;/**\n* javadoc\n*/b;', "a;\n/**\n * javadoc\n */\nb;"); + test_fragment('a;/**\n\nno javadoc\n*/b;', "a;\n/**\n\nno javadoc\n*/\nb;"); + bt('a;/*\n* javadoc\n*/b;', "a;\n/*\n * javadoc\n */\nb;"); // comment blocks detected and reindented even w/o javadoc starter + bt('if(a)break;', "if (a) break;"); + bt('if(a){break}', "if (a) {\n break\n}"); + bt('if((a))foo();', 'if ((a)) foo();'); + bt('for(var i=0;;) a', 'for (var i = 0;;) a'); + bt('for(var i=0;;)\na', 'for (var i = 0;;)\n a'); + bt('a++;', 'a++;'); + bt('for(;;i++)a()', 'for (;; i++) a()'); + bt('for(;;i++)\na()', 'for (;; i++)\n a()'); + bt('for(;;++i)a', 'for (;; ++i) a'); + bt('return(1)', 'return (1)'); + bt('try{a();}catch(b){c();}finally{d();}', "try {\n a();\n} catch (b) {\n c();\n} finally {\n d();\n}"); + bt('(xx)()'); // magic function call + bt('a[1]()'); // another magic function call + bt('if(a){b();}else if(c) foo();', "if (a) {\n b();\n} else if (c) foo();"); + bt('switch(x) {case 0: case 1: a(); break; default: break}', "switch (x) {\n case 0:\n case 1:\n a();\n break;\n default:\n break\n}"); + bt('switch(x){case -1:break;case !y:break;}', 'switch (x) {\n case -1:\n break;\n case !y:\n break;\n}'); + bt('a !== b'); + bt('if (a) b(); else c();', "if (a) b();\nelse c();"); + bt("// comment\n(function something() {})"); // typical greasemonkey start + bt("{\n\n x();\n\n}"); // was: duplicating newlines + bt('if (a in b) foo();'); + bt('var a, b;'); + // bt('var a, b'); + bt('{a:1, b:2}', "{\n a: 1,\n b: 2\n}"); + bt('a={1:[-1],2:[+1]}', 'a = {\n 1: [-1],\n 2: [+1]\n}'); + bt('var l = {\'a\':\'1\', \'b\':\'2\'}', "var l = {\n 'a': '1',\n 'b': '2'\n}"); + bt('if (template.user[n] in bk) foo();'); + bt('{{}/z/}', "{\n {}\n /z/\n}"); + bt('return 45', "return 45"); + bt('return this.prevObject ||\n\n this.constructor(null);'); + bt('If[1]', "If[1]"); + bt('Then[1]', "Then[1]"); + bt('a = 1e10', "a = 1e10"); + bt('a = 1.3e10', "a = 1.3e10"); + bt('a = 1.3e-10', "a = 1.3e-10"); + bt('a = -1.3e-10', "a = -1.3e-10"); + bt('a = 1e-10', "a = 1e-10"); + bt('a = e - 10', "a = e - 10"); + bt('a = 11-10', "a = 11 - 10"); + bt("a = 1;// comment", "a = 1; // comment"); + bt("a = 1; // comment", "a = 1; // comment"); + bt("a = 1;\n // comment", "a = 1;\n// comment"); + bt('a = [-1, -1, -1]'); + + // The exact formatting these should have is open for discussion, but they are at least reasonable + bt('a = [ // comment\n -1, -1, -1\n]'); + bt('var a = [ // comment\n -1, -1, -1\n]'); + bt('a = [ // comment\n -1, // comment\n -1, -1\n]'); + bt('var a = [ // comment\n -1, // comment\n -1, -1\n]'); + + bt('o = [{a:b},{c:d}]', 'o = [{\n a: b\n}, {\n c: d\n}]'); + + bt("if (a) {\n do();\n}"); // was: extra space appended + + bt("if (a) {\n// comment\n}else{\n// comment\n}", "if (a) {\n // comment\n} else {\n // comment\n}"); // if/else statement with empty body + bt("if (a) {\n// comment\n// comment\n}", "if (a) {\n // comment\n // comment\n}"); // multiple comments indentation + bt("if (a) b() else c();", "if (a) b()\nelse c();"); + bt("if (a) b() else if c() d();", "if (a) b()\nelse if c() d();"); + + bt("{}"); + bt("{\n\n}"); + bt("do { a(); } while ( 1 );", "do {\n a();\n} while (1);"); + bt("do {} while (1);"); + bt("do {\n} while (1);", "do {} while (1);"); + bt("do {\n\n} while (1);"); + bt("var a = x(a, b, c)"); + bt("delete x if (a) b();", "delete x\nif (a) b();"); + bt("delete x[x] if (a) b();", "delete x[x]\nif (a) b();"); + bt("for(var a=1,b=2)d", "for (var a = 1, b = 2) d"); + bt("for(var a=1,b=2,c=3) d", "for (var a = 1, b = 2, c = 3) d"); + bt("for(var a=1,b=2,c=3;d<3;d++)\ne", "for (var a = 1, b = 2, c = 3; d < 3; d++)\n e"); + bt("function x(){(a||b).c()}", "function x() {\n (a || b).c()\n}"); + bt("function x(){return - 1}", "function x() {\n return -1\n}"); + bt("function x(){return ! a}", "function x() {\n return !a\n}"); + bt("x => x", "x => x"); + bt("(x) => x", "(x) => x"); + bt("x => { x }", "x => {\n x\n}"); + bt("(x) => { x }", "(x) => {\n x\n}"); + + // a common snippet in jQuery plugins + bt("settings = $.extend({},defaults,settings);", "settings = $.extend({}, defaults, settings);"); + + // reserved words used as property names + bt("$http().then().finally().default()", "$http().then().finally().default()"); + bt("$http()\n.then()\n.finally()\n.default()", "$http()\n .then()\n .finally()\n .default()"); + bt("$http().when.in.new.catch().throw()", "$http().when.in.new.catch().throw()"); + bt("$http()\n.when\n.in\n.new\n.catch()\n.throw()", "$http()\n .when\n .in\n .new\n .catch()\n .throw()"); + + bt('{xxx;}()', '{\n xxx;\n}()'); + + bt("a = 'a'\nb = 'b'"); + bt("a = /reg/exp"); + bt("a = /reg/"); + bt('/abc/.test()'); + bt('/abc/i.test()'); + bt("{/abc/i.test()}", "{\n /abc/i.test()\n}"); + bt('var x=(a)/a;', 'var x = (a) / a;'); + + bt('x != -1', 'x != -1'); + + bt('for (; s-->0;)t', 'for (; s-- > 0;) t'); + bt('for (; s++>0;)u', 'for (; s++ > 0;) u'); + bt('a = s++>s--;', 'a = s++ > s--;'); + bt('a = s++>--s;', 'a = s++ > --s;'); + + bt('{x=#1=[]}', '{\n x = #1=[]\n}'); + bt('{a:#1={}}', '{\n a: #1={}\n}'); + bt('{a:#1#}', '{\n a: #1#\n}'); + + test_fragment('"incomplete-string'); + test_fragment("'incomplete-string"); + test_fragment('/incomplete-regex'); + test_fragment('`incomplete-template-string'); + + test_fragment('{a:1},{a:2}', '{\n a: 1\n}, {\n a: 2\n}'); + test_fragment('var ary=[{a:1}, {a:2}];', 'var ary = [{\n a: 1\n}, {\n a: 2\n}];'); + + test_fragment('{a:#1', '{\n a: #1'); // incomplete + test_fragment('{a:#', '{\n a: #'); // incomplete + + test_fragment('}}}', '}\n}\n}'); // incomplete + + test_fragment('<!--\nvoid();\n// -->', '<!--\nvoid();\n// -->'); + + test_fragment('a=/regexp', 'a = /regexp'); // incomplete regexp + + bt('{a:#1=[],b:#1#,c:#999999#}', '{\n a: #1=[],\n b: #1#,\n c: #999999#\n}'); + + bt("a = 1e+2"); + bt("a = 1e-2"); + bt("do{x()}while(a>1)", "do {\n x()\n} while (a > 1)"); + + bt("x(); /reg/exp.match(something)", "x();\n/reg/exp.match(something)"); + + test_fragment("something();(", "something();\n("); + test_fragment("#!she/bangs, she bangs\nf=1", "#!she/bangs, she bangs\n\nf = 1"); + test_fragment("#!she/bangs, she bangs\n\nf=1", "#!she/bangs, she bangs\n\nf = 1"); + test_fragment("#!she/bangs, she bangs\n\n/* comment */", "#!she/bangs, she bangs\n\n/* comment */"); + test_fragment("#!she/bangs, she bangs\n\n\n/* comment */", "#!she/bangs, she bangs\n\n\n/* comment */"); + test_fragment("#", "#"); + test_fragment("#!", "#!"); + + bt("function namespace::something()"); + + test_fragment("<!--\nsomething();\n-->", "<!--\nsomething();\n-->"); + test_fragment("<!--\nif(i<0){bla();}\n-->", "<!--\nif (i < 0) {\n bla();\n}\n-->"); + + bt('{foo();--bar;}', '{\n foo();\n --bar;\n}'); + bt('{foo();++bar;}', '{\n foo();\n ++bar;\n}'); + bt('{--bar;}', '{\n --bar;\n}'); + bt('{++bar;}', '{\n ++bar;\n}'); + + // Handling of newlines around unary ++ and -- operators + bt('{foo\n++bar;}', '{\n foo\n ++bar;\n}'); + bt('{foo++\nbar;}', '{\n foo++\n bar;\n}'); + + // This is invalid, but harder to guard against. Issue #203. + bt('{foo\n++\nbar;}', '{\n foo\n ++\n bar;\n}'); + + + // regexps + bt('a(/abc\\/\\/def/);b()', "a(/abc\\/\\/def/);\nb()"); + bt('a(/a[b\\[\\]c]d/);b()', "a(/a[b\\[\\]c]d/);\nb()"); + test_fragment('a(/a[b\\[', "a(/a[b\\["); // incomplete char class + // allow unescaped / in char classes + bt('a(/[a/b]/);b()', "a(/[a/b]/);\nb()"); + + bt('function foo() {\n return [\n "one",\n "two"\n ];\n}'); + bt('a=[[1,2],[4,5],[7,8]]', "a = [\n [1, 2],\n [4, 5],\n [7, 8]\n]"); + bt('a=[[1,2],[4,5],function(){},[7,8]]', + "a = [\n [1, 2],\n [4, 5],\n function() {},\n [7, 8]\n]"); + bt('a=[[1,2],[4,5],function(){},function(){},[7,8]]', + "a = [\n [1, 2],\n [4, 5],\n function() {},\n function() {},\n [7, 8]\n]"); + bt('a=[[1,2],[4,5],function(){},[7,8]]', + "a = [\n [1, 2],\n [4, 5],\n function() {},\n [7, 8]\n]"); + bt('a=[b,c,function(){},function(){},d]', + "a = [b, c,\n function() {},\n function() {},\n d\n]"); + bt('a=[a[1],b[4],c[d[7]]]', "a = [a[1], b[4], c[d[7]]]"); + bt('[1,2,[3,4,[5,6],7],8]', "[1, 2, [3, 4, [5, 6], 7], 8]"); + + bt('[[["1","2"],["3","4"]],[["5","6","7"],["8","9","0"]],[["1","2","3"],["4","5","6","7"],["8","9","0"]]]', + '[\n [\n ["1", "2"],\n ["3", "4"]\n ],\n [\n ["5", "6", "7"],\n ["8", "9", "0"]\n ],\n [\n ["1", "2", "3"],\n ["4", "5", "6", "7"],\n ["8", "9", "0"]\n ]\n]'); + + bt('{[x()[0]];indent;}', '{\n [x()[0]];\n indent;\n}'); + + bt('return ++i', 'return ++i'); + bt('return !!x', 'return !!x'); + bt('return !x', 'return !x'); + bt('return [1,2]', 'return [1, 2]'); + bt('return;', 'return;'); + bt('return\nfunc', 'return\nfunc'); + bt('catch(e)', 'catch (e)'); + bt('yield [1, 2]'); + + bt('var a=1,b={foo:2,bar:3},{baz:4,wham:5},c=4;', + 'var a = 1,\n b = {\n foo: 2,\n bar: 3\n },\n {\n baz: 4,\n wham: 5\n }, c = 4;'); + bt('var a=1,b={foo:2,bar:3},{baz:4,wham:5},\nc=4;', + 'var a = 1,\n b = {\n foo: 2,\n bar: 3\n },\n {\n baz: 4,\n wham: 5\n },\n c = 4;'); + + + // inline comment + bt('function x(/*int*/ start, /*string*/ foo)', 'function x( /*int*/ start, /*string*/ foo)'); + + // javadoc comment + bt('/**\n* foo\n*/', '/**\n * foo\n */'); + bt('{\n/**\n* foo\n*/\n}', '{\n /**\n * foo\n */\n}'); + + // starless block comment + bt('/**\nfoo\n*/'); + bt('/**\nfoo\n**/'); + bt('/**\nfoo\nbar\n**/'); + bt('/**\nfoo\n\nbar\n**/'); + bt('/**\nfoo\n bar\n**/'); + bt('{\n/**\nfoo\n*/\n}', '{\n /**\n foo\n */\n}'); + bt('{\n/**\nfoo\n**/\n}', '{\n /**\n foo\n **/\n}'); + bt('{\n/**\nfoo\nbar\n**/\n}', '{\n /**\n foo\n bar\n **/\n}'); + bt('{\n/**\nfoo\n\nbar\n**/\n}', '{\n /**\n foo\n\n bar\n **/\n}'); + bt('{\n/**\nfoo\n bar\n**/\n}', '{\n /**\n foo\n bar\n **/\n}'); + bt('{\n /**\n foo\nbar\n **/\n}'); + + bt('var a,b,c=1,d,e,f=2;', 'var a, b, c = 1,\n d, e, f = 2;'); + bt('var a,b,c=[],d,e,f=2;', 'var a, b, c = [],\n d, e, f = 2;'); + bt('function() {\n var a, b, c, d, e = [],\n f;\n}'); + + bt('do/regexp/;\nwhile(1);', 'do /regexp/;\nwhile (1);'); // hmmm + + bt('var a = a,\na;\nb = {\nb\n}', 'var a = a,\n a;\nb = {\n b\n}'); + + bt('var a = a,\n /* c */\n b;'); + bt('var a = a,\n // c\n b;'); + + bt('foo.("bar");'); // weird element referencing + + + bt('if (a) a()\nelse b()\nnewline()'); + bt('if (a) a()\nnewline()'); + bt('a=typeof(x)', 'a = typeof(x)'); + + bt('var a = function() {\n return null;\n },\n b = false;'); + + bt('var a = function() {\n func1()\n}'); + bt('var a = function() {\n func1()\n}\nvar b = function() {\n func2()\n}'); + + // code with and without semicolons + bt( 'var whatever = require("whatever");\nfunction() {\n a = 6;\n}', + 'var whatever = require("whatever");\n\nfunction() {\n a = 6;\n}'); + bt( 'var whatever = require("whatever")\nfunction() {\n a = 6\n}', + 'var whatever = require("whatever")\n\nfunction() {\n a = 6\n}'); + + + opts.jslint_happy = true; + + bt('a=typeof(x)', 'a = typeof (x)'); + bt('x();\n\nfunction(){}', 'x();\n\nfunction () {}'); + bt('function () {\n var a, b, c, d, e = [],\n f;\n}'); + bt('switch(x) {case 0: case 1: a(); break; default: break}', + "switch (x) {\ncase 0:\ncase 1:\n a();\n break;\ndefault:\n break\n}"); + bt('switch(x){case -1:break;case !y:break;}', + 'switch (x) {\ncase -1:\n break;\ncase !y:\n break;\n}'); + test_fragment("// comment 1\n(function()", "// comment 1\n(function ()"); // typical greasemonkey start + bt('var o1=$.extend(a);function(){alert(x);}', 'var o1 = $.extend(a);\n\nfunction () {\n alert(x);\n}'); + bt('function* () {\n yield 1;\n}'); + + opts.jslint_happy = false; + + bt('switch(x) {case 0: case 1: a(); break; default: break}', + "switch (x) {\n case 0:\n case 1:\n a();\n break;\n default:\n break\n}"); + bt('switch(x){case -1:break;case !y:break;}', + 'switch (x) {\n case -1:\n break;\n case !y:\n break;\n}'); + test_fragment("// comment 2\n(function()", "// comment 2\n(function()"); // typical greasemonkey start + bt("var a2, b2, c2, d2 = 0, c = function() {}, d = '';", "var a2, b2, c2, d2 = 0,\n c = function() {},\n d = '';"); + bt("var a2, b2, c2, d2 = 0, c = function() {},\nd = '';", "var a2, b2, c2, d2 = 0,\n c = function() {},\n d = '';"); + bt('var o2=$.extend(a);function(){alert(x);}', 'var o2 = $.extend(a);\n\nfunction() {\n alert(x);\n}'); + bt('function*() {\n yield 1;\n}'); + + bt('function* x() {\n yield 1;\n}'); + + bt('{"x":[{"a":1,"b":3},7,8,8,8,8,{"b":99},{"a":11}]}', '{\n "x": [{\n "a": 1,\n "b": 3\n },\n 7, 8, 8, 8, 8, {\n "b": 99\n }, {\n "a": 11\n }\n ]\n}'); + + bt('{"1":{"1a":"1b"},"2"}', '{\n "1": {\n "1a": "1b"\n },\n "2"\n}'); + bt('{a:{a:b},c}', '{\n a: {\n a: b\n },\n c\n}'); + + bt('{[y[a]];keep_indent;}', '{\n [y[a]];\n keep_indent;\n}'); + + bt('if (x) {y} else { if (x) {y}}', 'if (x) {\n y\n} else {\n if (x) {\n y\n }\n}'); + + bt('if (foo) one()\ntwo()\nthree()'); + bt('if (1 + foo() && bar(baz()) / 2) one()\ntwo()\nthree()'); + bt('if (1 + foo() && bar(baz()) / 2) one();\ntwo();\nthree();'); + + opts.indent_size = 1; + opts.indent_char = ' '; + bt('{ one_char() }', "{\n one_char()\n}"); + + bt('var a,b=1,c=2', 'var a, b = 1,\n c = 2'); + + opts.indent_size = 4; + opts.indent_char = ' '; + bt('{ one_char() }', "{\n one_char()\n}"); + + opts.indent_size = 1; + opts.indent_char = "\t"; + bt('{ one_char() }', "{\n\tone_char()\n}"); + bt('x = a ? b : c; x;', 'x = a ? b : c;\nx;'); + + //set to something else than it should change to, but with tabs on, should override + opts.indent_size = 5; + opts.indent_char = ' '; + opts.indent_with_tabs = true; + + bt('{ one_char() }', "{\n\tone_char()\n}"); + bt('x = a ? b : c; x;', 'x = a ? b : c;\nx;'); + + opts.indent_size = 4; + opts.indent_char = ' '; + opts.indent_with_tabs = false; + + opts.preserve_newlines = false; + + bt('var\na=dont_preserve_newlines;', 'var a = dont_preserve_newlines;'); + + // make sure the blank line between function definitions stays + // even when preserve_newlines = false + bt('function foo() {\n return 1;\n}\n\nfunction foo() {\n return 1;\n}'); + bt('function foo() {\n return 1;\n}\nfunction foo() {\n return 1;\n}', + 'function foo() {\n return 1;\n}\n\nfunction foo() {\n return 1;\n}' + ); + bt('function foo() {\n return 1;\n}\n\n\nfunction foo() {\n return 1;\n}', + 'function foo() {\n return 1;\n}\n\nfunction foo() {\n return 1;\n}' + ); + + opts.preserve_newlines = true; + bt('var\na=do_preserve_newlines;', 'var\n a = do_preserve_newlines;'); + bt('// a\n// b\n\n// c\n// d'); + bt('if (foo) // comment\n{\n bar();\n}'); + + + opts.keep_array_indentation = false; + bt("a = ['a', 'b', 'c',\n 'd', 'e', 'f']", + "a = ['a', 'b', 'c',\n 'd', 'e', 'f'\n]"); + bt("a = ['a', 'b', 'c',\n 'd', 'e', 'f',\n 'g', 'h', 'i']", + "a = ['a', 'b', 'c',\n 'd', 'e', 'f',\n 'g', 'h', 'i'\n]"); + bt("a = ['a', 'b', 'c',\n 'd', 'e', 'f',\n 'g', 'h', 'i']", + "a = ['a', 'b', 'c',\n 'd', 'e', 'f',\n 'g', 'h', 'i'\n]"); + bt('var x = [{}\n]', 'var x = [{}]'); + bt('var x = [{foo:bar}\n]', 'var x = [{\n foo: bar\n}]'); + bt("a = ['something',\n 'completely',\n 'different'];\nif (x);", + "a = ['something',\n 'completely',\n 'different'\n];\nif (x);"); + bt("a = ['a','b','c']", "a = ['a', 'b', 'c']"); + + bt("a = ['a', 'b','c']", "a = ['a', 'b', 'c']"); + bt("x = [{'a':0}]", + "x = [{\n 'a': 0\n}]"); + bt('{a([[a1]], {b;});}', + '{\n a([\n [a1]\n ], {\n b;\n });\n}'); + bt("a();\n [\n ['sdfsdfsd'],\n ['sdfsdfsdf']\n ].toString();", + "a();\n[\n ['sdfsdfsd'],\n ['sdfsdfsdf']\n].toString();"); + bt("a();\na = [\n ['sdfsdfsd'],\n ['sdfsdfsdf']\n ].toString();", + "a();\na = [\n ['sdfsdfsd'],\n ['sdfsdfsdf']\n].toString();"); + bt("function() {\n Foo([\n ['sdfsdfsd'],\n ['sdfsdfsdf']\n ]);\n}", + "function() {\n Foo([\n ['sdfsdfsd'],\n ['sdfsdfsdf']\n ]);\n}"); + bt('function foo() {\n return [\n "one",\n "two"\n ];\n}'); + // 4 spaces per indent input, processed with 4-spaces per indent + bt( "function foo() {\n" + + " return [\n" + + " {\n" + + " one: 'x',\n" + + " two: [\n" + + " {\n" + + " id: 'a',\n" + + " name: 'apple'\n" + + " }, {\n" + + " id: 'b',\n" + + " name: 'banana'\n" + + " }\n" + + " ]\n" + + " }\n" + + " ];\n" + + "}", + "function foo() {\n" + + " return [{\n" + + " one: 'x',\n" + + " two: [{\n" + + " id: 'a',\n" + + " name: 'apple'\n" + + " }, {\n" + + " id: 'b',\n" + + " name: 'banana'\n" + + " }]\n" + + " }];\n" + + "}"); + // 3 spaces per indent input, processed with 4-spaces per indent + bt( "function foo() {\n" + + " return [\n" + + " {\n" + + " one: 'x',\n" + + " two: [\n" + + " {\n" + + " id: 'a',\n" + + " name: 'apple'\n" + + " }, {\n" + + " id: 'b',\n" + + " name: 'banana'\n" + + " }\n" + + " ]\n" + + " }\n" + + " ];\n" + + "}", + "function foo() {\n" + + " return [{\n" + + " one: 'x',\n" + + " two: [{\n" + + " id: 'a',\n" + + " name: 'apple'\n" + + " }, {\n" + + " id: 'b',\n" + + " name: 'banana'\n" + + " }]\n" + + " }];\n" + + "}"); + + opts.keep_array_indentation = true; + bt("a = ['a', 'b', 'c',\n 'd', 'e', 'f']"); + bt("a = ['a', 'b', 'c',\n 'd', 'e', 'f',\n 'g', 'h', 'i']"); + bt("a = ['a', 'b', 'c',\n 'd', 'e', 'f',\n 'g', 'h', 'i']"); + bt('var x = [{}\n]', 'var x = [{}\n]'); + bt('var x = [{foo:bar}\n]', 'var x = [{\n foo: bar\n }\n]'); + bt("a = ['something',\n 'completely',\n 'different'];\nif (x);"); + bt("a = ['a','b','c']", "a = ['a', 'b', 'c']"); + bt("a = ['a', 'b','c']", "a = ['a', 'b', 'c']"); + bt("x = [{'a':0}]", + "x = [{\n 'a': 0\n}]"); + bt('{a([[a1]], {b;});}', + '{\n a([[a1]], {\n b;\n });\n}'); + bt("a();\n [\n ['sdfsdfsd'],\n ['sdfsdfsdf']\n ].toString();", + "a();\n [\n ['sdfsdfsd'],\n ['sdfsdfsdf']\n ].toString();"); + bt("a();\na = [\n ['sdfsdfsd'],\n ['sdfsdfsdf']\n ].toString();", + "a();\na = [\n ['sdfsdfsd'],\n ['sdfsdfsdf']\n ].toString();"); + bt("function() {\n Foo([\n ['sdfsdfsd'],\n ['sdfsdfsdf']\n ]);\n}", + "function() {\n Foo([\n ['sdfsdfsd'],\n ['sdfsdfsdf']\n ]);\n}"); + bt('function foo() {\n return [\n "one",\n "two"\n ];\n}'); + // 4 spaces per indent input, processed with 4-spaces per indent + bt( "function foo() {\n" + + " return [\n" + + " {\n" + + " one: 'x',\n" + + " two: [\n" + + " {\n" + + " id: 'a',\n" + + " name: 'apple'\n" + + " }, {\n" + + " id: 'b',\n" + + " name: 'banana'\n" + + " }\n" + + " ]\n" + + " }\n" + + " ];\n" + + "}"); + // 3 spaces per indent input, processed with 4-spaces per indent + // Should be unchanged, but is not - #445 +// bt( "function foo() {\n" + +// " return [\n" + +// " {\n" + +// " one: 'x',\n" + +// " two: [\n" + +// " {\n" + +// " id: 'a',\n" + +// " name: 'apple'\n" + +// " }, {\n" + +// " id: 'b',\n" + +// " name: 'banana'\n" + +// " }\n" + +// " ]\n" + +// " }\n" + +// " ];\n" + +// "}"); + + + opts.keep_array_indentation = false; + + + bt('a = //comment\n /regex/;'); + + test_fragment('/*\n * X\n */'); + test_fragment('/*\r\n * X\r\n */', '/*\n * X\n */'); + + bt('if (a)\n{\nb;\n}\nelse\n{\nc;\n}', 'if (a) {\n b;\n} else {\n c;\n}'); + + + opts.brace_style = 'expand'; + + bt('//case 1\nif (a == 1)\n{}\n//case 2\nelse if (a == 2)\n{}'); + bt('if(1){2}else{3}', "if (1)\n{\n 2\n}\nelse\n{\n 3\n}"); + bt('try{a();}catch(b){c();}catch(d){}finally{e();}', + "try\n{\n a();\n}\ncatch (b)\n{\n c();\n}\ncatch (d)\n{}\nfinally\n{\n e();\n}"); + bt('if(a){b();}else if(c) foo();', + "if (a)\n{\n b();\n}\nelse if (c) foo();"); + bt('if(X)if(Y)a();else b();else c();', + "if (X)\n if (Y) a();\n else b();\nelse c();"); + bt("if (a) {\n// comment\n}else{\n// comment\n}", + "if (a)\n{\n // comment\n}\nelse\n{\n // comment\n}"); // if/else statement with empty body + bt('if (x) {y} else { if (x) {y}}', + 'if (x)\n{\n y\n}\nelse\n{\n if (x)\n {\n y\n }\n}'); + bt('if (a)\n{\nb;\n}\nelse\n{\nc;\n}', + 'if (a)\n{\n b;\n}\nelse\n{\n c;\n}'); + test_fragment(' /*\n* xx\n*/\n// xx\nif (foo) {\n bar();\n}', + ' /*\n * xx\n */\n // xx\n if (foo)\n {\n bar();\n }'); + bt('if (foo)\n{}\nelse /regex/.test();'); + bt('if (foo) /regex/.test();'); + bt('if (a)\n{\nb;\n}\nelse\n{\nc;\n}', 'if (a)\n{\n b;\n}\nelse\n{\n c;\n}'); + test_fragment('if (foo) {', 'if (foo)\n{'); + test_fragment('foo {', 'foo\n{'); + test_fragment('return {', 'return {'); // return needs the brace. + test_fragment('return /* inline */ {', 'return /* inline */ {'); + // test_fragment('return\n{', 'return\n{'); // can't support this?, but that's an improbable and extreme case anyway. + test_fragment('return;\n{', 'return;\n{'); + bt("throw {}"); + bt("throw {\n foo;\n}"); + bt('var foo = {}'); + bt('if (foo) bar();\nelse break'); + bt('function x() {\n foo();\n}zzz', 'function x()\n{\n foo();\n}\nzzz'); + bt('a: do {} while (); xxx', 'a: do {} while ();\nxxx'); + bt('var a = new function();'); + bt('var a = new function() {};'); + bt('var a = new function()\n{};', 'var a = new function() {};'); + bt('var a = new function a()\n{};'); + bt('var a = new function a()\n {},\n b = new function b()\n {};'); + test_fragment('new function'); + bt("foo({\n 'a': 1\n},\n10);", + "foo(\n {\n 'a': 1\n },\n 10);"); + bt('(["foo","bar"]).each(function(i) {return i;});', + '(["foo", "bar"]).each(function(i)\n{\n return i;\n});'); + bt('(function(i) {return i;})();', + '(function(i)\n{\n return i;\n})();'); + bt( "test( /*Argument 1*/ {\n" + + " 'Value1': '1'\n" + + "}, /*Argument 2\n" + + " */ {\n" + + " 'Value2': '2'\n" + + "});", + // expected + "test( /*Argument 1*/\n" + + " {\n" + + " 'Value1': '1'\n" + + " },\n" + + " /*Argument 2\n" + + " */\n" + + " {\n" + + " 'Value2': '2'\n" + + " });"); + bt( "test(\n" + + "/*Argument 1*/ {\n" + + " 'Value1': '1'\n" + + "},\n" + + "/*Argument 2\n" + + " */ {\n" + + " 'Value2': '2'\n" + + "});", + // expected + "test(\n" + + " /*Argument 1*/\n" + + " {\n" + + " 'Value1': '1'\n" + + " },\n" + + " /*Argument 2\n" + + " */\n" + + " {\n" + + " 'Value2': '2'\n" + + " });"); + bt( "test( /*Argument 1*/\n" + + "{\n" + + " 'Value1': '1'\n" + + "}, /*Argument 2\n" + + " */\n" + + "{\n" + + " 'Value2': '2'\n" + + "});", + // expected + "test( /*Argument 1*/\n" + + " {\n" + + " 'Value1': '1'\n" + + " },\n" + + " /*Argument 2\n" + + " */\n" + + " {\n" + + " 'Value2': '2'\n" + + " });"); + + opts.brace_style = 'collapse'; + + bt('//case 1\nif (a == 1) {}\n//case 2\nelse if (a == 2) {}'); + bt('if(1){2}else{3}', "if (1) {\n 2\n} else {\n 3\n}"); + bt('try{a();}catch(b){c();}catch(d){}finally{e();}', + "try {\n a();\n} catch (b) {\n c();\n} catch (d) {} finally {\n e();\n}"); + bt('if(a){b();}else if(c) foo();', + "if (a) {\n b();\n} else if (c) foo();"); + bt("if (a) {\n// comment\n}else{\n// comment\n}", + "if (a) {\n // comment\n} else {\n // comment\n}"); // if/else statement with empty body + bt('if (x) {y} else { if (x) {y}}', + 'if (x) {\n y\n} else {\n if (x) {\n y\n }\n}'); + bt('if (a)\n{\nb;\n}\nelse\n{\nc;\n}', + 'if (a) {\n b;\n} else {\n c;\n}'); + test_fragment(' /*\n* xx\n*/\n// xx\nif (foo) {\n bar();\n}', + ' /*\n * xx\n */\n // xx\n if (foo) {\n bar();\n }'); + bt('if (foo) {} else /regex/.test();'); + bt('if (foo) /regex/.test();'); + bt('if (a)\n{\nb;\n}\nelse\n{\nc;\n}', 'if (a) {\n b;\n} else {\n c;\n}'); + test_fragment('if (foo) {', 'if (foo) {'); + test_fragment('foo {', 'foo {'); + test_fragment('return {', 'return {'); // return needs the brace. + test_fragment('return /* inline */ {', 'return /* inline */ {'); + // test_fragment('return\n{', 'return\n{'); // can't support this?, but that's an improbable and extreme case anyway. + test_fragment('return;\n{', 'return; {'); + bt("throw {}"); + bt("throw {\n foo;\n}"); + bt('var foo = {}'); + bt('if (foo) bar();\nelse break'); + bt('function x() {\n foo();\n}zzz', 'function x() {\n foo();\n}\nzzz'); + bt('a: do {} while (); xxx', 'a: do {} while ();\nxxx'); + bt('var a = new function();'); + bt('var a = new function() {};'); + bt('var a = new function a() {};'); + test_fragment('new function'); + bt("foo({\n 'a': 1\n},\n10);", + "foo({\n 'a': 1\n },\n 10);"); + bt('(["foo","bar"]).each(function(i) {return i;});', + '(["foo", "bar"]).each(function(i) {\n return i;\n});'); + bt('(function(i) {return i;})();', + '(function(i) {\n return i;\n})();'); + bt( "test( /*Argument 1*/ {\n" + + " 'Value1': '1'\n" + + "}, /*Argument 2\n" + + " */ {\n" + + " 'Value2': '2'\n" + + "});", + // expected + "test( /*Argument 1*/ {\n" + + " 'Value1': '1'\n" + + " },\n" + + " /*Argument 2\n" + + " */\n" + + " {\n" + + " 'Value2': '2'\n" + + " });"); + bt( "test(\n" + + "/*Argument 1*/ {\n" + + " 'Value1': '1'\n" + + "},\n" + + "/*Argument 2\n" + + " */ {\n" + + " 'Value2': '2'\n" + + "});", + // expected + "test(\n" + + " /*Argument 1*/\n" + + " {\n" + + " 'Value1': '1'\n" + + " },\n" + + " /*Argument 2\n" + + " */\n" + + " {\n" + + " 'Value2': '2'\n" + + " });"); + bt( "test( /*Argument 1*/\n" + + "{\n" + + " 'Value1': '1'\n" + + "}, /*Argument 2\n" + + " */\n" + + "{\n" + + " 'Value2': '2'\n" + + "});", + // expected + "test( /*Argument 1*/ {\n" + + " 'Value1': '1'\n" + + " },\n" + + " /*Argument 2\n" + + " */\n" + + " {\n" + + " 'Value2': '2'\n" + + " });"); + + opts.brace_style = "end-expand"; + + bt('//case 1\nif (a == 1) {}\n//case 2\nelse if (a == 2) {}'); + bt('if(1){2}else{3}', "if (1) {\n 2\n}\nelse {\n 3\n}"); + bt('try{a();}catch(b){c();}catch(d){}finally{e();}', + "try {\n a();\n}\ncatch (b) {\n c();\n}\ncatch (d) {}\nfinally {\n e();\n}"); + bt('if(a){b();}else if(c) foo();', + "if (a) {\n b();\n}\nelse if (c) foo();"); + bt("if (a) {\n// comment\n}else{\n// comment\n}", + "if (a) {\n // comment\n}\nelse {\n // comment\n}"); // if/else statement with empty body + bt('if (x) {y} else { if (x) {y}}', + 'if (x) {\n y\n}\nelse {\n if (x) {\n y\n }\n}'); + bt('if (a)\n{\nb;\n}\nelse\n{\nc;\n}', + 'if (a) {\n b;\n}\nelse {\n c;\n}'); + test_fragment(' /*\n* xx\n*/\n// xx\nif (foo) {\n bar();\n}', + ' /*\n * xx\n */\n // xx\n if (foo) {\n bar();\n }'); + bt('if (foo) {}\nelse /regex/.test();'); + bt('if (foo) /regex/.test();'); + bt('if (a)\n{\nb;\n}\nelse\n{\nc;\n}', 'if (a) {\n b;\n}\nelse {\n c;\n}'); + test_fragment('if (foo) {', 'if (foo) {'); + test_fragment('foo {', 'foo {'); + test_fragment('return {', 'return {'); // return needs the brace. + test_fragment('return /* inline */ {', 'return /* inline */ {'); + // test_fragment('return\n{', 'return\n{'); // can't support this?, but that's an improbable and extreme case anyway. + test_fragment('return;\n{', 'return; {'); + bt("throw {}"); + bt("throw {\n foo;\n}"); + bt('var foo = {}'); + bt('if (foo) bar();\nelse break'); + bt('function x() {\n foo();\n}zzz', 'function x() {\n foo();\n}\nzzz'); + bt('a: do {} while (); xxx', 'a: do {} while ();\nxxx'); + bt('var a = new function();'); + bt('var a = new function() {};'); + bt('var a = new function a() {};'); + test_fragment('new function'); + bt("foo({\n 'a': 1\n},\n10);", + "foo({\n 'a': 1\n },\n 10);"); + bt('(["foo","bar"]).each(function(i) {return i;});', + '(["foo", "bar"]).each(function(i) {\n return i;\n});'); + bt('(function(i) {return i;})();', + '(function(i) {\n return i;\n})();'); + bt( "test( /*Argument 1*/ {\n" + + " 'Value1': '1'\n" + + "}, /*Argument 2\n" + + " */ {\n" + + " 'Value2': '2'\n" + + "});", + // expected + "test( /*Argument 1*/ {\n" + + " 'Value1': '1'\n" + + " },\n" + + " /*Argument 2\n" + + " */\n" + + " {\n" + + " 'Value2': '2'\n" + + " });"); + bt( "test(\n" + + "/*Argument 1*/ {\n" + + " 'Value1': '1'\n" + + "},\n" + + "/*Argument 2\n" + + " */ {\n" + + " 'Value2': '2'\n" + + "});", + // expected + "test(\n" + + " /*Argument 1*/\n" + + " {\n" + + " 'Value1': '1'\n" + + " },\n" + + " /*Argument 2\n" + + " */\n" + + " {\n" + + " 'Value2': '2'\n" + + " });"); + bt( "test( /*Argument 1*/\n" + + "{\n" + + " 'Value1': '1'\n" + + "}, /*Argument 2\n" + + " */\n" + + "{\n" + + " 'Value2': '2'\n" + + "});", + // expected + "test( /*Argument 1*/ {\n" + + " 'Value1': '1'\n" + + " },\n" + + " /*Argument 2\n" + + " */\n" + + " {\n" + + " 'Value2': '2'\n" + + " });"); + + opts.brace_style = 'collapse'; + + + bt('a = <?= external() ?> ;'); // not the most perfect thing in the world, but you're the weirdo beaufifying php mix-ins with javascript beautifier + bt('a = <%= external() %> ;'); + + bt('// func-comment\n\nfunction foo() {}\n\n// end-func-comment'); + + test_fragment('roo = {\n /*\n ****\n FOO\n ****\n */\n BAR: 0\n};'); + + bt('"foo""bar""baz"', '"foo"\n"bar"\n"baz"'); + bt("'foo''bar''baz'", "'foo'\n'bar'\n'baz'"); + + + test_fragment("if (zz) {\n // ....\n}\n(function"); + + bt("{\n get foo() {}\n}"); + bt("{\n var a = get\n foo();\n}"); + bt("{\n set foo() {}\n}"); + bt("{\n var a = set\n foo();\n}"); + bt("var x = {\n get function()\n}"); + bt("var x = {\n set function()\n}"); + bt("var x = set\n\na() {}", "var x = set\n\n a() {}"); + bt("var x = set\n\nfunction() {}", "var x = set\n\n function() {}"); + + bt('<!-- foo\nbar();\n-->'); + bt('<!-- dont crash'); + bt('for () /abc/.test()'); + bt('if (k) /aaa/m.test(v) && l();'); + bt('switch (true) {\n case /swf/i.test(foo):\n bar();\n}'); + bt('createdAt = {\n type: Date,\n default: Date.now\n}'); + bt('switch (createdAt) {\n case a:\n Date,\n default:\n Date.now\n}'); + opts.space_before_conditional = false; + bt('if(a) b()'); + opts.space_before_conditional = true; + + + opts.preserve_newlines = true; + bt('var a = 42; // foo\n\nvar b;'); + bt('var a = 42; // foo\n\n\nvar b;'); + bt("var a = 'foo' +\n 'bar';"); + bt("var a = \"foo\" +\n \"bar\";"); + bt('this.oa = new OAuth(\n' + + ' _requestToken,\n' + + ' _accessToken,\n' + + ' consumer_key\n' + + ');'); + + + opts.unescape_strings = false; + test_fragment('"\\x22\\x27", \'\\x22\\x27\', "\\x5c", \'\\x5c\', "\\xff and \\xzz", "unicode \\u0000 \\u0022 \\u0027 \\u005c \\uffff \\uzzzz"'); + opts.unescape_strings = true; + test_fragment('"\\x20\\x40\\x4a"', '" @J"'); + test_fragment('"\\xff\\x40\\x4a"'); + test_fragment('"\\u0072\\u016B\\u0137\\u012B\\u0074\\u0069\\u0073"', '"rūķītis"'); + test_fragment('"Google Chrome est\\u00E1 actualizado."', '"Google Chrome está actualizado."'); + /* + bt('"\\x22\\x27",\'\\x22\\x27\',"\\x5c",\'\\x5c\',"\\xff and \\xzz","unicode \\u0000 \\u0022 \\u0027 \\u005c \\uffff \\uzzzz"', + '"\\"\'", \'"\\\'\', "\\\\", \'\\\\\', "\\xff and \\xzz", "unicode \\u0000 \\" \' \\\\ \\uffff \\uzzzz"'); + */ + opts.unescape_strings = false; + + bt('return function();'); + bt('var a = function();'); + bt('var a = 5 + function();'); + + bt('3.*7;', '3. * 7;'); + bt('import foo.*;', 'import foo.*;'); // actionscript's import + test_fragment('function f(a: a, b: b)'); // actionscript + + bt('{\n foo // something\n ,\n bar // something\n baz\n}'); + bt('function a(a) {} function b(b) {} function c(c) {}', 'function a(a) {}\n\nfunction b(b) {}\n\nfunction c(c) {}'); + bt('foo(a, function() {})'); + + bt('foo(a, /regex/)'); + + bt('/* foo */\n"x"'); + + opts.break_chained_methods = false; + opts.preserve_newlines = false; + bt('foo\n.bar()\n.baz().cucumber(fat)', 'foo.bar().baz().cucumber(fat)'); + bt('foo\n.bar()\n.baz().cucumber(fat); foo.bar().baz().cucumber(fat)', 'foo.bar().baz().cucumber(fat);\nfoo.bar().baz().cucumber(fat)'); + bt('foo\n.bar()\n.baz().cucumber(fat)\n foo.bar().baz().cucumber(fat)', 'foo.bar().baz().cucumber(fat)\nfoo.bar().baz().cucumber(fat)'); + bt('this\n.something = foo.bar()\n.baz().cucumber(fat)', 'this.something = foo.bar().baz().cucumber(fat)'); + bt('this.something.xxx = foo.moo.bar()'); + bt('this\n.something\n.xxx = foo.moo\n.bar()', 'this.something.xxx = foo.moo.bar()'); + + opts.break_chained_methods = false; + opts.preserve_newlines = true; + bt('foo\n.bar()\n.baz().cucumber(fat)', 'foo\n .bar()\n .baz().cucumber(fat)'); + bt('foo\n.bar()\n.baz().cucumber(fat); foo.bar().baz().cucumber(fat)', 'foo\n .bar()\n .baz().cucumber(fat);\nfoo.bar().baz().cucumber(fat)'); + bt('foo\n.bar()\n.baz().cucumber(fat)\n foo.bar().baz().cucumber(fat)', 'foo\n .bar()\n .baz().cucumber(fat)\nfoo.bar().baz().cucumber(fat)'); + bt('this\n.something = foo.bar()\n.baz().cucumber(fat)', 'this\n .something = foo.bar()\n .baz().cucumber(fat)'); + bt('this.something.xxx = foo.moo.bar()'); + bt('this\n.something\n.xxx = foo.moo\n.bar()', 'this\n .something\n .xxx = foo.moo\n .bar()'); + + opts.break_chained_methods = true; + opts.preserve_newlines = false; + bt('foo\n.bar()\n.baz().cucumber(fat)', 'foo.bar()\n .baz()\n .cucumber(fat)'); + bt('foo\n.bar()\n.baz().cucumber(fat); foo.bar().baz().cucumber(fat)', 'foo.bar()\n .baz()\n .cucumber(fat);\nfoo.bar()\n .baz()\n .cucumber(fat)'); + bt('foo\n.bar()\n.baz().cucumber(fat)\n foo.bar().baz().cucumber(fat)', 'foo.bar()\n .baz()\n .cucumber(fat)\nfoo.bar()\n .baz()\n .cucumber(fat)'); + bt('this\n.something = foo.bar()\n.baz().cucumber(fat)', 'this.something = foo.bar()\n .baz()\n .cucumber(fat)'); + bt('this.something.xxx = foo.moo.bar()'); + bt('this\n.something\n.xxx = foo.moo\n.bar()', 'this.something.xxx = foo.moo.bar()'); + + opts.break_chained_methods = true; + opts.preserve_newlines = true; + bt('foo\n.bar()\n.baz().cucumber(fat)', 'foo\n .bar()\n .baz()\n .cucumber(fat)'); + bt('foo\n.bar()\n.baz().cucumber(fat); foo.bar().baz().cucumber(fat)', 'foo\n .bar()\n .baz()\n .cucumber(fat);\nfoo.bar()\n .baz()\n .cucumber(fat)'); + bt('foo\n.bar()\n.baz().cucumber(fat)\n foo.bar().baz().cucumber(fat)', 'foo\n .bar()\n .baz()\n .cucumber(fat)\nfoo.bar()\n .baz()\n .cucumber(fat)'); + bt('this\n.something = foo.bar()\n.baz().cucumber(fat)', 'this\n .something = foo.bar()\n .baz()\n .cucumber(fat)'); + bt('this.something.xxx = foo.moo.bar()'); + bt('this\n.something\n.xxx = foo.moo\n.bar()', 'this\n .something\n .xxx = foo.moo\n .bar()'); + + opts.break_chained_methods = false; + + // Line wrap test intputs + //.............---------1---------2---------3---------4---------5---------6---------7 + //.............1234567890123456789012345678901234567890123456789012345678901234567890 + wrap_input_1=('foo.bar().baz().cucumber((fat && "sassy") || (leans\n&& mean));\n' + + 'Test_very_long_variable_name_this_should_never_wrap\n.but_this_can\n' + + 'if (wraps_can_occur && inside_an_if_block) that_is_\n.okay();\n' + + 'object_literal = {\n' + + ' property: first_token_should_never_wrap + but_this_can,\n' + + ' propertz: first_token_should_never_wrap + !but_this_can,\n' + + ' proper: "first_token_should_never_wrap" + "but_this_can"\n' + + '}'); + + //.............---------1---------2---------3---------4---------5---------6---------7 + //.............1234567890123456789012345678901234567890123456789012345678901234567890 + wrap_input_2=('{\n' + + ' foo.bar().baz().cucumber((fat && "sassy") || (leans\n&& mean));\n' + + ' Test_very_long_variable_name_this_should_never_wrap\n.but_this_can\n' + + ' if (wraps_can_occur && inside_an_if_block) that_is_\n.okay();\n' + + ' object_literal = {\n' + + ' property: first_token_should_never_wrap + but_this_can,\n' + + ' propertz: first_token_should_never_wrap + !but_this_can,\n' + + ' proper: "first_token_should_never_wrap" + "but_this_can"\n' + + ' }' + + '}'); + + opts.preserve_newlines = false; + opts.wrap_line_length = 0; + //.............---------1---------2---------3---------4---------5---------6---------7 + //.............1234567890123456789012345678901234567890123456789012345678901234567890 + test_fragment(wrap_input_1, + /* expected */ + 'foo.bar().baz().cucumber((fat && "sassy") || (leans && mean));\n' + + 'Test_very_long_variable_name_this_should_never_wrap.but_this_can\n' + + 'if (wraps_can_occur && inside_an_if_block) that_is_.okay();\n' + + 'object_literal = {\n' + + ' property: first_token_should_never_wrap + but_this_can,\n' + + ' propertz: first_token_should_never_wrap + !but_this_can,\n' + + ' proper: "first_token_should_never_wrap" + "but_this_can"\n' + + '}'); + + opts.wrap_line_length = 70; + //.............---------1---------2---------3---------4---------5---------6---------7 + //.............1234567890123456789012345678901234567890123456789012345678901234567890 + test_fragment(wrap_input_1, + /* expected */ + 'foo.bar().baz().cucumber((fat && "sassy") || (leans && mean));\n' + + 'Test_very_long_variable_name_this_should_never_wrap.but_this_can\n' + + 'if (wraps_can_occur && inside_an_if_block) that_is_.okay();\n' + + 'object_literal = {\n' + + ' property: first_token_should_never_wrap + but_this_can,\n' + + ' propertz: first_token_should_never_wrap + !but_this_can,\n' + + ' proper: "first_token_should_never_wrap" + "but_this_can"\n' + + '}'); + + opts.wrap_line_length = 40; + //.............---------1---------2---------3---------4---------5---------6---------7 + //.............1234567890123456789012345678901234567890123456789012345678901234567890 + test_fragment(wrap_input_1, + /* expected */ + 'foo.bar().baz().cucumber((fat &&\n' + + ' "sassy") || (leans && mean));\n' + + 'Test_very_long_variable_name_this_should_never_wrap\n' + + ' .but_this_can\n' + + 'if (wraps_can_occur &&\n' + + ' inside_an_if_block) that_is_.okay();\n' + + 'object_literal = {\n' + + ' property: first_token_should_never_wrap +\n' + + ' but_this_can,\n' + + ' propertz: first_token_should_never_wrap +\n' + + ' !but_this_can,\n' + + ' proper: "first_token_should_never_wrap" +\n' + + ' "but_this_can"\n' + + '}'); + + opts.wrap_line_length = 41; + // NOTE: wrap is only best effort - line continues until next wrap point is found. + //.............---------1---------2---------3---------4---------5---------6---------7 + //.............1234567890123456789012345678901234567890123456789012345678901234567890 + test_fragment(wrap_input_1, + /* expected */ + 'foo.bar().baz().cucumber((fat && "sassy") ||\n' + + ' (leans && mean));\n' + + 'Test_very_long_variable_name_this_should_never_wrap\n' + + ' .but_this_can\n' + + 'if (wraps_can_occur &&\n' + + ' inside_an_if_block) that_is_.okay();\n' + + 'object_literal = {\n' + + ' property: first_token_should_never_wrap +\n' + + ' but_this_can,\n' + + ' propertz: first_token_should_never_wrap +\n' + + ' !but_this_can,\n' + + ' proper: "first_token_should_never_wrap" +\n' + + ' "but_this_can"\n' + + '}'); + + opts.wrap_line_length = 45; + // NOTE: wrap is only best effort - line continues until next wrap point is found. + //.............---------1---------2---------3---------4---------5---------6---------7 + //.............1234567890123456789012345678901234567890123456789012345678901234567890 + test_fragment(wrap_input_2, + /* expected */ + '{\n' + + ' foo.bar().baz().cucumber((fat && "sassy") ||\n' + + ' (leans && mean));\n' + + ' Test_very_long_variable_name_this_should_never_wrap\n' + + ' .but_this_can\n' + + ' if (wraps_can_occur &&\n' + + ' inside_an_if_block) that_is_.okay();\n' + + ' object_literal = {\n' + + ' property: first_token_should_never_wrap +\n' + + ' but_this_can,\n' + + ' propertz: first_token_should_never_wrap +\n' + + ' !but_this_can,\n' + + ' proper: "first_token_should_never_wrap" +\n' + + ' "but_this_can"\n' + + ' }\n'+ + '}'); + + opts.preserve_newlines = true; + opts.wrap_line_length = 0; + //.............---------1---------2---------3---------4---------5---------6---------7 + //.............1234567890123456789012345678901234567890123456789012345678901234567890 + test_fragment(wrap_input_1, + /* expected */ + 'foo.bar().baz().cucumber((fat && "sassy") || (leans && mean));\n' + + 'Test_very_long_variable_name_this_should_never_wrap\n' + + ' .but_this_can\n' + + 'if (wraps_can_occur && inside_an_if_block) that_is_\n' + + ' .okay();\n' + + 'object_literal = {\n' + + ' property: first_token_should_never_wrap + but_this_can,\n' + + ' propertz: first_token_should_never_wrap + !but_this_can,\n' + + ' proper: "first_token_should_never_wrap" + "but_this_can"\n' + + '}'); + + opts.wrap_line_length = 70; + //.............---------1---------2---------3---------4---------5---------6---------7 + //.............1234567890123456789012345678901234567890123456789012345678901234567890 + test_fragment(wrap_input_1, + /* expected */ + 'foo.bar().baz().cucumber((fat && "sassy") || (leans && mean));\n' + + 'Test_very_long_variable_name_this_should_never_wrap\n' + + ' .but_this_can\n' + + 'if (wraps_can_occur && inside_an_if_block) that_is_\n' + + ' .okay();\n' + + 'object_literal = {\n' + + ' property: first_token_should_never_wrap + but_this_can,\n' + + ' propertz: first_token_should_never_wrap + !but_this_can,\n' + + ' proper: "first_token_should_never_wrap" + "but_this_can"\n' + + '}'); + + + opts.wrap_line_length = 40; + //.............---------1---------2---------3---------4---------5---------6---------7 + //.............1234567890123456789012345678901234567890123456789012345678901234567890 + test_fragment(wrap_input_1, + /* expected */ + 'foo.bar().baz().cucumber((fat &&\n' + + ' "sassy") || (leans && mean));\n' + + 'Test_very_long_variable_name_this_should_never_wrap\n' + + ' .but_this_can\n' + + 'if (wraps_can_occur &&\n' + + ' inside_an_if_block) that_is_\n' + + ' .okay();\n' + + 'object_literal = {\n' + + ' property: first_token_should_never_wrap +\n' + + ' but_this_can,\n' + + ' propertz: first_token_should_never_wrap +\n' + + ' !but_this_can,\n' + + ' proper: "first_token_should_never_wrap" +\n' + + ' "but_this_can"\n' + + '}'); + + opts.wrap_line_length = 41; + // NOTE: wrap is only best effort - line continues until next wrap point is found. + //.............---------1---------2---------3---------4---------5---------6---------7 + //.............1234567890123456789012345678901234567890123456789012345678901234567890 + test_fragment(wrap_input_1, + /* expected */ + 'foo.bar().baz().cucumber((fat && "sassy") ||\n' + + ' (leans && mean));\n' + + 'Test_very_long_variable_name_this_should_never_wrap\n' + + ' .but_this_can\n' + + 'if (wraps_can_occur &&\n' + + ' inside_an_if_block) that_is_\n' + + ' .okay();\n' + + 'object_literal = {\n' + + ' property: first_token_should_never_wrap +\n' + + ' but_this_can,\n' + + ' propertz: first_token_should_never_wrap +\n' + + ' !but_this_can,\n' + + ' proper: "first_token_should_never_wrap" +\n' + + ' "but_this_can"\n' + + '}'); + + opts.wrap_line_length = 45; + // NOTE: wrap is only best effort - line continues until next wrap point is found. + //.............---------1---------2---------3---------4---------5---------6---------7 + //.............1234567890123456789012345678901234567890123456789012345678901234567890 + test_fragment(wrap_input_2, + /* expected */ + '{\n' + + ' foo.bar().baz().cucumber((fat && "sassy") ||\n' + + ' (leans && mean));\n' + + ' Test_very_long_variable_name_this_should_never_wrap\n' + + ' .but_this_can\n' + + ' if (wraps_can_occur &&\n' + + ' inside_an_if_block) that_is_\n' + + ' .okay();\n' + + ' object_literal = {\n' + + ' property: first_token_should_never_wrap +\n' + + ' but_this_can,\n' + + ' propertz: first_token_should_never_wrap +\n' + + ' !but_this_can,\n' + + ' proper: "first_token_should_never_wrap" +\n' + + ' "but_this_can"\n' + + ' }\n'+ + '}'); + + opts.wrap_line_length = 0; + + opts.preserve_newlines = false; + bt('if (foo) // comment\n bar();'); + bt('if (foo) // comment\n (bar());'); + bt('if (foo) // comment\n (bar());'); + bt('if (foo) // comment\n /asdf/;'); + bt('this.oa = new OAuth(\n' + + ' _requestToken,\n' + + ' _accessToken,\n' + + ' consumer_key\n' + + ');', + 'this.oa = new OAuth(_requestToken, _accessToken, consumer_key);'); + bt('foo = {\n x: y, // #44\n w: z // #44\n}'); + bt('switch (x) {\n case "a":\n // comment on newline\n break;\n case "b": // comment on same line\n break;\n}'); + bt('this.type =\n this.options =\n // comment\n this.enabled null;', + 'this.type = this.options =\n // comment\n this.enabled null;'); + bt('someObj\n .someFunc1()\n // This comment should not break the indent\n .someFunc2();', + 'someObj.someFunc1()\n // This comment should not break the indent\n .someFunc2();'); + + bt('if (true ||\n!true) return;', 'if (true || !true) return;'); + + // these aren't ready yet. + //bt('if (foo) // comment\n bar() /*i*/ + baz() /*j\n*/ + asdf();'); + bt('if\n(foo)\nif\n(bar)\nif\n(baz)\nwhee();\na();', + 'if (foo)\n if (bar)\n if (baz) whee();\na();'); + bt('if\n(foo)\nif\n(bar)\nif\n(baz)\nwhee();\nelse\na();', + 'if (foo)\n if (bar)\n if (baz) whee();\n else a();'); + bt('if (foo)\nbar();\nelse\ncar();', + 'if (foo) bar();\nelse car();'); + + bt('if (foo) if (bar) if (baz);\na();', + 'if (foo)\n if (bar)\n if (baz);\na();'); + bt('if (foo) if (bar) if (baz) whee();\na();', + 'if (foo)\n if (bar)\n if (baz) whee();\na();'); + bt('if (foo) a()\nif (bar) if (baz) whee();\na();', + 'if (foo) a()\nif (bar)\n if (baz) whee();\na();'); + bt('if (foo);\nif (bar) if (baz) whee();\na();', + 'if (foo);\nif (bar)\n if (baz) whee();\na();'); + bt('if (options)\n' + + ' for (var p in options)\n' + + ' this[p] = options[p];', + 'if (options)\n'+ + ' for (var p in options) this[p] = options[p];'); + bt('if (options) for (var p in options) this[p] = options[p];', + 'if (options)\n for (var p in options) this[p] = options[p];'); + + bt('if (options) do q(); while (b());', + 'if (options)\n do q(); while (b());'); + bt('if (options) while (b()) q();', + 'if (options)\n while (b()) q();'); + bt('if (options) do while (b()) q(); while (a());', + 'if (options)\n do\n while (b()) q(); while (a());'); + + bt('function f(a, b, c,\nd, e) {}', + 'function f(a, b, c, d, e) {}'); + + bt('function f(a,b) {if(a) b()}function g(a,b) {if(!a) b()}', + 'function f(a, b) {\n if (a) b()\n}\n\nfunction g(a, b) {\n if (!a) b()\n}'); + bt('function f(a,b) {if(a) b()}\n\n\n\nfunction g(a,b) {if(!a) b()}', + 'function f(a, b) {\n if (a) b()\n}\n\nfunction g(a, b) {\n if (!a) b()\n}'); + + // This is not valid syntax, but still want to behave reasonably and not side-effect + bt('(if(a) b())(if(a) b())', + '(\n if (a) b())(\n if (a) b())'); + bt('(if(a) b())\n\n\n(if(a) b())', + '(\n if (a) b())\n(\n if (a) b())'); + + + + bt("if\n(a)\nb();", "if (a) b();"); + bt('var a =\nfoo', 'var a = foo'); + bt('var a = {\n"a":1,\n"b":2}', "var a = {\n \"a\": 1,\n \"b\": 2\n}"); + bt("var a = {\n'a':1,\n'b':2}", "var a = {\n 'a': 1,\n 'b': 2\n}"); + bt('var a = /*i*/ "b";'); + bt('var a = /*i*/\n"b";', 'var a = /*i*/ "b";'); + bt('var a = /*i*/\nb;', 'var a = /*i*/ b;'); + bt('{\n\n\n"x"\n}', '{\n "x"\n}'); + bt('if(a &&\nb\n||\nc\n||d\n&&\ne) e = f', 'if (a && b || c || d && e) e = f'); + bt('if(a &&\n(b\n||\nc\n||d)\n&&\ne) e = f', 'if (a && (b || c || d) && e) e = f'); + test_fragment('\n\n"x"', '"x"'); + bt('a = 1;\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nb = 2;', + 'a = 1;\nb = 2;'); + + opts.preserve_newlines = true; + bt('if (foo) // comment\n bar();'); + bt('if (foo) // comment\n (bar());'); + bt('if (foo) // comment\n (bar());'); + bt('if (foo) // comment\n /asdf/;'); + bt('foo = {\n x: y, // #44\n w: z // #44\n}'); + bt('switch (x) {\n case "a":\n // comment on newline\n break;\n case "b": // comment on same line\n break;\n}'); + bt('this.type =\n this.options =\n // comment\n this.enabled null;'); + bt('someObj\n .someFunc1()\n // This comment should not break the indent\n .someFunc2();'); + + bt('if (true ||\n!true) return;', 'if (true ||\n !true) return;'); + + // these aren't ready yet. + // bt('if (foo) // comment\n bar() /*i*/ + baz() /*j\n*/ + asdf();'); + bt('if\n(foo)\nif\n(bar)\nif\n(baz)\nwhee();\na();', + 'if (foo)\n if (bar)\n if (baz)\n whee();\na();'); + bt('if\n(foo)\nif\n(bar)\nif\n(baz)\nwhee();\nelse\na();', + 'if (foo)\n if (bar)\n if (baz)\n whee();\n else\n a();'); + bt('if (foo) bar();\nelse\ncar();', + 'if (foo) bar();\nelse\n car();'); + + bt('if (foo) if (bar) if (baz);\na();', + 'if (foo)\n if (bar)\n if (baz);\na();'); + bt('if (foo) if (bar) if (baz) whee();\na();', + 'if (foo)\n if (bar)\n if (baz) whee();\na();'); + bt('if (foo) a()\nif (bar) if (baz) whee();\na();', + 'if (foo) a()\nif (bar)\n if (baz) whee();\na();'); + bt('if (foo);\nif (bar) if (baz) whee();\na();', + 'if (foo);\nif (bar)\n if (baz) whee();\na();'); + bt('if (options)\n' + + ' for (var p in options)\n' + + ' this[p] = options[p];'); + bt('if (options) for (var p in options) this[p] = options[p];', + 'if (options)\n for (var p in options) this[p] = options[p];'); + + bt('if (options) do q(); while (b());', + 'if (options)\n do q(); while (b());'); + bt('if (options) do; while (b());', + 'if (options)\n do; while (b());'); + bt('if (options) while (b()) q();', + 'if (options)\n while (b()) q();'); + bt('if (options) do while (b()) q(); while (a());', + 'if (options)\n do\n while (b()) q(); while (a());'); + + bt('function f(a, b, c,\nd, e) {}', + 'function f(a, b, c,\n d, e) {}'); + + bt('function f(a,b) {if(a) b()}function g(a,b) {if(!a) b()}', + 'function f(a, b) {\n if (a) b()\n}\n\nfunction g(a, b) {\n if (!a) b()\n}'); + bt('function f(a,b) {if(a) b()}\n\n\n\nfunction g(a,b) {if(!a) b()}', + 'function f(a, b) {\n if (a) b()\n}\n\n\n\nfunction g(a, b) {\n if (!a) b()\n}'); + // This is not valid syntax, but still want to behave reasonably and not side-effect + bt('(if(a) b())(if(a) b())', + '(\n if (a) b())(\n if (a) b())'); + bt('(if(a) b())\n\n\n(if(a) b())', + '(\n if (a) b())\n\n\n(\n if (a) b())'); + + // space between functions + bt('/*\n * foo\n */\nfunction foo() {}'); + bt('// a nice function\nfunction foo() {}'); + bt('function foo() {}\nfunction foo() {}', + 'function foo() {}\n\nfunction foo() {}' + ); + + + + bt("if\n(a)\nb();", "if (a)\n b();"); + bt('var a =\nfoo', 'var a =\n foo'); + bt('var a = {\n"a":1,\n"b":2}', "var a = {\n \"a\": 1,\n \"b\": 2\n}"); + bt("var a = {\n'a':1,\n'b':2}", "var a = {\n 'a': 1,\n 'b': 2\n}"); + bt('var a = /*i*/ "b";'); + bt('var a = /*i*/\n"b";', 'var a = /*i*/\n "b";'); + bt('var a = /*i*/\nb;', 'var a = /*i*/\n b;'); + bt('{\n\n\n"x"\n}', '{\n\n\n "x"\n}'); + bt('if(a &&\nb\n||\nc\n||d\n&&\ne) e = f', 'if (a &&\n b ||\n c || d &&\n e) e = f'); + bt('if(a &&\n(b\n||\nc\n||d)\n&&\ne) e = f', 'if (a &&\n (b ||\n c || d) &&\n e) e = f'); + test_fragment('\n\n"x"', '"x"'); + + // this beavior differs between js and python, defaults to unlimited in js, 10 in python + bt('a = 1;\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nb = 2;', + 'a = 1;\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nb = 2;'); + opts.max_preserve_newlines = 8; + bt('a = 1;\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nb = 2;', + 'a = 1;\n\n\n\n\n\n\n\nb = 2;'); + + // Test the option to have spaces within parens + opts.space_in_paren = false; + bt('if(p) foo(a,b)', 'if (p) foo(a, b)'); + bt('try{while(true){willThrow()}}catch(result)switch(result){case 1:++result }', + 'try {\n while (true) {\n willThrow()\n }\n} catch (result) switch (result) {\n case 1:\n ++result\n}'); + bt('((e/((a+(b)*c)-d))^2)*5;', '((e / ((a + (b) * c) - d)) ^ 2) * 5;'); + bt('function f(a,b) {if(a) b()}function g(a,b) {if(!a) b()}', + 'function f(a, b) {\n if (a) b()\n}\n\nfunction g(a, b) {\n if (!a) b()\n}'); + bt('a=[];', + 'a = [];'); + bt('a=[b,c,d];', + 'a = [b, c, d];'); + bt('a= f[b];', + 'a = f[b];'); + opts.space_in_paren = true; + bt('if(p) foo(a,b)', 'if ( p ) foo( a, b )'); + bt('try{while(true){willThrow()}}catch(result)switch(result){case 1:++result }', + 'try {\n while ( true ) {\n willThrow()\n }\n} catch ( result ) switch ( result ) {\n case 1:\n ++result\n}'); + bt('((e/((a+(b)*c)-d))^2)*5;', '( ( e / ( ( a + ( b ) * c ) - d ) ) ^ 2 ) * 5;'); + bt('function f(a,b) {if(a) b()}function g(a,b) {if(!a) b()}', + 'function f( a, b ) {\n if ( a ) b()\n}\n\nfunction g( a, b ) {\n if ( !a ) b()\n}'); + bt('a=[];', + 'a = [];'); + bt('a=[b,c,d];', + 'a = [ b, c, d ];'); + bt('a= f[b];', + 'a = f[ b ];'); + opts.space_in_empty_paren = true; + bt('if(p) foo(a,b)', 'if ( p ) foo( a, b )'); + bt('try{while(true){willThrow()}}catch(result)switch(result){case 1:++result }', + 'try {\n while ( true ) {\n willThrow( )\n }\n} catch ( result ) switch ( result ) {\n case 1:\n ++result\n}'); + bt('((e/((a+(b)*c)-d))^2)*5;', '( ( e / ( ( a + ( b ) * c ) - d ) ) ^ 2 ) * 5;'); + bt('function f(a,b) {if(a) b()}function g(a,b) {if(!a) b()}', + 'function f( a, b ) {\n if ( a ) b( )\n}\n\nfunction g( a, b ) {\n if ( !a ) b( )\n}'); + bt('a=[];', + 'a = [ ];'); + bt('a=[b,c,d];', + 'a = [ b, c, d ];'); + bt('a= f[b];', + 'a = f[ b ];'); + opts.space_in_empty_paren = false; + opts.space_in_paren = false; + + // Test template strings + bt('`This is a ${template} string.`', '`This is a ${template} string.`'); + bt('`This\n is\n a\n ${template}\n string.`', '`This\n is\n a\n ${template}\n string.`'); + + // Test that e4x literals passed through when e4x-option is enabled + bt('xml=<a b="c"><d/><e>\n foo</e>x</a>;', 'xml = < a b = "c" > < d / > < e >\n foo < /e>x</a > ;'); + opts.e4x = true; + bt('xml=<a b="c"><d/><e>\n foo</e>x</a>;', 'xml = <a b="c"><d/><e>\n foo</e>x</a>;'); + bt('<a b=\'This is a quoted "c".\'/>', '<a b=\'This is a quoted "c".\'/>'); + bt('<a b="This is a quoted \'c\'."/>', '<a b="This is a quoted \'c\'."/>'); + bt('<a b="A quote \' inside string."/>', '<a b="A quote \' inside string."/>'); + bt('<a b=\'A quote " inside string.\'/>', '<a b=\'A quote " inside string.\'/>'); + bt('<a b=\'Some """ quotes "" inside string.\'/>', '<a b=\'Some """ quotes "" inside string.\'/>'); + // Handles inline expressions + bt('xml=<{a} b="c"><d/><e v={z}>\n foo</e>x</{a}>;', 'xml = <{a} b="c"><d/><e v={z}>\n foo</e>x</{a}>;'); + // xml literals with special characters in elem names + // see http://www.w3.org/TR/REC-xml/#NT-NameChar + bt('xml = <_:.valid.xml- _:.valid.xml-="123"/>;', 'xml = <_:.valid.xml- _:.valid.xml-="123"/>;'); + // Handles CDATA + bt('xml=<![CDATA[ b="c"><d/><e v={z}>\n foo</e>x/]]>;', 'xml = <![CDATA[ b="c"><d/><e v={z}>\n foo</e>x/]]>;'); + bt('xml=<![CDATA[]]>;', 'xml = <![CDATA[]]>;'); + bt('xml=<a b="c"><![CDATA[d/></a></{}]]></a>;', 'xml = <a b="c"><![CDATA[d/></a></{}]]></a>;'); + + // Handles messed up tags, as long as it isn't the same name + // as the root tag. Also handles tags of same name as root tag + // as long as nesting matches. + bt('xml=<a x="jn"><c></b></f><a><d jnj="jnn"><f></a ></nj></a>;', + 'xml = <a x="jn"><c></b></f><a><d jnj="jnn"><f></a ></nj></a>;'); + // If xml is not terminated, the remainder of the file is treated + // as part of the xml-literal (passed through unaltered) + test_fragment('xml=<a></b>\nc<b;', 'xml = <a></b>\nc<b;'); + opts.e4x = false; + + // START tests for issue 241 + bt('obj\n' + + ' .last({\n' + + ' foo: 1,\n' + + ' bar: 2\n' + + ' });\n' + + 'var test = 1;'); + + bt('obj\n' + + ' .last(a, function() {\n' + + ' var test;\n' + + ' });\n' + + 'var test = 1;'); + + bt('obj.first()\n' + + ' .second()\n' + + ' .last(function(err, response) {\n' + + ' console.log(err);\n' + + ' });'); + + // END tests for issue 241 + + + // START tests for issue 268 and 275 + bt('obj.last(a, function() {\n' + + ' var test;\n' + + '});\n' + + 'var test = 1;'); + bt('obj.last(a,\n' + + ' function() {\n' + + ' var test;\n' + + ' });\n' + + 'var test = 1;'); + + bt('(function() {if (!window.FOO) window.FOO || (window.FOO = function() {var b = {bar: "zort"};});})();', + '(function() {\n' + + ' if (!window.FOO) window.FOO || (window.FOO = function() {\n' + + ' var b = {\n' + + ' bar: "zort"\n' + + ' };\n' + + ' });\n' + + '})();'); + // END tests for issue 268 and 275 + + // START tests for issue 281 + bt('define(["dojo/_base/declare", "my/Employee", "dijit/form/Button",\n' + + ' "dojo/_base/lang", "dojo/Deferred"\n' + + '], function(declare, Employee, Button, lang, Deferred) {\n' + + ' return declare(Employee, {\n' + + ' constructor: function() {\n' + + ' new Button({\n' + + ' onClick: lang.hitch(this, function() {\n' + + ' new Deferred().then(lang.hitch(this, function() {\n' + + ' this.salary * 0.25;\n' + + ' }));\n' + + ' })\n' + + ' });\n' + + ' }\n' + + ' });\n' + + '});'); + + bt('define(["dojo/_base/declare", "my/Employee", "dijit/form/Button",\n' + + ' "dojo/_base/lang", "dojo/Deferred"\n' + + ' ],\n' + + ' function(declare, Employee, Button, lang, Deferred) {\n' + + ' return declare(Employee, {\n' + + ' constructor: function() {\n' + + ' new Button({\n' + + ' onClick: lang.hitch(this, function() {\n' + + ' new Deferred().then(lang.hitch(this, function() {\n' + + ' this.salary * 0.25;\n' + + ' }));\n' + + ' })\n' + + ' });\n' + + ' }\n' + + ' });\n' + + ' });'); + // END tests for issue 281 + + // START tests for issue 459 + bt( '(function() {\n' + + ' return {\n' + + ' foo: function() {\n' + + ' return "bar";\n' + + ' },\n' + + ' bar: ["bar"]\n' + + ' };\n' + + '}());'); + // END tests for issue 459 + + bt('var a=1,b={bang:2},c=3;', + 'var a = 1,\n b = {\n bang: 2\n },\n c = 3;'); + bt('var a={bing:1},b=2,c=3;', + 'var a = {\n bing: 1\n },\n b = 2,\n c = 3;'); + Urlencoded.run_tests(sanitytest); + + bth(''); + bth('<div></div>'); + bth('<div>content</div>'); + bth('<div><div></div></div>', + '<div>\n' + + ' <div></div>\n' + + '</div>'); + bth('<div><div>content</div></div>', + '<div>\n' + + ' <div>content</div>\n' + + '</div>'); + bth('<div>\n' + + ' <span>content</span>\n' + + '</div>'); + bth('<div>\n' + + '</div>'); + bth('<div>\n' + + ' content\n' + + '</div>'); + bth('<div>\n' + + ' </div>', + '<div>\n' + + '</div>'); + bth(' <div>\n' + + ' </div>', + '<div>\n' + + '</div>'); + bth(' <div>\n' + + '</div>', + '<div>\n' + + '</div>'); + bth('<div >content</div>', + '<div>content</div>'); + bth('<div thinger="preserve space here" ></div >', + '<div thinger="preserve space here"></div>'); + bth('content\n' + + ' <div>\n' + + ' </div>\n' + + 'content', + 'content\n' + + '<div>\n' + + '</div>\n' + + 'content'); + bth('<li>\n' + + ' <div>\n' + + ' </div>\n' + + '</li>'); + bth('<li>\n' + + '<div>\n' + + '</div>\n' + + '</li>', + '<li>\n' + + ' <div>\n' + + ' </div>\n' + + '</li>'); + bth('<li>\n' + + ' content\n' + + '</li>\n' + + '<li>\n' + + ' content\n' + + '</li>'); + + // START tests for issue 453 + bth('<script type="text/unknown"><div></div></script>', + '<script type="text/unknown">\n' + + ' <div></div>\n' + + '</script>'); + bth('<script type="text/javascript"><div></div></script>', + '<script type="text/javascript">\n' + + ' < div > < /div>\n' + + '</script>'); + bth('<script><div></div></script>', + '<script>\n' + + ' < div > < /div>\n' + + '</script>'); + bth('<script type="text/javascript">var foo = "bar";</script>', + '<script type="text/javascript">\n' + + ' var foo = "bar";\n' + + '</script>'); + bth('<script type="application/javascript">var foo = "bar";</script>', + '<script type="application/javascript">\n' + + ' var foo = "bar";\n' + + '</script>'); + bth('<script type="application/javascript;version=1.8">var foo = "bar";</script>', + '<script type="application/javascript;version=1.8">\n' + + ' var foo = "bar";\n' + + '</script>'); + bth('<script type="application/x-javascript">var foo = "bar";</script>', + '<script type="application/x-javascript">\n' + + ' var foo = "bar";\n' + + '</script>'); + bth('<script type="application/ecmascript">var foo = "bar";</script>', + '<script type="application/ecmascript">\n' + + ' var foo = "bar";\n' + + '</script>'); + bth('<script type="text/javascript1.5">var foo = "bar";</script>', + '<script type="text/javascript1.5">\n' + + ' var foo = "bar";\n' + + '</script>'); + bth('<script>var foo = "bar";</script>', + '<script>\n' + + ' var foo = "bar";\n' + + '</script>'); + + bth('<style type="text/unknown"><tag></tag></style>', + '<style type="text/unknown">\n' + + ' <tag></tag>\n' + + '</style>'); + bth('<style type="text/css"><tag></tag></style>', + '<style type="text/css">\n' + + ' <tag></tag>\n' + + '</style>'); + bth('<style><tag></tag></style>', + '<style>\n' + + ' <tag></tag>\n' + + '</style>'); + bth('<style type="text/css">.selector {font-size:12px;}</style>', + '<style type="text/css">\n' + + ' .selector {\n' + + ' font-size: 12px;\n' + + ' }\n'+ + '</style>'); + bth('<style>.selector {font-size:12px;}</style>', + '<style>\n' + + ' .selector {\n' + + ' font-size: 12px;\n' + + ' }\n'+ + '</style>'); + // END tests for issue 453 + + // Tests that don't pass, but probably should. + // bth('<div><span>content</span></div>'); + + // Handlebars tests + // Without the indent option on, handlebars are treated as content. + opts.indent_handlebars = false; + bth('{{#if 0}}\n' + + ' <div>\n' + + ' </div>\n' + + '{{/if}}', + '{{#if 0}}\n' + + '<div>\n' + + '</div>\n' + + '{{/if}}'); + bth('<div>\n' + + '{{#each thing}}\n' + + ' {{name}}\n' + + '{{/each}}\n' + + '</div>', + '<div>\n' + + ' {{#each thing}} {{name}} {{/each}}\n' + + '</div>'); + + opts.indent_handlebars = true; + bth('{{#if 0}}{{/if}}'); + bth('{{#if 0}}content{{/if}}'); + bth('{{#if 0}}\n' + + '{{/if}}'); + bth('{{#if words}}{{/if}}', + '{{#if words}}{{/if}}'); + bth('{{#if words}}content{{/if}}', + '{{#if words}}content{{/if}}'); + bth('{{#if words}}content{{/if}}', + '{{#if words}}content{{/if}}'); + bth('{{#if 1}}\n' + + ' <div>\n' + + ' </div>\n' + + '{{/if}}'); + bth('{{#if 1}}\n' + + '<div>\n' + + '</div>\n' + + '{{/if}}', + '{{#if 1}}\n' + + ' <div>\n' + + ' </div>\n' + + '{{/if}}'); + bth('<div>\n' + + ' {{#if 1}}\n' + + ' {{/if}}\n' + + '</div>'); + bth('<div>\n' + + '{{#if 1}}\n' + + '{{/if}}\n' + + '</div>', + '<div>\n' + + ' {{#if 1}}\n' + + ' {{/if}}\n' + + '</div>'); + bth('{{#if}}\n' + + '{{#each}}\n' + + '{{#if}}\n' + + 'content\n' + + '{{/if}}\n' + + '{{#if}}\n' + + 'content\n' + + '{{/if}}\n' + + '{{/each}}\n' + + '{{/if}}', + '{{#if}}\n' + + ' {{#each}}\n' + + ' {{#if}}\n' + + ' content\n' + + ' {{/if}}\n' + + ' {{#if}}\n' + + ' content\n' + + ' {{/if}}\n' + + ' {{/each}}\n' + + '{{/if}}'); + bth('{{#if 1}}\n' + + ' <div>\n' + + ' </div>\n' + + '{{/if}}'); + + // Test {{else}} aligned with {{#if}} and {{/if}} + bth('{{#if 1}}\n' + + ' content\n' + + ' {{else}}\n' + + ' content\n' + + '{{/if}}', + '{{#if 1}}\n' + + ' content\n' + + '{{else}}\n' + + ' content\n' + + '{{/if}}'); + bth('{{#if 1}}\n' + + ' {{else}}\n' + + ' {{/if}}', + '{{#if 1}}\n' + + '{{else}}\n' + + '{{/if}}'); + bth('{{#if thing}}\n' + + '{{#if otherthing}}\n' + + ' content\n' + + ' {{else}}\n' + + 'content\n' + + ' {{/if}}\n' + + ' {{else}}\n'+ + 'content\n' + + '{{/if}}', + '{{#if thing}}\n' + + ' {{#if otherthing}}\n' + + ' content\n' + + ' {{else}}\n' + + ' content\n' + + ' {{/if}}\n' + + '{{else}}\n'+ + ' content\n' + + '{{/if}}'); + + // Test {{}} inside of <> tags, which should be separated by spaces + // for readability, unless they are inside a string. + bth('<div{{somestyle}}></div>', + '<div {{somestyle}}></div>'); + bth('<div{{#if test}}class="foo"{{/if}}>content</div>', + '<div {{#if test}} class="foo" {{/if}}>content</div>'); + bth('<div{{#if thing}}{{somestyle}}class="{{class}}"{{else}}class="{{class2}}"{{/if}}>content</div>', + '<div {{#if thing}} {{somestyle}} class="{{class}}" {{else}} class="{{class2}}" {{/if}}>content</div>'); + bth('<span{{#if condition}}class="foo"{{/if}}>content</span>', + '<span {{#if condition}} class="foo" {{/if}}>content</span>'); + bth('<div unformatted="{{#if}}content{{/if}}">content</div>'); + bth('<div unformatted="{{#if }} content{{/if}}">content</div>'); + + // Quotes found inside of Handlebars expressions inside of quoted + // strings themselves should not be considered string delimiters. + bth('<div class="{{#if thingIs "value"}}content{{/if}}"></div>'); + bth('<div class="{{#if thingIs \'value\'}}content{{/if}}"></div>'); + bth('<div class=\'{{#if thingIs "value"}}content{{/if}}\'></div>'); + bth('<div class=\'{{#if thingIs \'value\'}}content{{/if}}\'></div>'); + + opts.wrap_line_length = 0; + //...---------1---------2---------3---------4---------5---------6---------7 + //...1234567890123456789012345678901234567890123456789012345678901234567890 + bth('<div>Some text that should not wrap at all.</div>', + /* expected */ + '<div>Some text that should not wrap at all.</div>'); + + // A value of 0 means no max line length, and should not wrap. + //...---------1---------2---------3---------4---------5---------6---------7---------8---------9--------10--------11--------12--------13--------14--------15--------16--------17--------18--------19--------20--------21--------22--------23--------24--------25--------26--------27--------28--------29 + //...12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890 + bth('<div>Some text that should not wrap at all. Some text that should not wrap at all. Some text that should not wrap at all. Some text that should not wrap at all. Some text that should not wrap at all. Some text that should not wrap at all. Some text that should not wrap at all.</div>', + /* expected */ + '<div>Some text that should not wrap at all. Some text that should not wrap at all. Some text that should not wrap at all. Some text that should not wrap at all. Some text that should not wrap at all. Some text that should not wrap at all. Some text that should not wrap at all.</div>'); + + opts.wrap_line_length = "0"; + //...---------1---------2---------3---------4---------5---------6---------7 + //...1234567890123456789012345678901234567890123456789012345678901234567890 + bth('<div>Some text that should not wrap at all.</div>', + /* expected */ + '<div>Some text that should not wrap at all.</div>'); + + // A value of "0" means no max line length, and should not wrap + //...---------1---------2---------3---------4---------5---------6---------7---------8---------9--------10--------11--------12--------13--------14--------15--------16--------17--------18--------19--------20--------21--------22--------23--------24--------25--------26--------27--------28--------29 + //...12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890 + bth('<div>Some text that should not wrap at all. Some text that should not wrap at all. Some text that should not wrap at all. Some text that should not wrap at all. Some text that should not wrap at all. Some text that should not wrap at all. Some text that should not wrap at all.</div>', + /* expected */ + '<div>Some text that should not wrap at all. Some text that should not wrap at all. Some text that should not wrap at all. Some text that should not wrap at all. Some text that should not wrap at all. Some text that should not wrap at all. Some text that should not wrap at all.</div>'); + + //BUGBUG: This should wrap before 40 not after. + opts.wrap_line_length = 40; + //...---------1---------2---------3---------4---------5---------6---------7 + //...1234567890123456789012345678901234567890123456789012345678901234567890 + bth('<div>Some test text that should wrap_inside_this section here.</div>', + /* expected */ + '<div>Some test text that should wrap_inside_this\n' + + ' section here.</div>'); + + opts.wrap_line_length = "40"; + //...---------1---------2---------3---------4---------5---------6---------7 + //...1234567890123456789012345678901234567890123456789012345678901234567890 + bth('<div>Some test text that should wrap_inside_this section here.</div>', + /* expected */ + '<div>Some test text that should wrap_inside_this\n' + + ' section here.</div>'); + + opts.indent_size = 1; + opts.indent_char = '\t'; + opts.preserve_newlines = false; + bth('<div>\n\tfoo\n</div>', '<div>foo</div>'); + + opts.preserve_newlines = true; + bth('<div>\n\tfoo\n</div>'); + + + + // test preserve_newlines and max_preserve_newlines + opts.preserve_newlines = false; + test_fragment('<div>Should not</div>\n\n\n' + + '<div>preserve newlines</div>', + '<div>Should not</div>\n' + + '<div>preserve newlines</div>'); + + opts.preserve_newlines = true; + opts.max_preserve_newlines = 0; + test_fragment('<div>Should</div>\n\n\n' + + '<div>preserve zero newlines</div>', + '<div>Should</div>\n' + + '<div>preserve zero newlines</div>'); + + opts.max_preserve_newlines = 1; + test_fragment('<div>Should</div>\n\n\n' + + '<div>preserve one newline</div>', + '<div>Should</div>\n\n' + + '<div>preserve one newline</div>'); + + opts.max_preserve_newlines = null; + test_fragment('<div>Should</div>\n\n\n' + + '<div>preserve one newline</div>', + '<div>Should</div>\n\n\n' + + '<div>preserve one newline</div>'); + // css beautifier + opts.indent_size = 1; + opts.indent_char = '\t'; + opts.selector_separator_newline = true; + opts.end_with_newline = true; + + // test basic css beautifier + btc('', '\n'); + btc(".tabs{}", ".tabs {}\n"); + btc(".tabs{color:red;}", ".tabs {\n\tcolor: red;\n}\n"); + btc(".tabs{color:rgb(255, 255, 0)}", ".tabs {\n\tcolor: rgb(255, 255, 0)\n}\n"); + btc(".tabs{background:url('back.jpg')}", ".tabs {\n\tbackground: url('back.jpg')\n}\n"); + btc("#bla, #foo{color:red}", "#bla,\n#foo {\n\tcolor: red\n}\n"); + btc("@media print {.tab{}}", "@media print {\n\t.tab {}\n}\n"); + btc("@media print {.tab{background-image:url(foo@2x.png)}}", "@media print {\n\t.tab {\n\t\tbackground-image: url(foo@2x.png)\n\t}\n}\n"); + + // comments + btc("/* test */", "/* test */\n"); + btc(".tabs{/* test */}", ".tabs {\n\t/* test */\n}\n"); + btc("/* header */.tabs {}", "/* header */\n\n.tabs {}\n"); + + //single line comment support (less/sass) + btc(".tabs{\n// comment\nwidth:10px;\n}", ".tabs {\n\t// comment\n\twidth: 10px;\n}\n"); + btc(".tabs{// comment\nwidth:10px;\n}", ".tabs {\n\t// comment\n\twidth: 10px;\n}\n"); + btc("//comment\n.tabs{width:10px;}", "//comment\n.tabs {\n\twidth: 10px;\n}\n"); + btc(".tabs{//comment\n//2nd single line comment\nwidth:10px;}", ".tabs {\n\t//comment\n\t//2nd single line comment\n\twidth: 10px;\n}\n"); + btc(".tabs{width:10px;//end of line comment\n}", ".tabs {\n\twidth: 10px;//end of line comment\n}\n"); + btc(".tabs{width:10px;//end of line comment\nheight:10px;}", ".tabs {\n\twidth: 10px;//end of line comment\n\theight: 10px;\n}\n"); + btc(".tabs{width:10px;//end of line comment\nheight:10px;//another\n}", ".tabs {\n\twidth: 10px;//end of line comment\n\theight: 10px;//another\n}\n"); + + // separate selectors + btc("#bla, #foo{color:red}", "#bla,\n#foo {\n\tcolor: red\n}\n"); + btc("a, img {padding: 0.2px}", "a,\nimg {\n\tpadding: 0.2px\n}\n"); + + // block nesting + btc("#foo {\n\tbackground-image: url(foo@2x.png);\n\t@font-face {\n\t\tfont-family: 'Bitstream Vera Serif Bold';\n\t\tsrc: url('http://developer.mozilla.org/@api/deki/files/2934/=VeraSeBd.ttf');\n\t}\n}\n"); + btc("@media screen {\n\t#foo:hover {\n\t\tbackground-image: url(foo@2x.png);\n\t}\n\t@font-face {\n\t\tfont-family: 'Bitstream Vera Serif Bold';\n\t\tsrc: url('http://developer.mozilla.org/@api/deki/files/2934/=VeraSeBd.ttf');\n\t}\n}\n"); +/* +@font-face { + font-family: 'Bitstream Vera Serif Bold'; + src: url('http://developer.mozilla.org/@api/deki/files/2934/=VeraSeBd.ttf'); +} +@media screen { + #foo:hover { + background-image: url(foo.png); + } + @media screen and (min-device-pixel-ratio: 2) { + @font-face { + font-family: 'Helvetica Neue' + } + #foo:hover { + background-image: url(foo@2x.png); + } + } +} +*/ + btc("@font-face {\n\tfont-family: 'Bitstream Vera Serif Bold';\n\tsrc: url('http://developer.mozilla.org/@api/deki/files/2934/=VeraSeBd.ttf');\n}\n@media screen {\n\t#foo:hover {\n\t\tbackground-image: url(foo.png);\n\t}\n\t@media screen and (min-device-pixel-ratio: 2) {\n\t\t@font-face {\n\t\t\tfont-family: 'Helvetica Neue'\n\t\t}\n\t\t#foo:hover {\n\t\t\tbackground-image: url(foo@2x.png);\n\t\t}\n\t}\n}\n"); + + // test options + opts.indent_size = 2; + opts.indent_char = ' '; + opts.selector_separator_newline = false; + + btc("#bla, #foo{color:green}", "#bla, #foo {\n color: green\n}\n"); + btc("@media print {.tab{}}", "@media print {\n .tab {}\n}\n"); + btc("@media print {.tab,.bat{}}", "@media print {\n .tab, .bat {}\n}\n"); + btc("#bla, #foo{color:black}", "#bla, #foo {\n color: black\n}\n"); + + // pseudo-classes and pseudo-elements + btc("#foo:hover {\n background-image: url(foo@2x.png)\n}\n"); + btc("#foo *:hover {\n color: purple\n}\n"); + btc("::selection {\n color: #ff0000;\n}\n"); + + // TODO: don't break nested pseduo-classes + btc("@media screen {.tab,.bat:hover {color:red}}", "@media screen {\n .tab, .bat:hover {\n color: red\n }\n}\n"); + + // particular edge case with braces and semicolons inside tags that allows custom text + btc("a:not(\"foobar\\\";{}omg\"){\ncontent: 'example\\';{} text';\ncontent: \"example\\\";{} text\";}", + "a:not(\"foobar\\\";{}omg\") {\n content: 'example\\';{} text';\n content: \"example\\\";{} text\";\n}\n"); + + btc('html.js [data-custom="123"] {\n opacity: 1.00;\n}\n'); // may not eat the space before "[" + btc('html.js *[data-custom="123"] {\n opacity: 1.00;\n}\n'); + + return sanitytest; + } + + return beautifier_tests(); +} + +if (typeof exports !== "undefined") { + exports.run_beautifier_tests = run_beautifier_tests; +} diff --git a/devtools/shared/jsbeautify/src/moz.build b/devtools/shared/jsbeautify/src/moz.build new file mode 100644 index 000000000..ef16a2bb2 --- /dev/null +++ b/devtools/shared/jsbeautify/src/moz.build @@ -0,0 +1,12 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +DevToolsModules( + 'beautify-css.js', + 'beautify-html.js', + 'beautify-js.js', + 'beautify-tests.js' +) |