From ceea2a1cf26996c7e64f4107137ea6e9dbabb310 Mon Sep 17 00:00:00 2001 From: Slava Kim Date: Fri, 13 Dec 2013 16:40:12 -0800 Subject: [PATCH 01/34] Pull all imports with css-parse --- .../.npm/package/npm-shrinkwrap.json | 16 ++++++++++ packages/minifiers/minifiers.js | 4 +++ packages/minifiers/package.js | 5 +++- tools/bundler.js | 29 +++++++++++++++---- 4 files changed, 48 insertions(+), 6 deletions(-) diff --git a/packages/minifiers/.npm/package/npm-shrinkwrap.json b/packages/minifiers/.npm/package/npm-shrinkwrap.json index e2eb3b72aa..db17ed6c94 100644 --- a/packages/minifiers/.npm/package/npm-shrinkwrap.json +++ b/packages/minifiers/.npm/package/npm-shrinkwrap.json @@ -34,6 +34,22 @@ "version": "1.0.1" } } + }, + "css-parse": { + "version": "1.6.0" + }, + "css-stringify": { + "version": "1.4.1", + "dependencies": { + "source-map": { + "version": "0.1.31", + "dependencies": { + "amdefine": { + "version": "0.1.0" + } + } + } + } } } } diff --git a/packages/minifiers/minifiers.js b/packages/minifiers/minifiers.js index ad15487d26..f09748fd71 100644 --- a/packages/minifiers/minifiers.js +++ b/packages/minifiers/minifiers.js @@ -5,4 +5,8 @@ CleanCSSProcess = function (source, options) { return instance.minify(source); }; +CssParse = Npm.require('css-parse'); +CssStringify = Npm.require('css-stringify'); + UglifyJSMinify = Npm.require('uglify-js').minify; + diff --git a/packages/minifiers/package.js b/packages/minifiers/package.js index c76efd3ee9..2424ed5906 100644 --- a/packages/minifiers/package.js +++ b/packages/minifiers/package.js @@ -5,10 +5,13 @@ Package.describe({ Npm.depends({ "clean-css": "2.0.2", - "uglify-js": "2.4.7" + "uglify-js": "2.4.7", + "css-parse": "1.6.0", + "css-stringify": "1.4.1" }); Package.on_use(function (api) { api.export(['CleanCSSProcess', 'UglifyJSMinify']); + api.export(['CssParse', 'CssStringify']); api.add_files('minifiers.js', 'server'); }); diff --git a/tools/bundler.js b/tools/bundler.js index 8049026e98..8047b31522 100644 --- a/tools/bundler.js +++ b/tools/bundler.js @@ -759,13 +759,32 @@ _.extend(ClientTarget.prototype, { minifyCss: function (minifiers) { var self = this; - var allCss = _.map(self.css, function (file) { - return file.contents('utf8'); - }).join('\n'); + // after concatenation some @import's might be left in the middle of CSS + // file but they required to be in the beginning. + var importsAst = { + type: 'stylesheet', + stylesheet: { rules: [] } + }; - allCss = minifiers.CleanCSSProcess(allCss); + var cssAsts = _.map(self.css, function (file) { + var ast = minifiers.CssParse(file.contents('utf8')); + function isImportRule (node) { + return node.type === 'import'; + } - self.css = [new File({ data: new Buffer(allCss, 'utf8') })]; + var imports = _.filter(ast.stylesheet.rules, isImportRule); + importsAst.stylesheet.rules = importsAst.stylesheet.rules.concat(imports); + + ast.stylesheet.rules = _.reject(ast.stylesheet.rules, isImportRule); + return ast; + }); + + var allCss = + _.map([importsAst].concat(cssAsts), minifiers.CssStringify).join('\n'); + + var minifiedCss = minifiers.CleanCSSProcess(allCss); + + self.css = [new File({ data: new Buffer(minifiedCss, 'utf8') })]; self.css[0].setUrlToHash(".css"); }, From 21c8eaf8a5862457f7e70a00ab5a9d978cc3756c Mon Sep 17 00:00:00 2001 From: Slava Kim Date: Fri, 13 Dec 2013 17:04:37 -0800 Subject: [PATCH 02/34] Error reporting for CSS parsing --- tools/bundler.js | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/tools/bundler.js b/tools/bundler.js index 8047b31522..c47f531a81 100644 --- a/tools/bundler.js +++ b/tools/bundler.js @@ -159,6 +159,7 @@ // wait until later. var path = require('path'); +var util = require('util'); var files = require(path.join(__dirname, 'files.js')); var packages = require(path.join(__dirname, 'packages.js')); var linker = require(path.join(__dirname, 'linker.js')); @@ -767,7 +768,12 @@ _.extend(ClientTarget.prototype, { }; var cssAsts = _.map(self.css, function (file) { - var ast = minifiers.CssParse(file.contents('utf8')); + try { + var ast = minifiers.CssParse(file.contents('utf8')); + } catch (e) { + throw new Error(util.format('Parsing %s: %s', file.url, e.message)); + } + function isImportRule (node) { return node.type === 'import'; } From 9bad898e5973e46bf09b995579cdf3fad5c76fe0 Mon Sep 17 00:00:00 2001 From: Slava Kim Date: Fri, 13 Dec 2013 17:51:55 -0800 Subject: [PATCH 03/34] Better error reporting on CSS building --- tools/bundler.js | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/tools/bundler.js b/tools/bundler.js index c47f531a81..ec95852051 100644 --- a/tools/bundler.js +++ b/tools/bundler.js @@ -771,7 +771,9 @@ _.extend(ClientTarget.prototype, { try { var ast = minifiers.CssParse(file.contents('utf8')); } catch (e) { - throw new Error(util.format('Parsing %s: %s', file.url, e.message)); + var file = file.url[0] === '/' ? file.url.slice(1) : file.url; + buildmessage.error(e.message, { file: file }); + return { type: "stylesheet", stylesheet: { rules: [] } }; } function isImportRule (node) { From 355d7e8944bb7ea68054dfd5b5f1506d96f07479 Mon Sep 17 00:00:00 2001 From: Slava Kim Date: Fri, 3 Jan 2014 15:40:58 -0800 Subject: [PATCH 04/34] Ignore @charset rules and comments, then pull up @import rules from the top of every file. --- tools/bundler.js | 24 ++++++++++++++++++++---- 1 file changed, 20 insertions(+), 4 deletions(-) diff --git a/tools/bundler.js b/tools/bundler.js index ec95852051..97bf3291ca 100644 --- a/tools/bundler.js +++ b/tools/bundler.js @@ -776,14 +776,30 @@ _.extend(ClientTarget.prototype, { return { type: "stylesheet", stylesheet: { rules: [] } }; } - function isImportRule (node) { - return node.type === 'import'; + function rulePredicate (rule) { + return function (node) { + return node.type === rule; + } } - var imports = _.filter(ast.stylesheet.rules, isImportRule); + // Get rid of comments + ast.stylesheet.rules = _.reject(ast.stylesheet.rules, + rulePredicate("comment")); + + // Pick only the imports from the begginning of file ignoring @charset + // rules as Meteor assumes every file is in utf-8. + ast.stylesheet.rules = _.reject(ast.stylesheet.rules, + rulePredicate("charset")); + var importsNumber = 0; + for (var i = 0; i < ast.stylesheet.rules.length; i++) + if (!rulePredicate("import")(ast.stylesheet.rules[i])) { + importsNumber = i; + break; + } + + var imports = ast.stylesheet.rules.splice(0, importsNumber); importsAst.stylesheet.rules = importsAst.stylesheet.rules.concat(imports); - ast.stylesheet.rules = _.reject(ast.stylesheet.rules, isImportRule); return ast; }); From e1f34d3ab423c2b24ca5b99d5db424e3d34fe87e Mon Sep 17 00:00:00 2001 From: Slava Kim Date: Fri, 3 Jan 2014 15:48:31 -0800 Subject: [PATCH 05/34] Better comments --- tools/bundler.js | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/tools/bundler.js b/tools/bundler.js index 97bf3291ca..091c1a9e6b 100644 --- a/tools/bundler.js +++ b/tools/bundler.js @@ -760,8 +760,9 @@ _.extend(ClientTarget.prototype, { minifyCss: function (minifiers) { var self = this; - // after concatenation some @import's might be left in the middle of CSS - // file but they required to be in the beginning. + // The straight-forward concatenation of CSS files would break @import rules + // located in the beginning of a file. Before concatenation, pull them to a + // separate syntax tree that will always precede other rules. var importsAst = { type: 'stylesheet', stylesheet: { rules: [] } @@ -786,7 +787,7 @@ _.extend(ClientTarget.prototype, { ast.stylesheet.rules = _.reject(ast.stylesheet.rules, rulePredicate("comment")); - // Pick only the imports from the begginning of file ignoring @charset + // Pick only the imports from the beginning of file ignoring @charset // rules as Meteor assumes every file is in utf-8. ast.stylesheet.rules = _.reject(ast.stylesheet.rules, rulePredicate("charset")); From 65e01162a24a28ecf9887d70a70d8114bbae75bf Mon Sep 17 00:00:00 2001 From: Slava Kim Date: Fri, 3 Jan 2014 16:31:39 -0800 Subject: [PATCH 06/34] Print a warning in case of buried @import's --- tools/bundler.js | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/tools/bundler.js b/tools/bundler.js index 091c1a9e6b..22aca47b90 100644 --- a/tools/bundler.js +++ b/tools/bundler.js @@ -772,8 +772,8 @@ _.extend(ClientTarget.prototype, { try { var ast = minifiers.CssParse(file.contents('utf8')); } catch (e) { - var file = file.url[0] === '/' ? file.url.slice(1) : file.url; - buildmessage.error(e.message, { file: file }); + var fileName = file.url[0] === '/' ? file.url.slice(1) : file.url; + buildmessage.error(e.message, { file: fileName }); return { type: "stylesheet", stylesheet: { rules: [] } }; } @@ -801,6 +801,14 @@ _.extend(ClientTarget.prototype, { var imports = ast.stylesheet.rules.splice(0, importsNumber); importsAst.stylesheet.rules = importsAst.stylesheet.rules.concat(imports); + // if there are imports left in the middle of file, warn user as it might + // be a potential bug (imports are valid only in the beginning of file). + if (_.any(ast.stylesheet.rules, rulePredicate("import"))) { + var fileName = file.url[0] === '/' ? file.url.slice(1) : file.url; + // XXX make this a buildmessage.warning call rather than a random log + console.log("%s: warn: there are some @import rules those are not taking effect as they are required to be in the beginning of the file.", fileName); + } + return ast; }); From 0393315e29d65e0fad5af7e52bdebbe5807f4559 Mon Sep 17 00:00:00 2001 From: Slava Kim Date: Fri, 10 Jan 2014 18:17:00 -0800 Subject: [PATCH 07/34] Nick's comments --- tools/bundler.js | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/tools/bundler.js b/tools/bundler.js index 22aca47b90..022fd7b904 100644 --- a/tools/bundler.js +++ b/tools/bundler.js @@ -772,12 +772,12 @@ _.extend(ClientTarget.prototype, { try { var ast = minifiers.CssParse(file.contents('utf8')); } catch (e) { - var fileName = file.url[0] === '/' ? file.url.slice(1) : file.url; + var fileName = file.url.replace(/^\//, ''); buildmessage.error(e.message, { file: fileName }); return { type: "stylesheet", stylesheet: { rules: [] } }; } - function rulePredicate (rule) { + var rulePredicate = function (rule) { return function (node) { return node.type === rule; } @@ -791,20 +791,20 @@ _.extend(ClientTarget.prototype, { // rules as Meteor assumes every file is in utf-8. ast.stylesheet.rules = _.reject(ast.stylesheet.rules, rulePredicate("charset")); - var importsNumber = 0; + var importCount = 0; for (var i = 0; i < ast.stylesheet.rules.length; i++) if (!rulePredicate("import")(ast.stylesheet.rules[i])) { - importsNumber = i; + importCount = i; break; } - var imports = ast.stylesheet.rules.splice(0, importsNumber); + var imports = ast.stylesheet.rules.splice(0, importCount); importsAst.stylesheet.rules = importsAst.stylesheet.rules.concat(imports); // if there are imports left in the middle of file, warn user as it might // be a potential bug (imports are valid only in the beginning of file). if (_.any(ast.stylesheet.rules, rulePredicate("import"))) { - var fileName = file.url[0] === '/' ? file.url.slice(1) : file.url; + var fileName = file.url.replace(/^\//, ''); // XXX make this a buildmessage.warning call rather than a random log console.log("%s: warn: there are some @import rules those are not taking effect as they are required to be in the beginning of the file.", fileName); } From 2c018d5efc71ad02398beaaa9c3c16fa8a1244ad Mon Sep 17 00:00:00 2001 From: Slava Kim Date: Fri, 10 Jan 2014 18:17:14 -0800 Subject: [PATCH 08/34] Update dependencies --- packages/minifiers/.npm/package/npm-shrinkwrap.json | 4 ++-- packages/minifiers/package.js | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/packages/minifiers/.npm/package/npm-shrinkwrap.json b/packages/minifiers/.npm/package/npm-shrinkwrap.json index db17ed6c94..c315f0ff93 100644 --- a/packages/minifiers/.npm/package/npm-shrinkwrap.json +++ b/packages/minifiers/.npm/package/npm-shrinkwrap.json @@ -1,7 +1,7 @@ { "dependencies": { "clean-css": { - "version": "2.0.2", + "version": "2.0.6", "dependencies": { "commander": { "version": "2.0.0" @@ -36,7 +36,7 @@ } }, "css-parse": { - "version": "1.6.0" + "version": "1.7.0" }, "css-stringify": { "version": "1.4.1", diff --git a/packages/minifiers/package.js b/packages/minifiers/package.js index 2424ed5906..6ff951a8a7 100644 --- a/packages/minifiers/package.js +++ b/packages/minifiers/package.js @@ -4,9 +4,9 @@ Package.describe({ }); Npm.depends({ - "clean-css": "2.0.2", + "clean-css": "2.0.6", "uglify-js": "2.4.7", - "css-parse": "1.6.0", + "css-parse": "1.7.0", "css-stringify": "1.4.1" }); From b8d4e93166df54d32f65dd0b3a73f9a9df0439bd Mon Sep 17 00:00:00 2001 From: Slava Kim Date: Mon, 13 Jan 2014 10:46:36 -0800 Subject: [PATCH 09/34] Spit out a warning if @charset rule found Since Meteor will just ignore those. --- tools/bundler.js | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/tools/bundler.js b/tools/bundler.js index 022fd7b904..ca0490f528 100644 --- a/tools/bundler.js +++ b/tools/bundler.js @@ -789,6 +789,12 @@ _.extend(ClientTarget.prototype, { // Pick only the imports from the beginning of file ignoring @charset // rules as Meteor assumes every file is in utf-8. + if (_.any(ast.stylesheet.rules, rulePredicate("charset"))) { + var fileName = file.url.replace(/^\//, ''); + // XXX make this a buildmessage.warning call rather than a random log + console.log("%s: warn: @charset rules in this file will be ignored as Meteor supports only utf-8 at the moment.", fileName); + } + ast.stylesheet.rules = _.reject(ast.stylesheet.rules, rulePredicate("charset")); var importCount = 0; From dcecf0a76571bd78204b73907d824edbad9124e0 Mon Sep 17 00:00:00 2001 From: David Greenspan Date: Wed, 4 Dec 2013 15:39:17 -0800 Subject: [PATCH 10/34] show diffs in test results Conflicts: packages/spacebars/compile_tests.js packages/test-in-browser/driver.js --- .../diff_match_patch_uncompressed.js | 2193 +++++++++++++++++ packages/test-in-browser/driver.css | 15 + packages/test-in-browser/driver.js | 111 +- packages/test-in-browser/package.js | 2 + packages/tinytest/tinytest.js | 24 +- 5 files changed, 2306 insertions(+), 39 deletions(-) create mode 100644 packages/test-in-browser/diff_match_patch_uncompressed.js diff --git a/packages/test-in-browser/diff_match_patch_uncompressed.js b/packages/test-in-browser/diff_match_patch_uncompressed.js new file mode 100644 index 0000000000..112130e097 --- /dev/null +++ b/packages/test-in-browser/diff_match_patch_uncompressed.js @@ -0,0 +1,2193 @@ +/** + * Diff Match and Patch + * + * Copyright 2006 Google Inc. + * http://code.google.com/p/google-diff-match-patch/ + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @fileoverview Computes the difference between two texts to create a patch. + * Applies the patch onto another text, allowing for errors. + * @author fraser@google.com (Neil Fraser) + */ + +/** + * Class containing the diff, match and patch methods. + * @constructor + */ +function diff_match_patch() { + + // Defaults. + // Redefine these in your program to override the defaults. + + // Number of seconds to map a diff before giving up (0 for infinity). + this.Diff_Timeout = 1.0; + // Cost of an empty edit operation in terms of edit characters. + this.Diff_EditCost = 4; + // At what point is no match declared (0.0 = perfection, 1.0 = very loose). + this.Match_Threshold = 0.5; + // How far to search for a match (0 = exact location, 1000+ = broad match). + // A match this many characters away from the expected location will add + // 1.0 to the score (0.0 is a perfect match). + this.Match_Distance = 1000; + // When deleting a large block of text (over ~64 characters), how close do + // the contents have to be to match the expected contents. (0.0 = perfection, + // 1.0 = very loose). Note that Match_Threshold controls how closely the + // end points of a delete need to match. + this.Patch_DeleteThreshold = 0.5; + // Chunk size for context length. + this.Patch_Margin = 4; + + // The number of bits in an int. + this.Match_MaxBits = 32; +} + + +// DIFF FUNCTIONS + + +/** + * The data structure representing a diff is an array of tuples: + * [[DIFF_DELETE, 'Hello'], [DIFF_INSERT, 'Goodbye'], [DIFF_EQUAL, ' world.']] + * which means: delete 'Hello', add 'Goodbye' and keep ' world.' + */ +var DIFF_DELETE = -1; +var DIFF_INSERT = 1; +var DIFF_EQUAL = 0; + +/** @typedef {{0: number, 1: string}} */ +diff_match_patch.Diff; + + +/** + * Find the differences between two texts. Simplifies the problem by stripping + * any common prefix or suffix off the texts before diffing. + * @param {string} text1 Old string to be diffed. + * @param {string} text2 New string to be diffed. + * @param {boolean=} opt_checklines Optional speedup flag. If present and false, + * then don't run a line-level diff first to identify the changed areas. + * Defaults to true, which does a faster, slightly less optimal diff. + * @param {number} opt_deadline Optional time when the diff should be complete + * by. Used internally for recursive calls. Users should set DiffTimeout + * instead. + * @return {!Array.} Array of diff tuples. + */ +diff_match_patch.prototype.diff_main = function(text1, text2, opt_checklines, + opt_deadline) { + // Set a deadline by which time the diff must be complete. + if (typeof opt_deadline == 'undefined') { + if (this.Diff_Timeout <= 0) { + opt_deadline = Number.MAX_VALUE; + } else { + opt_deadline = (new Date).getTime() + this.Diff_Timeout * 1000; + } + } + var deadline = opt_deadline; + + // Check for null inputs. + if (text1 == null || text2 == null) { + throw new Error('Null input. (diff_main)'); + } + + // Check for equality (speedup). + if (text1 == text2) { + if (text1) { + return [[DIFF_EQUAL, text1]]; + } + return []; + } + + if (typeof opt_checklines == 'undefined') { + opt_checklines = true; + } + var checklines = opt_checklines; + + // Trim off common prefix (speedup). + var commonlength = this.diff_commonPrefix(text1, text2); + var commonprefix = text1.substring(0, commonlength); + text1 = text1.substring(commonlength); + text2 = text2.substring(commonlength); + + // Trim off common suffix (speedup). + commonlength = this.diff_commonSuffix(text1, text2); + var commonsuffix = text1.substring(text1.length - commonlength); + text1 = text1.substring(0, text1.length - commonlength); + text2 = text2.substring(0, text2.length - commonlength); + + // Compute the diff on the middle block. + var diffs = this.diff_compute_(text1, text2, checklines, deadline); + + // Restore the prefix and suffix. + if (commonprefix) { + diffs.unshift([DIFF_EQUAL, commonprefix]); + } + if (commonsuffix) { + diffs.push([DIFF_EQUAL, commonsuffix]); + } + this.diff_cleanupMerge(diffs); + return diffs; +}; + + +/** + * Find the differences between two texts. Assumes that the texts do not + * have any common prefix or suffix. + * @param {string} text1 Old string to be diffed. + * @param {string} text2 New string to be diffed. + * @param {boolean} checklines Speedup flag. If false, then don't run a + * line-level diff first to identify the changed areas. + * If true, then run a faster, slightly less optimal diff. + * @param {number} deadline Time when the diff should be complete by. + * @return {!Array.} Array of diff tuples. + * @private + */ +diff_match_patch.prototype.diff_compute_ = function(text1, text2, checklines, + deadline) { + var diffs; + + if (!text1) { + // Just add some text (speedup). + return [[DIFF_INSERT, text2]]; + } + + if (!text2) { + // Just delete some text (speedup). + return [[DIFF_DELETE, text1]]; + } + + var longtext = text1.length > text2.length ? text1 : text2; + var shorttext = text1.length > text2.length ? text2 : text1; + var i = longtext.indexOf(shorttext); + if (i != -1) { + // Shorter text is inside the longer text (speedup). + diffs = [[DIFF_INSERT, longtext.substring(0, i)], + [DIFF_EQUAL, shorttext], + [DIFF_INSERT, longtext.substring(i + shorttext.length)]]; + // Swap insertions for deletions if diff is reversed. + if (text1.length > text2.length) { + diffs[0][0] = diffs[2][0] = DIFF_DELETE; + } + return diffs; + } + + if (shorttext.length == 1) { + // Single character string. + // After the previous speedup, the character can't be an equality. + return [[DIFF_DELETE, text1], [DIFF_INSERT, text2]]; + } + + // Check to see if the problem can be split in two. + var hm = this.diff_halfMatch_(text1, text2); + if (hm) { + // A half-match was found, sort out the return data. + var text1_a = hm[0]; + var text1_b = hm[1]; + var text2_a = hm[2]; + var text2_b = hm[3]; + var mid_common = hm[4]; + // Send both pairs off for separate processing. + var diffs_a = this.diff_main(text1_a, text2_a, checklines, deadline); + var diffs_b = this.diff_main(text1_b, text2_b, checklines, deadline); + // Merge the results. + return diffs_a.concat([[DIFF_EQUAL, mid_common]], diffs_b); + } + + if (checklines && text1.length > 100 && text2.length > 100) { + return this.diff_lineMode_(text1, text2, deadline); + } + + return this.diff_bisect_(text1, text2, deadline); +}; + + +/** + * Do a quick line-level diff on both strings, then rediff the parts for + * greater accuracy. + * This speedup can produce non-minimal diffs. + * @param {string} text1 Old string to be diffed. + * @param {string} text2 New string to be diffed. + * @param {number} deadline Time when the diff should be complete by. + * @return {!Array.} Array of diff tuples. + * @private + */ +diff_match_patch.prototype.diff_lineMode_ = function(text1, text2, deadline) { + // Scan the text on a line-by-line basis first. + var a = this.diff_linesToChars_(text1, text2); + text1 = a.chars1; + text2 = a.chars2; + var linearray = a.lineArray; + + var diffs = this.diff_main(text1, text2, false, deadline); + + // Convert the diff back to original text. + this.diff_charsToLines_(diffs, linearray); + // Eliminate freak matches (e.g. blank lines) + this.diff_cleanupSemantic(diffs); + + // Rediff any replacement blocks, this time character-by-character. + // Add a dummy entry at the end. + diffs.push([DIFF_EQUAL, '']); + var pointer = 0; + var count_delete = 0; + var count_insert = 0; + var text_delete = ''; + var text_insert = ''; + while (pointer < diffs.length) { + switch (diffs[pointer][0]) { + case DIFF_INSERT: + count_insert++; + text_insert += diffs[pointer][1]; + break; + case DIFF_DELETE: + count_delete++; + text_delete += diffs[pointer][1]; + break; + case DIFF_EQUAL: + // Upon reaching an equality, check for prior redundancies. + if (count_delete >= 1 && count_insert >= 1) { + // Delete the offending records and add the merged ones. + diffs.splice(pointer - count_delete - count_insert, + count_delete + count_insert); + pointer = pointer - count_delete - count_insert; + var a = this.diff_main(text_delete, text_insert, false, deadline); + for (var j = a.length - 1; j >= 0; j--) { + diffs.splice(pointer, 0, a[j]); + } + pointer = pointer + a.length; + } + count_insert = 0; + count_delete = 0; + text_delete = ''; + text_insert = ''; + break; + } + pointer++; + } + diffs.pop(); // Remove the dummy entry at the end. + + return diffs; +}; + + +/** + * Find the 'middle snake' of a diff, split the problem in two + * and return the recursively constructed diff. + * See Myers 1986 paper: An O(ND) Difference Algorithm and Its Variations. + * @param {string} text1 Old string to be diffed. + * @param {string} text2 New string to be diffed. + * @param {number} deadline Time at which to bail if not yet complete. + * @return {!Array.} Array of diff tuples. + * @private + */ +diff_match_patch.prototype.diff_bisect_ = function(text1, text2, deadline) { + // Cache the text lengths to prevent multiple calls. + var text1_length = text1.length; + var text2_length = text2.length; + var max_d = Math.ceil((text1_length + text2_length) / 2); + var v_offset = max_d; + var v_length = 2 * max_d; + var v1 = new Array(v_length); + var v2 = new Array(v_length); + // Setting all elements to -1 is faster in Chrome & Firefox than mixing + // integers and undefined. + for (var x = 0; x < v_length; x++) { + v1[x] = -1; + v2[x] = -1; + } + v1[v_offset + 1] = 0; + v2[v_offset + 1] = 0; + var delta = text1_length - text2_length; + // If the total number of characters is odd, then the front path will collide + // with the reverse path. + var front = (delta % 2 != 0); + // Offsets for start and end of k loop. + // Prevents mapping of space beyond the grid. + var k1start = 0; + var k1end = 0; + var k2start = 0; + var k2end = 0; + for (var d = 0; d < max_d; d++) { + // Bail out if deadline is reached. + if ((new Date()).getTime() > deadline) { + break; + } + + // Walk the front path one step. + for (var k1 = -d + k1start; k1 <= d - k1end; k1 += 2) { + var k1_offset = v_offset + k1; + var x1; + if (k1 == -d || (k1 != d && v1[k1_offset - 1] < v1[k1_offset + 1])) { + x1 = v1[k1_offset + 1]; + } else { + x1 = v1[k1_offset - 1] + 1; + } + var y1 = x1 - k1; + while (x1 < text1_length && y1 < text2_length && + text1.charAt(x1) == text2.charAt(y1)) { + x1++; + y1++; + } + v1[k1_offset] = x1; + if (x1 > text1_length) { + // Ran off the right of the graph. + k1end += 2; + } else if (y1 > text2_length) { + // Ran off the bottom of the graph. + k1start += 2; + } else if (front) { + var k2_offset = v_offset + delta - k1; + if (k2_offset >= 0 && k2_offset < v_length && v2[k2_offset] != -1) { + // Mirror x2 onto top-left coordinate system. + var x2 = text1_length - v2[k2_offset]; + if (x1 >= x2) { + // Overlap detected. + return this.diff_bisectSplit_(text1, text2, x1, y1, deadline); + } + } + } + } + + // Walk the reverse path one step. + for (var k2 = -d + k2start; k2 <= d - k2end; k2 += 2) { + var k2_offset = v_offset + k2; + var x2; + if (k2 == -d || (k2 != d && v2[k2_offset - 1] < v2[k2_offset + 1])) { + x2 = v2[k2_offset + 1]; + } else { + x2 = v2[k2_offset - 1] + 1; + } + var y2 = x2 - k2; + while (x2 < text1_length && y2 < text2_length && + text1.charAt(text1_length - x2 - 1) == + text2.charAt(text2_length - y2 - 1)) { + x2++; + y2++; + } + v2[k2_offset] = x2; + if (x2 > text1_length) { + // Ran off the left of the graph. + k2end += 2; + } else if (y2 > text2_length) { + // Ran off the top of the graph. + k2start += 2; + } else if (!front) { + var k1_offset = v_offset + delta - k2; + if (k1_offset >= 0 && k1_offset < v_length && v1[k1_offset] != -1) { + var x1 = v1[k1_offset]; + var y1 = v_offset + x1 - k1_offset; + // Mirror x2 onto top-left coordinate system. + x2 = text1_length - x2; + if (x1 >= x2) { + // Overlap detected. + return this.diff_bisectSplit_(text1, text2, x1, y1, deadline); + } + } + } + } + } + // Diff took too long and hit the deadline or + // number of diffs equals number of characters, no commonality at all. + return [[DIFF_DELETE, text1], [DIFF_INSERT, text2]]; +}; + + +/** + * Given the location of the 'middle snake', split the diff in two parts + * and recurse. + * @param {string} text1 Old string to be diffed. + * @param {string} text2 New string to be diffed. + * @param {number} x Index of split point in text1. + * @param {number} y Index of split point in text2. + * @param {number} deadline Time at which to bail if not yet complete. + * @return {!Array.} Array of diff tuples. + * @private + */ +diff_match_patch.prototype.diff_bisectSplit_ = function(text1, text2, x, y, + deadline) { + var text1a = text1.substring(0, x); + var text2a = text2.substring(0, y); + var text1b = text1.substring(x); + var text2b = text2.substring(y); + + // Compute both diffs serially. + var diffs = this.diff_main(text1a, text2a, false, deadline); + var diffsb = this.diff_main(text1b, text2b, false, deadline); + + return diffs.concat(diffsb); +}; + + +/** + * Split two texts into an array of strings. Reduce the texts to a string of + * hashes where each Unicode character represents one line. + * @param {string} text1 First string. + * @param {string} text2 Second string. + * @return {{chars1: string, chars2: string, lineArray: !Array.}} + * An object containing the encoded text1, the encoded text2 and + * the array of unique strings. + * The zeroth element of the array of unique strings is intentionally blank. + * @private + */ +diff_match_patch.prototype.diff_linesToChars_ = function(text1, text2) { + var lineArray = []; // e.g. lineArray[4] == 'Hello\n' + var lineHash = {}; // e.g. lineHash['Hello\n'] == 4 + + // '\x00' is a valid character, but various debuggers don't like it. + // So we'll insert a junk entry to avoid generating a null character. + lineArray[0] = ''; + + /** + * Split a text into an array of strings. Reduce the texts to a string of + * hashes where each Unicode character represents one line. + * Modifies linearray and linehash through being a closure. + * @param {string} text String to encode. + * @return {string} Encoded string. + * @private + */ + function diff_linesToCharsMunge_(text) { + var chars = ''; + // Walk the text, pulling out a substring for each line. + // text.split('\n') would would temporarily double our memory footprint. + // Modifying text would create many large strings to garbage collect. + var lineStart = 0; + var lineEnd = -1; + // Keeping our own length variable is faster than looking it up. + var lineArrayLength = lineArray.length; + while (lineEnd < text.length - 1) { + lineEnd = text.indexOf('\n', lineStart); + if (lineEnd == -1) { + lineEnd = text.length - 1; + } + var line = text.substring(lineStart, lineEnd + 1); + lineStart = lineEnd + 1; + + if (lineHash.hasOwnProperty ? lineHash.hasOwnProperty(line) : + (lineHash[line] !== undefined)) { + chars += String.fromCharCode(lineHash[line]); + } else { + chars += String.fromCharCode(lineArrayLength); + lineHash[line] = lineArrayLength; + lineArray[lineArrayLength++] = line; + } + } + return chars; + } + + var chars1 = diff_linesToCharsMunge_(text1); + var chars2 = diff_linesToCharsMunge_(text2); + return {chars1: chars1, chars2: chars2, lineArray: lineArray}; +}; + + +/** + * Rehydrate the text in a diff from a string of line hashes to real lines of + * text. + * @param {!Array.} diffs Array of diff tuples. + * @param {!Array.} lineArray Array of unique strings. + * @private + */ +diff_match_patch.prototype.diff_charsToLines_ = function(diffs, lineArray) { + for (var x = 0; x < diffs.length; x++) { + var chars = diffs[x][1]; + var text = []; + for (var y = 0; y < chars.length; y++) { + text[y] = lineArray[chars.charCodeAt(y)]; + } + diffs[x][1] = text.join(''); + } +}; + + +/** + * Determine the common prefix of two strings. + * @param {string} text1 First string. + * @param {string} text2 Second string. + * @return {number} The number of characters common to the start of each + * string. + */ +diff_match_patch.prototype.diff_commonPrefix = function(text1, text2) { + // Quick check for common null cases. + if (!text1 || !text2 || text1.charAt(0) != text2.charAt(0)) { + return 0; + } + // Binary search. + // Performance analysis: http://neil.fraser.name/news/2007/10/09/ + var pointermin = 0; + var pointermax = Math.min(text1.length, text2.length); + var pointermid = pointermax; + var pointerstart = 0; + while (pointermin < pointermid) { + if (text1.substring(pointerstart, pointermid) == + text2.substring(pointerstart, pointermid)) { + pointermin = pointermid; + pointerstart = pointermin; + } else { + pointermax = pointermid; + } + pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin); + } + return pointermid; +}; + + +/** + * Determine the common suffix of two strings. + * @param {string} text1 First string. + * @param {string} text2 Second string. + * @return {number} The number of characters common to the end of each string. + */ +diff_match_patch.prototype.diff_commonSuffix = function(text1, text2) { + // Quick check for common null cases. + if (!text1 || !text2 || + text1.charAt(text1.length - 1) != text2.charAt(text2.length - 1)) { + return 0; + } + // Binary search. + // Performance analysis: http://neil.fraser.name/news/2007/10/09/ + var pointermin = 0; + var pointermax = Math.min(text1.length, text2.length); + var pointermid = pointermax; + var pointerend = 0; + while (pointermin < pointermid) { + if (text1.substring(text1.length - pointermid, text1.length - pointerend) == + text2.substring(text2.length - pointermid, text2.length - pointerend)) { + pointermin = pointermid; + pointerend = pointermin; + } else { + pointermax = pointermid; + } + pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin); + } + return pointermid; +}; + + +/** + * Determine if the suffix of one string is the prefix of another. + * @param {string} text1 First string. + * @param {string} text2 Second string. + * @return {number} The number of characters common to the end of the first + * string and the start of the second string. + * @private + */ +diff_match_patch.prototype.diff_commonOverlap_ = function(text1, text2) { + // Cache the text lengths to prevent multiple calls. + var text1_length = text1.length; + var text2_length = text2.length; + // Eliminate the null case. + if (text1_length == 0 || text2_length == 0) { + return 0; + } + // Truncate the longer string. + if (text1_length > text2_length) { + text1 = text1.substring(text1_length - text2_length); + } else if (text1_length < text2_length) { + text2 = text2.substring(0, text1_length); + } + var text_length = Math.min(text1_length, text2_length); + // Quick check for the worst case. + if (text1 == text2) { + return text_length; + } + + // Start by looking for a single character match + // and increase length until no match is found. + // Performance analysis: http://neil.fraser.name/news/2010/11/04/ + var best = 0; + var length = 1; + while (true) { + var pattern = text1.substring(text_length - length); + var found = text2.indexOf(pattern); + if (found == -1) { + return best; + } + length += found; + if (found == 0 || text1.substring(text_length - length) == + text2.substring(0, length)) { + best = length; + length++; + } + } +}; + + +/** + * Do the two texts share a substring which is at least half the length of the + * longer text? + * This speedup can produce non-minimal diffs. + * @param {string} text1 First string. + * @param {string} text2 Second string. + * @return {Array.} Five element Array, containing the prefix of + * text1, the suffix of text1, the prefix of text2, the suffix of + * text2 and the common middle. Or null if there was no match. + * @private + */ +diff_match_patch.prototype.diff_halfMatch_ = function(text1, text2) { + if (this.Diff_Timeout <= 0) { + // Don't risk returning a non-optimal diff if we have unlimited time. + return null; + } + var longtext = text1.length > text2.length ? text1 : text2; + var shorttext = text1.length > text2.length ? text2 : text1; + if (longtext.length < 4 || shorttext.length * 2 < longtext.length) { + return null; // Pointless. + } + var dmp = this; // 'this' becomes 'window' in a closure. + + /** + * Does a substring of shorttext exist within longtext such that the substring + * is at least half the length of longtext? + * Closure, but does not reference any external variables. + * @param {string} longtext Longer string. + * @param {string} shorttext Shorter string. + * @param {number} i Start index of quarter length substring within longtext. + * @return {Array.} Five element Array, containing the prefix of + * longtext, the suffix of longtext, the prefix of shorttext, the suffix + * of shorttext and the common middle. Or null if there was no match. + * @private + */ + function diff_halfMatchI_(longtext, shorttext, i) { + // Start with a 1/4 length substring at position i as a seed. + var seed = longtext.substring(i, i + Math.floor(longtext.length / 4)); + var j = -1; + var best_common = ''; + var best_longtext_a, best_longtext_b, best_shorttext_a, best_shorttext_b; + while ((j = shorttext.indexOf(seed, j + 1)) != -1) { + var prefixLength = dmp.diff_commonPrefix(longtext.substring(i), + shorttext.substring(j)); + var suffixLength = dmp.diff_commonSuffix(longtext.substring(0, i), + shorttext.substring(0, j)); + if (best_common.length < suffixLength + prefixLength) { + best_common = shorttext.substring(j - suffixLength, j) + + shorttext.substring(j, j + prefixLength); + best_longtext_a = longtext.substring(0, i - suffixLength); + best_longtext_b = longtext.substring(i + prefixLength); + best_shorttext_a = shorttext.substring(0, j - suffixLength); + best_shorttext_b = shorttext.substring(j + prefixLength); + } + } + if (best_common.length * 2 >= longtext.length) { + return [best_longtext_a, best_longtext_b, + best_shorttext_a, best_shorttext_b, best_common]; + } else { + return null; + } + } + + // First check if the second quarter is the seed for a half-match. + var hm1 = diff_halfMatchI_(longtext, shorttext, + Math.ceil(longtext.length / 4)); + // Check again based on the third quarter. + var hm2 = diff_halfMatchI_(longtext, shorttext, + Math.ceil(longtext.length / 2)); + var hm; + if (!hm1 && !hm2) { + return null; + } else if (!hm2) { + hm = hm1; + } else if (!hm1) { + hm = hm2; + } else { + // Both matched. Select the longest. + hm = hm1[4].length > hm2[4].length ? hm1 : hm2; + } + + // A half-match was found, sort out the return data. + var text1_a, text1_b, text2_a, text2_b; + if (text1.length > text2.length) { + text1_a = hm[0]; + text1_b = hm[1]; + text2_a = hm[2]; + text2_b = hm[3]; + } else { + text2_a = hm[0]; + text2_b = hm[1]; + text1_a = hm[2]; + text1_b = hm[3]; + } + var mid_common = hm[4]; + return [text1_a, text1_b, text2_a, text2_b, mid_common]; +}; + + +/** + * Reduce the number of edits by eliminating semantically trivial equalities. + * @param {!Array.} diffs Array of diff tuples. + */ +diff_match_patch.prototype.diff_cleanupSemantic = function(diffs) { + var changes = false; + var equalities = []; // Stack of indices where equalities are found. + var equalitiesLength = 0; // Keeping our own length var is faster in JS. + /** @type {?string} */ + var lastequality = null; + // Always equal to diffs[equalities[equalitiesLength - 1]][1] + var pointer = 0; // Index of current position. + // Number of characters that changed prior to the equality. + var length_insertions1 = 0; + var length_deletions1 = 0; + // Number of characters that changed after the equality. + var length_insertions2 = 0; + var length_deletions2 = 0; + while (pointer < diffs.length) { + if (diffs[pointer][0] == DIFF_EQUAL) { // Equality found. + equalities[equalitiesLength++] = pointer; + length_insertions1 = length_insertions2; + length_deletions1 = length_deletions2; + length_insertions2 = 0; + length_deletions2 = 0; + lastequality = diffs[pointer][1]; + } else { // An insertion or deletion. + if (diffs[pointer][0] == DIFF_INSERT) { + length_insertions2 += diffs[pointer][1].length; + } else { + length_deletions2 += diffs[pointer][1].length; + } + // Eliminate an equality that is smaller or equal to the edits on both + // sides of it. + if (lastequality && (lastequality.length <= + Math.max(length_insertions1, length_deletions1)) && + (lastequality.length <= Math.max(length_insertions2, + length_deletions2))) { + // Duplicate record. + diffs.splice(equalities[equalitiesLength - 1], 0, + [DIFF_DELETE, lastequality]); + // Change second copy to insert. + diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT; + // Throw away the equality we just deleted. + equalitiesLength--; + // Throw away the previous equality (it needs to be reevaluated). + equalitiesLength--; + pointer = equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1; + length_insertions1 = 0; // Reset the counters. + length_deletions1 = 0; + length_insertions2 = 0; + length_deletions2 = 0; + lastequality = null; + changes = true; + } + } + pointer++; + } + + // Normalize the diff. + if (changes) { + this.diff_cleanupMerge(diffs); + } + this.diff_cleanupSemanticLossless(diffs); + + // Find any overlaps between deletions and insertions. + // e.g: abcxxxxxxdef + // -> abcxxxdef + // e.g: xxxabcdefxxx + // -> defxxxabc + // Only extract an overlap if it is as big as the edit ahead or behind it. + pointer = 1; + while (pointer < diffs.length) { + if (diffs[pointer - 1][0] == DIFF_DELETE && + diffs[pointer][0] == DIFF_INSERT) { + var deletion = diffs[pointer - 1][1]; + var insertion = diffs[pointer][1]; + var overlap_length1 = this.diff_commonOverlap_(deletion, insertion); + var overlap_length2 = this.diff_commonOverlap_(insertion, deletion); + if (overlap_length1 >= overlap_length2) { + if (overlap_length1 >= deletion.length / 2 || + overlap_length1 >= insertion.length / 2) { + // Overlap found. Insert an equality and trim the surrounding edits. + diffs.splice(pointer, 0, + [DIFF_EQUAL, insertion.substring(0, overlap_length1)]); + diffs[pointer - 1][1] = + deletion.substring(0, deletion.length - overlap_length1); + diffs[pointer + 1][1] = insertion.substring(overlap_length1); + pointer++; + } + } else { + if (overlap_length2 >= deletion.length / 2 || + overlap_length2 >= insertion.length / 2) { + // Reverse overlap found. + // Insert an equality and swap and trim the surrounding edits. + diffs.splice(pointer, 0, + [DIFF_EQUAL, deletion.substring(0, overlap_length2)]); + diffs[pointer - 1][0] = DIFF_INSERT; + diffs[pointer - 1][1] = + insertion.substring(0, insertion.length - overlap_length2); + diffs[pointer + 1][0] = DIFF_DELETE; + diffs[pointer + 1][1] = + deletion.substring(overlap_length2); + pointer++; + } + } + pointer++; + } + pointer++; + } +}; + + +/** + * Look for single edits surrounded on both sides by equalities + * which can be shifted sideways to align the edit to a word boundary. + * e.g: The cat came. -> The cat came. + * @param {!Array.} diffs Array of diff tuples. + */ +diff_match_patch.prototype.diff_cleanupSemanticLossless = function(diffs) { + /** + * Given two strings, compute a score representing whether the internal + * boundary falls on logical boundaries. + * Scores range from 6 (best) to 0 (worst). + * Closure, but does not reference any external variables. + * @param {string} one First string. + * @param {string} two Second string. + * @return {number} The score. + * @private + */ + function diff_cleanupSemanticScore_(one, two) { + if (!one || !two) { + // Edges are the best. + return 6; + } + + // Each port of this function behaves slightly differently due to + // subtle differences in each language's definition of things like + // 'whitespace'. Since this function's purpose is largely cosmetic, + // the choice has been made to use each language's native features + // rather than force total conformity. + var char1 = one.charAt(one.length - 1); + var char2 = two.charAt(0); + var nonAlphaNumeric1 = char1.match(diff_match_patch.nonAlphaNumericRegex_); + var nonAlphaNumeric2 = char2.match(diff_match_patch.nonAlphaNumericRegex_); + var whitespace1 = nonAlphaNumeric1 && + char1.match(diff_match_patch.whitespaceRegex_); + var whitespace2 = nonAlphaNumeric2 && + char2.match(diff_match_patch.whitespaceRegex_); + var lineBreak1 = whitespace1 && + char1.match(diff_match_patch.linebreakRegex_); + var lineBreak2 = whitespace2 && + char2.match(diff_match_patch.linebreakRegex_); + var blankLine1 = lineBreak1 && + one.match(diff_match_patch.blanklineEndRegex_); + var blankLine2 = lineBreak2 && + two.match(diff_match_patch.blanklineStartRegex_); + + if (blankLine1 || blankLine2) { + // Five points for blank lines. + return 5; + } else if (lineBreak1 || lineBreak2) { + // Four points for line breaks. + return 4; + } else if (nonAlphaNumeric1 && !whitespace1 && whitespace2) { + // Three points for end of sentences. + return 3; + } else if (whitespace1 || whitespace2) { + // Two points for whitespace. + return 2; + } else if (nonAlphaNumeric1 || nonAlphaNumeric2) { + // One point for non-alphanumeric. + return 1; + } + return 0; + } + + var pointer = 1; + // Intentionally ignore the first and last element (don't need checking). + while (pointer < diffs.length - 1) { + if (diffs[pointer - 1][0] == DIFF_EQUAL && + diffs[pointer + 1][0] == DIFF_EQUAL) { + // This is a single edit surrounded by equalities. + var equality1 = diffs[pointer - 1][1]; + var edit = diffs[pointer][1]; + var equality2 = diffs[pointer + 1][1]; + + // First, shift the edit as far left as possible. + var commonOffset = this.diff_commonSuffix(equality1, edit); + if (commonOffset) { + var commonString = edit.substring(edit.length - commonOffset); + equality1 = equality1.substring(0, equality1.length - commonOffset); + edit = commonString + edit.substring(0, edit.length - commonOffset); + equality2 = commonString + equality2; + } + + // Second, step character by character right, looking for the best fit. + var bestEquality1 = equality1; + var bestEdit = edit; + var bestEquality2 = equality2; + var bestScore = diff_cleanupSemanticScore_(equality1, edit) + + diff_cleanupSemanticScore_(edit, equality2); + while (edit.charAt(0) === equality2.charAt(0)) { + equality1 += edit.charAt(0); + edit = edit.substring(1) + equality2.charAt(0); + equality2 = equality2.substring(1); + var score = diff_cleanupSemanticScore_(equality1, edit) + + diff_cleanupSemanticScore_(edit, equality2); + // The >= encourages trailing rather than leading whitespace on edits. + if (score >= bestScore) { + bestScore = score; + bestEquality1 = equality1; + bestEdit = edit; + bestEquality2 = equality2; + } + } + + if (diffs[pointer - 1][1] != bestEquality1) { + // We have an improvement, save it back to the diff. + if (bestEquality1) { + diffs[pointer - 1][1] = bestEquality1; + } else { + diffs.splice(pointer - 1, 1); + pointer--; + } + diffs[pointer][1] = bestEdit; + if (bestEquality2) { + diffs[pointer + 1][1] = bestEquality2; + } else { + diffs.splice(pointer + 1, 1); + pointer--; + } + } + } + pointer++; + } +}; + +// Define some regex patterns for matching boundaries. +diff_match_patch.nonAlphaNumericRegex_ = /[^a-zA-Z0-9]/; +diff_match_patch.whitespaceRegex_ = /\s/; +diff_match_patch.linebreakRegex_ = /[\r\n]/; +diff_match_patch.blanklineEndRegex_ = /\n\r?\n$/; +diff_match_patch.blanklineStartRegex_ = /^\r?\n\r?\n/; + +/** + * Reduce the number of edits by eliminating operationally trivial equalities. + * @param {!Array.} diffs Array of diff tuples. + */ +diff_match_patch.prototype.diff_cleanupEfficiency = function(diffs) { + var changes = false; + var equalities = []; // Stack of indices where equalities are found. + var equalitiesLength = 0; // Keeping our own length var is faster in JS. + /** @type {?string} */ + var lastequality = null; + // Always equal to diffs[equalities[equalitiesLength - 1]][1] + var pointer = 0; // Index of current position. + // Is there an insertion operation before the last equality. + var pre_ins = false; + // Is there a deletion operation before the last equality. + var pre_del = false; + // Is there an insertion operation after the last equality. + var post_ins = false; + // Is there a deletion operation after the last equality. + var post_del = false; + while (pointer < diffs.length) { + if (diffs[pointer][0] == DIFF_EQUAL) { // Equality found. + if (diffs[pointer][1].length < this.Diff_EditCost && + (post_ins || post_del)) { + // Candidate found. + equalities[equalitiesLength++] = pointer; + pre_ins = post_ins; + pre_del = post_del; + lastequality = diffs[pointer][1]; + } else { + // Not a candidate, and can never become one. + equalitiesLength = 0; + lastequality = null; + } + post_ins = post_del = false; + } else { // An insertion or deletion. + if (diffs[pointer][0] == DIFF_DELETE) { + post_del = true; + } else { + post_ins = true; + } + /* + * Five types to be split: + * ABXYCD + * AXCD + * ABXC + * AXCD + * ABXC + */ + if (lastequality && ((pre_ins && pre_del && post_ins && post_del) || + ((lastequality.length < this.Diff_EditCost / 2) && + (pre_ins + pre_del + post_ins + post_del) == 3))) { + // Duplicate record. + diffs.splice(equalities[equalitiesLength - 1], 0, + [DIFF_DELETE, lastequality]); + // Change second copy to insert. + diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT; + equalitiesLength--; // Throw away the equality we just deleted; + lastequality = null; + if (pre_ins && pre_del) { + // No changes made which could affect previous entry, keep going. + post_ins = post_del = true; + equalitiesLength = 0; + } else { + equalitiesLength--; // Throw away the previous equality. + pointer = equalitiesLength > 0 ? + equalities[equalitiesLength - 1] : -1; + post_ins = post_del = false; + } + changes = true; + } + } + pointer++; + } + + if (changes) { + this.diff_cleanupMerge(diffs); + } +}; + + +/** + * Reorder and merge like edit sections. Merge equalities. + * Any edit section can move as long as it doesn't cross an equality. + * @param {!Array.} diffs Array of diff tuples. + */ +diff_match_patch.prototype.diff_cleanupMerge = function(diffs) { + diffs.push([DIFF_EQUAL, '']); // Add a dummy entry at the end. + var pointer = 0; + var count_delete = 0; + var count_insert = 0; + var text_delete = ''; + var text_insert = ''; + var commonlength; + while (pointer < diffs.length) { + switch (diffs[pointer][0]) { + case DIFF_INSERT: + count_insert++; + text_insert += diffs[pointer][1]; + pointer++; + break; + case DIFF_DELETE: + count_delete++; + text_delete += diffs[pointer][1]; + pointer++; + break; + case DIFF_EQUAL: + // Upon reaching an equality, check for prior redundancies. + if (count_delete + count_insert > 1) { + if (count_delete !== 0 && count_insert !== 0) { + // Factor out any common prefixies. + commonlength = this.diff_commonPrefix(text_insert, text_delete); + if (commonlength !== 0) { + if ((pointer - count_delete - count_insert) > 0 && + diffs[pointer - count_delete - count_insert - 1][0] == + DIFF_EQUAL) { + diffs[pointer - count_delete - count_insert - 1][1] += + text_insert.substring(0, commonlength); + } else { + diffs.splice(0, 0, [DIFF_EQUAL, + text_insert.substring(0, commonlength)]); + pointer++; + } + text_insert = text_insert.substring(commonlength); + text_delete = text_delete.substring(commonlength); + } + // Factor out any common suffixies. + commonlength = this.diff_commonSuffix(text_insert, text_delete); + if (commonlength !== 0) { + diffs[pointer][1] = text_insert.substring(text_insert.length - + commonlength) + diffs[pointer][1]; + text_insert = text_insert.substring(0, text_insert.length - + commonlength); + text_delete = text_delete.substring(0, text_delete.length - + commonlength); + } + } + // Delete the offending records and add the merged ones. + if (count_delete === 0) { + diffs.splice(pointer - count_insert, + count_delete + count_insert, [DIFF_INSERT, text_insert]); + } else if (count_insert === 0) { + diffs.splice(pointer - count_delete, + count_delete + count_insert, [DIFF_DELETE, text_delete]); + } else { + diffs.splice(pointer - count_delete - count_insert, + count_delete + count_insert, [DIFF_DELETE, text_delete], + [DIFF_INSERT, text_insert]); + } + pointer = pointer - count_delete - count_insert + + (count_delete ? 1 : 0) + (count_insert ? 1 : 0) + 1; + } else if (pointer !== 0 && diffs[pointer - 1][0] == DIFF_EQUAL) { + // Merge this equality with the previous one. + diffs[pointer - 1][1] += diffs[pointer][1]; + diffs.splice(pointer, 1); + } else { + pointer++; + } + count_insert = 0; + count_delete = 0; + text_delete = ''; + text_insert = ''; + break; + } + } + if (diffs[diffs.length - 1][1] === '') { + diffs.pop(); // Remove the dummy entry at the end. + } + + // Second pass: look for single edits surrounded on both sides by equalities + // which can be shifted sideways to eliminate an equality. + // e.g: ABAC -> ABAC + var changes = false; + pointer = 1; + // Intentionally ignore the first and last element (don't need checking). + while (pointer < diffs.length - 1) { + if (diffs[pointer - 1][0] == DIFF_EQUAL && + diffs[pointer + 1][0] == DIFF_EQUAL) { + // This is a single edit surrounded by equalities. + if (diffs[pointer][1].substring(diffs[pointer][1].length - + diffs[pointer - 1][1].length) == diffs[pointer - 1][1]) { + // Shift the edit over the previous equality. + diffs[pointer][1] = diffs[pointer - 1][1] + + diffs[pointer][1].substring(0, diffs[pointer][1].length - + diffs[pointer - 1][1].length); + diffs[pointer + 1][1] = diffs[pointer - 1][1] + diffs[pointer + 1][1]; + diffs.splice(pointer - 1, 1); + changes = true; + } else if (diffs[pointer][1].substring(0, diffs[pointer + 1][1].length) == + diffs[pointer + 1][1]) { + // Shift the edit over the next equality. + diffs[pointer - 1][1] += diffs[pointer + 1][1]; + diffs[pointer][1] = + diffs[pointer][1].substring(diffs[pointer + 1][1].length) + + diffs[pointer + 1][1]; + diffs.splice(pointer + 1, 1); + changes = true; + } + } + pointer++; + } + // If shifts were made, the diff needs reordering and another shift sweep. + if (changes) { + this.diff_cleanupMerge(diffs); + } +}; + + +/** + * loc is a location in text1, compute and return the equivalent location in + * text2. + * e.g. 'The cat' vs 'The big cat', 1->1, 5->8 + * @param {!Array.} diffs Array of diff tuples. + * @param {number} loc Location within text1. + * @return {number} Location within text2. + */ +diff_match_patch.prototype.diff_xIndex = function(diffs, loc) { + var chars1 = 0; + var chars2 = 0; + var last_chars1 = 0; + var last_chars2 = 0; + var x; + for (x = 0; x < diffs.length; x++) { + if (diffs[x][0] !== DIFF_INSERT) { // Equality or deletion. + chars1 += diffs[x][1].length; + } + if (diffs[x][0] !== DIFF_DELETE) { // Equality or insertion. + chars2 += diffs[x][1].length; + } + if (chars1 > loc) { // Overshot the location. + break; + } + last_chars1 = chars1; + last_chars2 = chars2; + } + // Was the location was deleted? + if (diffs.length != x && diffs[x][0] === DIFF_DELETE) { + return last_chars2; + } + // Add the remaining character length. + return last_chars2 + (loc - last_chars1); +}; + + +/** + * Convert a diff array into a pretty HTML report. + * @param {!Array.} diffs Array of diff tuples. + * @return {string} HTML representation. + */ +diff_match_patch.prototype.diff_prettyHtml = function(diffs) { + var html = []; + var pattern_amp = /&/g; + var pattern_lt = //g; + var pattern_para = /\n/g; + for (var x = 0; x < diffs.length; x++) { + var op = diffs[x][0]; // Operation (insert, delete, equal) + var data = diffs[x][1]; // Text of change. + var text = data.replace(pattern_amp, '&').replace(pattern_lt, '<') + .replace(pattern_gt, '>').replace(pattern_para, '¶
'); + switch (op) { + case DIFF_INSERT: + html[x] = '' + text + ''; + break; + case DIFF_DELETE: + html[x] = '' + text + ''; + break; + case DIFF_EQUAL: + html[x] = '' + text + ''; + break; + } + } + return html.join(''); +}; + + +/** + * Compute and return the source text (all equalities and deletions). + * @param {!Array.} diffs Array of diff tuples. + * @return {string} Source text. + */ +diff_match_patch.prototype.diff_text1 = function(diffs) { + var text = []; + for (var x = 0; x < diffs.length; x++) { + if (diffs[x][0] !== DIFF_INSERT) { + text[x] = diffs[x][1]; + } + } + return text.join(''); +}; + + +/** + * Compute and return the destination text (all equalities and insertions). + * @param {!Array.} diffs Array of diff tuples. + * @return {string} Destination text. + */ +diff_match_patch.prototype.diff_text2 = function(diffs) { + var text = []; + for (var x = 0; x < diffs.length; x++) { + if (diffs[x][0] !== DIFF_DELETE) { + text[x] = diffs[x][1]; + } + } + return text.join(''); +}; + + +/** + * Compute the Levenshtein distance; the number of inserted, deleted or + * substituted characters. + * @param {!Array.} diffs Array of diff tuples. + * @return {number} Number of changes. + */ +diff_match_patch.prototype.diff_levenshtein = function(diffs) { + var levenshtein = 0; + var insertions = 0; + var deletions = 0; + for (var x = 0; x < diffs.length; x++) { + var op = diffs[x][0]; + var data = diffs[x][1]; + switch (op) { + case DIFF_INSERT: + insertions += data.length; + break; + case DIFF_DELETE: + deletions += data.length; + break; + case DIFF_EQUAL: + // A deletion and an insertion is one substitution. + levenshtein += Math.max(insertions, deletions); + insertions = 0; + deletions = 0; + break; + } + } + levenshtein += Math.max(insertions, deletions); + return levenshtein; +}; + + +/** + * Crush the diff into an encoded string which describes the operations + * required to transform text1 into text2. + * E.g. =3\t-2\t+ing -> Keep 3 chars, delete 2 chars, insert 'ing'. + * Operations are tab-separated. Inserted text is escaped using %xx notation. + * @param {!Array.} diffs Array of diff tuples. + * @return {string} Delta text. + */ +diff_match_patch.prototype.diff_toDelta = function(diffs) { + var text = []; + for (var x = 0; x < diffs.length; x++) { + switch (diffs[x][0]) { + case DIFF_INSERT: + text[x] = '+' + encodeURI(diffs[x][1]); + break; + case DIFF_DELETE: + text[x] = '-' + diffs[x][1].length; + break; + case DIFF_EQUAL: + text[x] = '=' + diffs[x][1].length; + break; + } + } + return text.join('\t').replace(/%20/g, ' '); +}; + + +/** + * Given the original text1, and an encoded string which describes the + * operations required to transform text1 into text2, compute the full diff. + * @param {string} text1 Source string for the diff. + * @param {string} delta Delta text. + * @return {!Array.} Array of diff tuples. + * @throws {!Error} If invalid input. + */ +diff_match_patch.prototype.diff_fromDelta = function(text1, delta) { + var diffs = []; + var diffsLength = 0; // Keeping our own length var is faster in JS. + var pointer = 0; // Cursor in text1 + var tokens = delta.split(/\t/g); + for (var x = 0; x < tokens.length; x++) { + // Each token begins with a one character parameter which specifies the + // operation of this token (delete, insert, equality). + var param = tokens[x].substring(1); + switch (tokens[x].charAt(0)) { + case '+': + try { + diffs[diffsLength++] = [DIFF_INSERT, decodeURI(param)]; + } catch (ex) { + // Malformed URI sequence. + throw new Error('Illegal escape in diff_fromDelta: ' + param); + } + break; + case '-': + // Fall through. + case '=': + var n = parseInt(param, 10); + if (isNaN(n) || n < 0) { + throw new Error('Invalid number in diff_fromDelta: ' + param); + } + var text = text1.substring(pointer, pointer += n); + if (tokens[x].charAt(0) == '=') { + diffs[diffsLength++] = [DIFF_EQUAL, text]; + } else { + diffs[diffsLength++] = [DIFF_DELETE, text]; + } + break; + default: + // Blank tokens are ok (from a trailing \t). + // Anything else is an error. + if (tokens[x]) { + throw new Error('Invalid diff operation in diff_fromDelta: ' + + tokens[x]); + } + } + } + if (pointer != text1.length) { + throw new Error('Delta length (' + pointer + + ') does not equal source text length (' + text1.length + ').'); + } + return diffs; +}; + + +// MATCH FUNCTIONS + + +/** + * Locate the best instance of 'pattern' in 'text' near 'loc'. + * @param {string} text The text to search. + * @param {string} pattern The pattern to search for. + * @param {number} loc The location to search around. + * @return {number} Best match index or -1. + */ +diff_match_patch.prototype.match_main = function(text, pattern, loc) { + // Check for null inputs. + if (text == null || pattern == null || loc == null) { + throw new Error('Null input. (match_main)'); + } + + loc = Math.max(0, Math.min(loc, text.length)); + if (text == pattern) { + // Shortcut (potentially not guaranteed by the algorithm) + return 0; + } else if (!text.length) { + // Nothing to match. + return -1; + } else if (text.substring(loc, loc + pattern.length) == pattern) { + // Perfect match at the perfect spot! (Includes case of null pattern) + return loc; + } else { + // Do a fuzzy compare. + return this.match_bitap_(text, pattern, loc); + } +}; + + +/** + * Locate the best instance of 'pattern' in 'text' near 'loc' using the + * Bitap algorithm. + * @param {string} text The text to search. + * @param {string} pattern The pattern to search for. + * @param {number} loc The location to search around. + * @return {number} Best match index or -1. + * @private + */ +diff_match_patch.prototype.match_bitap_ = function(text, pattern, loc) { + if (pattern.length > this.Match_MaxBits) { + throw new Error('Pattern too long for this browser.'); + } + + // Initialise the alphabet. + var s = this.match_alphabet_(pattern); + + var dmp = this; // 'this' becomes 'window' in a closure. + + /** + * Compute and return the score for a match with e errors and x location. + * Accesses loc and pattern through being a closure. + * @param {number} e Number of errors in match. + * @param {number} x Location of match. + * @return {number} Overall score for match (0.0 = good, 1.0 = bad). + * @private + */ + function match_bitapScore_(e, x) { + var accuracy = e / pattern.length; + var proximity = Math.abs(loc - x); + if (!dmp.Match_Distance) { + // Dodge divide by zero error. + return proximity ? 1.0 : accuracy; + } + return accuracy + (proximity / dmp.Match_Distance); + } + + // Highest score beyond which we give up. + var score_threshold = this.Match_Threshold; + // Is there a nearby exact match? (speedup) + var best_loc = text.indexOf(pattern, loc); + if (best_loc != -1) { + score_threshold = Math.min(match_bitapScore_(0, best_loc), score_threshold); + // What about in the other direction? (speedup) + best_loc = text.lastIndexOf(pattern, loc + pattern.length); + if (best_loc != -1) { + score_threshold = + Math.min(match_bitapScore_(0, best_loc), score_threshold); + } + } + + // Initialise the bit arrays. + var matchmask = 1 << (pattern.length - 1); + best_loc = -1; + + var bin_min, bin_mid; + var bin_max = pattern.length + text.length; + var last_rd; + for (var d = 0; d < pattern.length; d++) { + // Scan for the best match; each iteration allows for one more error. + // Run a binary search to determine how far from 'loc' we can stray at this + // error level. + bin_min = 0; + bin_mid = bin_max; + while (bin_min < bin_mid) { + if (match_bitapScore_(d, loc + bin_mid) <= score_threshold) { + bin_min = bin_mid; + } else { + bin_max = bin_mid; + } + bin_mid = Math.floor((bin_max - bin_min) / 2 + bin_min); + } + // Use the result from this iteration as the maximum for the next. + bin_max = bin_mid; + var start = Math.max(1, loc - bin_mid + 1); + var finish = Math.min(loc + bin_mid, text.length) + pattern.length; + + var rd = Array(finish + 2); + rd[finish + 1] = (1 << d) - 1; + for (var j = finish; j >= start; j--) { + // The alphabet (s) is a sparse hash, so the following line generates + // warnings. + var charMatch = s[text.charAt(j - 1)]; + if (d === 0) { // First pass: exact match. + rd[j] = ((rd[j + 1] << 1) | 1) & charMatch; + } else { // Subsequent passes: fuzzy match. + rd[j] = (((rd[j + 1] << 1) | 1) & charMatch) | + (((last_rd[j + 1] | last_rd[j]) << 1) | 1) | + last_rd[j + 1]; + } + if (rd[j] & matchmask) { + var score = match_bitapScore_(d, j - 1); + // This match will almost certainly be better than any existing match. + // But check anyway. + if (score <= score_threshold) { + // Told you so. + score_threshold = score; + best_loc = j - 1; + if (best_loc > loc) { + // When passing loc, don't exceed our current distance from loc. + start = Math.max(1, 2 * loc - best_loc); + } else { + // Already passed loc, downhill from here on in. + break; + } + } + } + } + // No hope for a (better) match at greater error levels. + if (match_bitapScore_(d + 1, loc) > score_threshold) { + break; + } + last_rd = rd; + } + return best_loc; +}; + + +/** + * Initialise the alphabet for the Bitap algorithm. + * @param {string} pattern The text to encode. + * @return {!Object} Hash of character locations. + * @private + */ +diff_match_patch.prototype.match_alphabet_ = function(pattern) { + var s = {}; + for (var i = 0; i < pattern.length; i++) { + s[pattern.charAt(i)] = 0; + } + for (var i = 0; i < pattern.length; i++) { + s[pattern.charAt(i)] |= 1 << (pattern.length - i - 1); + } + return s; +}; + + +// PATCH FUNCTIONS + + +/** + * Increase the context until it is unique, + * but don't let the pattern expand beyond Match_MaxBits. + * @param {!diff_match_patch.patch_obj} patch The patch to grow. + * @param {string} text Source text. + * @private + */ +diff_match_patch.prototype.patch_addContext_ = function(patch, text) { + if (text.length == 0) { + return; + } + var pattern = text.substring(patch.start2, patch.start2 + patch.length1); + var padding = 0; + + // Look for the first and last matches of pattern in text. If two different + // matches are found, increase the pattern length. + while (text.indexOf(pattern) != text.lastIndexOf(pattern) && + pattern.length < this.Match_MaxBits - this.Patch_Margin - + this.Patch_Margin) { + padding += this.Patch_Margin; + pattern = text.substring(patch.start2 - padding, + patch.start2 + patch.length1 + padding); + } + // Add one chunk for good luck. + padding += this.Patch_Margin; + + // Add the prefix. + var prefix = text.substring(patch.start2 - padding, patch.start2); + if (prefix) { + patch.diffs.unshift([DIFF_EQUAL, prefix]); + } + // Add the suffix. + var suffix = text.substring(patch.start2 + patch.length1, + patch.start2 + patch.length1 + padding); + if (suffix) { + patch.diffs.push([DIFF_EQUAL, suffix]); + } + + // Roll back the start points. + patch.start1 -= prefix.length; + patch.start2 -= prefix.length; + // Extend the lengths. + patch.length1 += prefix.length + suffix.length; + patch.length2 += prefix.length + suffix.length; +}; + + +/** + * Compute a list of patches to turn text1 into text2. + * Use diffs if provided, otherwise compute it ourselves. + * There are four ways to call this function, depending on what data is + * available to the caller: + * Method 1: + * a = text1, b = text2 + * Method 2: + * a = diffs + * Method 3 (optimal): + * a = text1, b = diffs + * Method 4 (deprecated, use method 3): + * a = text1, b = text2, c = diffs + * + * @param {string|!Array.} a text1 (methods 1,3,4) or + * Array of diff tuples for text1 to text2 (method 2). + * @param {string|!Array.} opt_b text2 (methods 1,4) or + * Array of diff tuples for text1 to text2 (method 3) or undefined (method 2). + * @param {string|!Array.} opt_c Array of diff tuples + * for text1 to text2 (method 4) or undefined (methods 1,2,3). + * @return {!Array.} Array of Patch objects. + */ +diff_match_patch.prototype.patch_make = function(a, opt_b, opt_c) { + var text1, diffs; + if (typeof a == 'string' && typeof opt_b == 'string' && + typeof opt_c == 'undefined') { + // Method 1: text1, text2 + // Compute diffs from text1 and text2. + text1 = /** @type {string} */(a); + diffs = this.diff_main(text1, /** @type {string} */(opt_b), true); + if (diffs.length > 2) { + this.diff_cleanupSemantic(diffs); + this.diff_cleanupEfficiency(diffs); + } + } else if (a && typeof a == 'object' && typeof opt_b == 'undefined' && + typeof opt_c == 'undefined') { + // Method 2: diffs + // Compute text1 from diffs. + diffs = /** @type {!Array.} */(a); + text1 = this.diff_text1(diffs); + } else if (typeof a == 'string' && opt_b && typeof opt_b == 'object' && + typeof opt_c == 'undefined') { + // Method 3: text1, diffs + text1 = /** @type {string} */(a); + diffs = /** @type {!Array.} */(opt_b); + } else if (typeof a == 'string' && typeof opt_b == 'string' && + opt_c && typeof opt_c == 'object') { + // Method 4: text1, text2, diffs + // text2 is not used. + text1 = /** @type {string} */(a); + diffs = /** @type {!Array.} */(opt_c); + } else { + throw new Error('Unknown call format to patch_make.'); + } + + if (diffs.length === 0) { + return []; // Get rid of the null case. + } + var patches = []; + var patch = new diff_match_patch.patch_obj(); + var patchDiffLength = 0; // Keeping our own length var is faster in JS. + var char_count1 = 0; // Number of characters into the text1 string. + var char_count2 = 0; // Number of characters into the text2 string. + // Start with text1 (prepatch_text) and apply the diffs until we arrive at + // text2 (postpatch_text). We recreate the patches one by one to determine + // context info. + var prepatch_text = text1; + var postpatch_text = text1; + for (var x = 0; x < diffs.length; x++) { + var diff_type = diffs[x][0]; + var diff_text = diffs[x][1]; + + if (!patchDiffLength && diff_type !== DIFF_EQUAL) { + // A new patch starts here. + patch.start1 = char_count1; + patch.start2 = char_count2; + } + + switch (diff_type) { + case DIFF_INSERT: + patch.diffs[patchDiffLength++] = diffs[x]; + patch.length2 += diff_text.length; + postpatch_text = postpatch_text.substring(0, char_count2) + diff_text + + postpatch_text.substring(char_count2); + break; + case DIFF_DELETE: + patch.length1 += diff_text.length; + patch.diffs[patchDiffLength++] = diffs[x]; + postpatch_text = postpatch_text.substring(0, char_count2) + + postpatch_text.substring(char_count2 + + diff_text.length); + break; + case DIFF_EQUAL: + if (diff_text.length <= 2 * this.Patch_Margin && + patchDiffLength && diffs.length != x + 1) { + // Small equality inside a patch. + patch.diffs[patchDiffLength++] = diffs[x]; + patch.length1 += diff_text.length; + patch.length2 += diff_text.length; + } else if (diff_text.length >= 2 * this.Patch_Margin) { + // Time for a new patch. + if (patchDiffLength) { + this.patch_addContext_(patch, prepatch_text); + patches.push(patch); + patch = new diff_match_patch.patch_obj(); + patchDiffLength = 0; + // Unlike Unidiff, our patch lists have a rolling context. + // http://code.google.com/p/google-diff-match-patch/wiki/Unidiff + // Update prepatch text & pos to reflect the application of the + // just completed patch. + prepatch_text = postpatch_text; + char_count1 = char_count2; + } + } + break; + } + + // Update the current character count. + if (diff_type !== DIFF_INSERT) { + char_count1 += diff_text.length; + } + if (diff_type !== DIFF_DELETE) { + char_count2 += diff_text.length; + } + } + // Pick up the leftover patch if not empty. + if (patchDiffLength) { + this.patch_addContext_(patch, prepatch_text); + patches.push(patch); + } + + return patches; +}; + + +/** + * Given an array of patches, return another array that is identical. + * @param {!Array.} patches Array of Patch objects. + * @return {!Array.} Array of Patch objects. + */ +diff_match_patch.prototype.patch_deepCopy = function(patches) { + // Making deep copies is hard in JavaScript. + var patchesCopy = []; + for (var x = 0; x < patches.length; x++) { + var patch = patches[x]; + var patchCopy = new diff_match_patch.patch_obj(); + patchCopy.diffs = []; + for (var y = 0; y < patch.diffs.length; y++) { + patchCopy.diffs[y] = patch.diffs[y].slice(); + } + patchCopy.start1 = patch.start1; + patchCopy.start2 = patch.start2; + patchCopy.length1 = patch.length1; + patchCopy.length2 = patch.length2; + patchesCopy[x] = patchCopy; + } + return patchesCopy; +}; + + +/** + * Merge a set of patches onto the text. Return a patched text, as well + * as a list of true/false values indicating which patches were applied. + * @param {!Array.} patches Array of Patch objects. + * @param {string} text Old text. + * @return {!Array.>} Two element Array, containing the + * new text and an array of boolean values. + */ +diff_match_patch.prototype.patch_apply = function(patches, text) { + if (patches.length == 0) { + return [text, []]; + } + + // Deep copy the patches so that no changes are made to originals. + patches = this.patch_deepCopy(patches); + + var nullPadding = this.patch_addPadding(patches); + text = nullPadding + text + nullPadding; + + this.patch_splitMax(patches); + // delta keeps track of the offset between the expected and actual location + // of the previous patch. If there are patches expected at positions 10 and + // 20, but the first patch was found at 12, delta is 2 and the second patch + // has an effective expected position of 22. + var delta = 0; + var results = []; + for (var x = 0; x < patches.length; x++) { + var expected_loc = patches[x].start2 + delta; + var text1 = this.diff_text1(patches[x].diffs); + var start_loc; + var end_loc = -1; + if (text1.length > this.Match_MaxBits) { + // patch_splitMax will only provide an oversized pattern in the case of + // a monster delete. + start_loc = this.match_main(text, text1.substring(0, this.Match_MaxBits), + expected_loc); + if (start_loc != -1) { + end_loc = this.match_main(text, + text1.substring(text1.length - this.Match_MaxBits), + expected_loc + text1.length - this.Match_MaxBits); + if (end_loc == -1 || start_loc >= end_loc) { + // Can't find valid trailing context. Drop this patch. + start_loc = -1; + } + } + } else { + start_loc = this.match_main(text, text1, expected_loc); + } + if (start_loc == -1) { + // No match found. :( + results[x] = false; + // Subtract the delta for this failed patch from subsequent patches. + delta -= patches[x].length2 - patches[x].length1; + } else { + // Found a match. :) + results[x] = true; + delta = start_loc - expected_loc; + var text2; + if (end_loc == -1) { + text2 = text.substring(start_loc, start_loc + text1.length); + } else { + text2 = text.substring(start_loc, end_loc + this.Match_MaxBits); + } + if (text1 == text2) { + // Perfect match, just shove the replacement text in. + text = text.substring(0, start_loc) + + this.diff_text2(patches[x].diffs) + + text.substring(start_loc + text1.length); + } else { + // Imperfect match. Run a diff to get a framework of equivalent + // indices. + var diffs = this.diff_main(text1, text2, false); + if (text1.length > this.Match_MaxBits && + this.diff_levenshtein(diffs) / text1.length > + this.Patch_DeleteThreshold) { + // The end points match, but the content is unacceptably bad. + results[x] = false; + } else { + this.diff_cleanupSemanticLossless(diffs); + var index1 = 0; + var index2; + for (var y = 0; y < patches[x].diffs.length; y++) { + var mod = patches[x].diffs[y]; + if (mod[0] !== DIFF_EQUAL) { + index2 = this.diff_xIndex(diffs, index1); + } + if (mod[0] === DIFF_INSERT) { // Insertion + text = text.substring(0, start_loc + index2) + mod[1] + + text.substring(start_loc + index2); + } else if (mod[0] === DIFF_DELETE) { // Deletion + text = text.substring(0, start_loc + index2) + + text.substring(start_loc + this.diff_xIndex(diffs, + index1 + mod[1].length)); + } + if (mod[0] !== DIFF_DELETE) { + index1 += mod[1].length; + } + } + } + } + } + } + // Strip the padding off. + text = text.substring(nullPadding.length, text.length - nullPadding.length); + return [text, results]; +}; + + +/** + * Add some padding on text start and end so that edges can match something. + * Intended to be called only from within patch_apply. + * @param {!Array.} patches Array of Patch objects. + * @return {string} The padding string added to each side. + */ +diff_match_patch.prototype.patch_addPadding = function(patches) { + var paddingLength = this.Patch_Margin; + var nullPadding = ''; + for (var x = 1; x <= paddingLength; x++) { + nullPadding += String.fromCharCode(x); + } + + // Bump all the patches forward. + for (var x = 0; x < patches.length; x++) { + patches[x].start1 += paddingLength; + patches[x].start2 += paddingLength; + } + + // Add some padding on start of first diff. + var patch = patches[0]; + var diffs = patch.diffs; + if (diffs.length == 0 || diffs[0][0] != DIFF_EQUAL) { + // Add nullPadding equality. + diffs.unshift([DIFF_EQUAL, nullPadding]); + patch.start1 -= paddingLength; // Should be 0. + patch.start2 -= paddingLength; // Should be 0. + patch.length1 += paddingLength; + patch.length2 += paddingLength; + } else if (paddingLength > diffs[0][1].length) { + // Grow first equality. + var extraLength = paddingLength - diffs[0][1].length; + diffs[0][1] = nullPadding.substring(diffs[0][1].length) + diffs[0][1]; + patch.start1 -= extraLength; + patch.start2 -= extraLength; + patch.length1 += extraLength; + patch.length2 += extraLength; + } + + // Add some padding on end of last diff. + patch = patches[patches.length - 1]; + diffs = patch.diffs; + if (diffs.length == 0 || diffs[diffs.length - 1][0] != DIFF_EQUAL) { + // Add nullPadding equality. + diffs.push([DIFF_EQUAL, nullPadding]); + patch.length1 += paddingLength; + patch.length2 += paddingLength; + } else if (paddingLength > diffs[diffs.length - 1][1].length) { + // Grow last equality. + var extraLength = paddingLength - diffs[diffs.length - 1][1].length; + diffs[diffs.length - 1][1] += nullPadding.substring(0, extraLength); + patch.length1 += extraLength; + patch.length2 += extraLength; + } + + return nullPadding; +}; + + +/** + * Look through the patches and break up any which are longer than the maximum + * limit of the match algorithm. + * Intended to be called only from within patch_apply. + * @param {!Array.} patches Array of Patch objects. + */ +diff_match_patch.prototype.patch_splitMax = function(patches) { + var patch_size = this.Match_MaxBits; + for (var x = 0; x < patches.length; x++) { + if (patches[x].length1 <= patch_size) { + continue; + } + var bigpatch = patches[x]; + // Remove the big old patch. + patches.splice(x--, 1); + var start1 = bigpatch.start1; + var start2 = bigpatch.start2; + var precontext = ''; + while (bigpatch.diffs.length !== 0) { + // Create one of several smaller patches. + var patch = new diff_match_patch.patch_obj(); + var empty = true; + patch.start1 = start1 - precontext.length; + patch.start2 = start2 - precontext.length; + if (precontext !== '') { + patch.length1 = patch.length2 = precontext.length; + patch.diffs.push([DIFF_EQUAL, precontext]); + } + while (bigpatch.diffs.length !== 0 && + patch.length1 < patch_size - this.Patch_Margin) { + var diff_type = bigpatch.diffs[0][0]; + var diff_text = bigpatch.diffs[0][1]; + if (diff_type === DIFF_INSERT) { + // Insertions are harmless. + patch.length2 += diff_text.length; + start2 += diff_text.length; + patch.diffs.push(bigpatch.diffs.shift()); + empty = false; + } else if (diff_type === DIFF_DELETE && patch.diffs.length == 1 && + patch.diffs[0][0] == DIFF_EQUAL && + diff_text.length > 2 * patch_size) { + // This is a large deletion. Let it pass in one chunk. + patch.length1 += diff_text.length; + start1 += diff_text.length; + empty = false; + patch.diffs.push([diff_type, diff_text]); + bigpatch.diffs.shift(); + } else { + // Deletion or equality. Only take as much as we can stomach. + diff_text = diff_text.substring(0, + patch_size - patch.length1 - this.Patch_Margin); + patch.length1 += diff_text.length; + start1 += diff_text.length; + if (diff_type === DIFF_EQUAL) { + patch.length2 += diff_text.length; + start2 += diff_text.length; + } else { + empty = false; + } + patch.diffs.push([diff_type, diff_text]); + if (diff_text == bigpatch.diffs[0][1]) { + bigpatch.diffs.shift(); + } else { + bigpatch.diffs[0][1] = + bigpatch.diffs[0][1].substring(diff_text.length); + } + } + } + // Compute the head context for the next patch. + precontext = this.diff_text2(patch.diffs); + precontext = + precontext.substring(precontext.length - this.Patch_Margin); + // Append the end context for this patch. + var postcontext = this.diff_text1(bigpatch.diffs) + .substring(0, this.Patch_Margin); + if (postcontext !== '') { + patch.length1 += postcontext.length; + patch.length2 += postcontext.length; + if (patch.diffs.length !== 0 && + patch.diffs[patch.diffs.length - 1][0] === DIFF_EQUAL) { + patch.diffs[patch.diffs.length - 1][1] += postcontext; + } else { + patch.diffs.push([DIFF_EQUAL, postcontext]); + } + } + if (!empty) { + patches.splice(++x, 0, patch); + } + } + } +}; + + +/** + * Take a list of patches and return a textual representation. + * @param {!Array.} patches Array of Patch objects. + * @return {string} Text representation of patches. + */ +diff_match_patch.prototype.patch_toText = function(patches) { + var text = []; + for (var x = 0; x < patches.length; x++) { + text[x] = patches[x]; + } + return text.join(''); +}; + + +/** + * Parse a textual representation of patches and return a list of Patch objects. + * @param {string} textline Text representation of patches. + * @return {!Array.} Array of Patch objects. + * @throws {!Error} If invalid input. + */ +diff_match_patch.prototype.patch_fromText = function(textline) { + var patches = []; + if (!textline) { + return patches; + } + var text = textline.split('\n'); + var textPointer = 0; + var patchHeader = /^@@ -(\d+),?(\d*) \+(\d+),?(\d*) @@$/; + while (textPointer < text.length) { + var m = text[textPointer].match(patchHeader); + if (!m) { + throw new Error('Invalid patch string: ' + text[textPointer]); + } + var patch = new diff_match_patch.patch_obj(); + patches.push(patch); + patch.start1 = parseInt(m[1], 10); + if (m[2] === '') { + patch.start1--; + patch.length1 = 1; + } else if (m[2] == '0') { + patch.length1 = 0; + } else { + patch.start1--; + patch.length1 = parseInt(m[2], 10); + } + + patch.start2 = parseInt(m[3], 10); + if (m[4] === '') { + patch.start2--; + patch.length2 = 1; + } else if (m[4] == '0') { + patch.length2 = 0; + } else { + patch.start2--; + patch.length2 = parseInt(m[4], 10); + } + textPointer++; + + while (textPointer < text.length) { + var sign = text[textPointer].charAt(0); + try { + var line = decodeURI(text[textPointer].substring(1)); + } catch (ex) { + // Malformed URI sequence. + throw new Error('Illegal escape in patch_fromText: ' + line); + } + if (sign == '-') { + // Deletion. + patch.diffs.push([DIFF_DELETE, line]); + } else if (sign == '+') { + // Insertion. + patch.diffs.push([DIFF_INSERT, line]); + } else if (sign == ' ') { + // Minor equality. + patch.diffs.push([DIFF_EQUAL, line]); + } else if (sign == '@') { + // Start of next patch. + break; + } else if (sign === '') { + // Blank line? Whatever. + } else { + // WTF? + throw new Error('Invalid patch mode "' + sign + '" in: ' + line); + } + textPointer++; + } + } + return patches; +}; + + +/** + * Class representing one patch operation. + * @constructor + */ +diff_match_patch.patch_obj = function() { + /** @type {!Array.} */ + this.diffs = []; + /** @type {?number} */ + this.start1 = null; + /** @type {?number} */ + this.start2 = null; + /** @type {number} */ + this.length1 = 0; + /** @type {number} */ + this.length2 = 0; +}; + + +/** + * Emmulate GNU diff's format. + * Header: @@ -382,8 +481,9 @@ + * Indicies are printed as 1-based, not 0-based. + * @return {string} The GNU diff string. + */ +diff_match_patch.patch_obj.prototype.toString = function() { + var coords1, coords2; + if (this.length1 === 0) { + coords1 = this.start1 + ',0'; + } else if (this.length1 == 1) { + coords1 = this.start1 + 1; + } else { + coords1 = (this.start1 + 1) + ',' + this.length1; + } + if (this.length2 === 0) { + coords2 = this.start2 + ',0'; + } else if (this.length2 == 1) { + coords2 = this.start2 + 1; + } else { + coords2 = (this.start2 + 1) + ',' + this.length2; + } + var text = ['@@ -' + coords1 + ' +' + coords2 + ' @@\n']; + var op; + // Escape the body of the patch with %xx notation. + for (var x = 0; x < this.diffs.length; x++) { + switch (this.diffs[x][0]) { + case DIFF_INSERT: + op = '+'; + break; + case DIFF_DELETE: + op = '-'; + break; + case DIFF_EQUAL: + op = ' '; + break; + } + text[x + 1] = op + encodeURI(this.diffs[x][1]) + '\n'; + } + return text.join('').replace(/%20/g, ' '); +}; + + +// Export these global variables so that they survive Google's JS compiler. +// In a browser, 'this' will be 'window'. +// Users of node.js should 'require' the uncompressed version since Google's +// JS compiler may break the following exports for non-browser environments. +this['diff_match_patch'] = diff_match_patch; +this['DIFF_DELETE'] = DIFF_DELETE; +this['DIFF_INSERT'] = DIFF_INSERT; +this['DIFF_EQUAL'] = DIFF_EQUAL; diff --git a/packages/test-in-browser/driver.css b/packages/test-in-browser/driver.css index 897ab9dbe7..7b9bf2fb95 100644 --- a/packages/test-in-browser/driver.css +++ b/packages/test-in-browser/driver.css @@ -132,3 +132,18 @@ body { top: 10px; z-index: 2; } + +.string_equal { + line-height: 1.2; + margin-left: 30px; +} +.string_equal ins { + text-decoration: none; +} +.string_equal_expected ins { + background: #fe0; +} +.string_equal_actual ins { + color: #d00; + background: #fcc; +} diff --git a/packages/test-in-browser/driver.js b/packages/test-in-browser/driver.js index 0d200cdfd3..cc891a7643 100644 --- a/packages/test-in-browser/driver.js +++ b/packages/test-in-browser/driver.js @@ -458,46 +458,81 @@ Template.event.events({ } }); -Template.event.get_details = function() { - - var prepare = function(details) { - return _.compact(_.map(details, function(val, key) { - - // You can end up with a an undefined value, e.g. using - // isNull without providing a message attribute: isNull(1). - // No need to display those. - if (!_.isUndefined(val)) { - return { - key: key, - val: val - }; - } else { - return undefined; - } - })); - }; - - var details = this.details; - - if (! details) { - return null; - } else { - - var type = details.type; - var stack = details.stack; - - details = _.clone(details); - delete details.type; - delete details.stack; - - return { - type: type, - stack: stack, - details: prepare(details) - }; - } +// e.g. doDiff('abc', 'bcd') => [[-1, 'a'], [0, 'bc'], [1, 'd']] +var doDiff = function (str1, str2) { + var D = new diff_match_patch(); + var pieces = D.diff_main(str1, str2, false); + D.diff_cleanupSemantic(pieces); + return pieces; }; +Template.event.helpers({ + get_details: function() { + + var details = this.details; + + if (! details) { + return null; + } else { + + var type = details.type; + var stack = details.stack; + + details = _.clone(details); + delete details.type; + delete details.stack; + var prepare = function(details) { + if (type === 'string_equal') { + var diff = doDiff(details.actual, + details.expected); + } + + return _.compact(_.map(details, function(val, key) { + + // make test._stringEqual results print nicely, + // in particular for multiline strings + if (type === 'string_equal' && + (key === 'actual' || key === 'expected')) { + var html = '
';
+          _.each(diff, function (piece) {
+            var which = piece[0];
+            var text = piece[1];
+            if (which === 0 ||
+                which === (key === 'actual' ? -1 : 1)) {
+              var htmlBit = Handlebars._escape(text).replace(
+                /\n/g, '
');
+              if (which !== 0)
+                htmlBit = '' + htmlBit + '';
+              html += htmlBit;
+            }
+          });
+          html += '
'; + val = new Handlebars.SafeString(html); + } + + // You can end up with a an undefined value, e.g. using + // isNull without providing a message attribute: isNull(1). + // No need to display those. + if (!_.isUndefined(val)) { + return { + key: key, + val: val + }; + } else { + return undefined; + } + })); + }; + + return { + type: type, + stack: stack, + details: prepare(details) + }; + } + } +}); + Template.event.is_debuggable = function() { return !!this.cookie; }; diff --git a/packages/test-in-browser/package.js b/packages/test-in-browser/package.js index cfe84ca858..589ac3de4a 100644 --- a/packages/test-in-browser/package.js +++ b/packages/test-in-browser/package.js @@ -16,6 +16,8 @@ Package.on_use(function (api) { api.use(['spark', 'livedata', 'templating', 'deps'], 'client'); + api.add_files('diff_match_patch_uncompressed.js', 'client'); + api.add_files([ 'driver.css', 'driver.html', diff --git a/packages/tinytest/tinytest.js b/packages/tinytest/tinytest.js index de212efb50..74313762bd 100644 --- a/packages/tinytest/tinytest.js +++ b/packages/tinytest/tinytest.js @@ -107,6 +107,13 @@ _.extend(TestCaseResults.prototype, { // XXX eliminate 'message' and 'not' arguments equal: function (actual, expected, message, not) { + + if ((! not) && (typeof actual === 'string') && + (typeof expected === 'string')) { + this._stringEqual(actual, expected, message); + return; + } + /* If expected is a DOM node, do a literal '===' comparison with * actual. Otherwise do a deep comparison, as implemented by _.isEqual. */ @@ -162,7 +169,7 @@ _.extend(TestCaseResults.prototype, { }, // XXX nodejs assert.throws can take an expected error, as a class, - // regular expression, or predicate function. However, with its + // regular expression, or predicate function. However, with its // implementation if a constructor (class) is passed in and `actual` // fails the instanceof test, the constructor is then treated as // a predicate and called with `actual` (!) @@ -269,8 +276,23 @@ _.extend(TestCaseResults.prototype, { else this.fail({type: "length", expected: expected_length, actual: obj.length}); + }, + + // EXPERIMENTAL way to compare two strings that results in + // a nicer display in the test runner, e.g. for multiline + // strings + _stringEqual: function (actual, expected, message) { + if (actual !== expected) { + this.fail({type: "string_equal", + message: message, + expected: expected, + actual: actual}); + } else { + this.ok(); + } } + }); /******************************************************************************/ From 44ffad379484b520147938e2d26e827aa00b1a4b Mon Sep 17 00:00:00 2001 From: Slava Kim Date: Tue, 21 Jan 2014 01:26:50 -0800 Subject: [PATCH 11/34] Replace Clean-Css with a small and unfinished css minifier based on ast manipulations --- .../.npm/package/npm-shrinkwrap.json | 8 - packages/minifiers/minifiers-tests.js | 21 +++ packages/minifiers/minifiers.js | 160 ++++++++++++++++-- packages/minifiers/package.js | 11 +- tools/bundler.js | 8 +- 5 files changed, 183 insertions(+), 25 deletions(-) create mode 100644 packages/minifiers/minifiers-tests.js diff --git a/packages/minifiers/.npm/package/npm-shrinkwrap.json b/packages/minifiers/.npm/package/npm-shrinkwrap.json index c315f0ff93..0b7c29a8b4 100644 --- a/packages/minifiers/.npm/package/npm-shrinkwrap.json +++ b/packages/minifiers/.npm/package/npm-shrinkwrap.json @@ -1,13 +1,5 @@ { "dependencies": { - "clean-css": { - "version": "2.0.6", - "dependencies": { - "commander": { - "version": "2.0.0" - } - } - }, "uglify-js": { "version": "2.4.7", "dependencies": { diff --git a/packages/minifiers/minifiers-tests.js b/packages/minifiers/minifiers-tests.js new file mode 100644 index 0000000000..e42f753635 --- /dev/null +++ b/packages/minifiers/minifiers-tests.js @@ -0,0 +1,21 @@ +Tinytest.add("minifiers - simple css minification", function (test) { + var t = function (css, expected, desc) { + test.equal(CssTools.minifyCss(css), expected, desc); + } + + t('a \t\n{ color: red } \n', 'a{color:red}', 'whitespace check'); + t('a \t\n{ color: red; margin: 1; } \n', 'a{color:red;margin:1}', 'only last one looses semicolon'); + t('a \t\n{ color: red;;; margin: 1;;; } \n', 'a{color:red;margin:1}', 'more semicolons than needed'); + t('a , p \t\n{ color: red; } \n', 'a,p{color:red}', 'multiple selectors'); + t('body {}', '', 'removing empty rules'); + t('*.my-class { color: #fff; }', '.my-class{color:#fff}', 'removing universal selector'); + t('p > *.my-class { color: #fff; }', 'p>.my-class{color:#fff}', 'removing optional whitespace around ">" in selector'); + t('p + *.my-class { color: #fff; }', 'p+.my-class{color:#fff}', 'removing optional whitespace around "+" in selector'); + // XXX url parsing is difficult to support at the moment + t('a {\n\ + font:12px \'Helvetica\',"Arial",\'Nautica\';\n\ + background:url("/some/nice/picture.png");\n}', + 'a{font:12px Helvetica,Arial,Nautica;background:url("/some/nice/picture.png")}', 'removing quotes in font and url (if possible)'); + t('/* no comments */ a { color: red; }', 'a{color:red}', 'remove comments'); +}); + diff --git a/packages/minifiers/minifiers.js b/packages/minifiers/minifiers.js index f09748fd71..b8807a1a97 100644 --- a/packages/minifiers/minifiers.js +++ b/packages/minifiers/minifiers.js @@ -1,12 +1,152 @@ -var CleanCss = Npm.require('clean-css'); - -CleanCSSProcess = function (source, options) { - var instance = new CleanCss(options); - return instance.minify(source); -}; - -CssParse = Npm.require('css-parse'); -CssStringify = Npm.require('css-stringify'); - UglifyJSMinify = Npm.require('uglify-js').minify; +var cssParse = Npm.require('css-parse'); +var cssStringify = Npm.require('css-stringify'); + +CssTools = { + parseCss: cssParse, + stringifyCss: cssStringify, + minifyCss: function (cssText) { + return CssTools.minifyCssAst(cssParse(cssText)); + }, + minifyCssAst: function (cssAst) { + return compile(cssAst); + } +}; + +// Stringifier based on css-stringify +var emit = function (str) { + return str.toString(); +}; + +var visit = function (node, last) { + return traverse[node.type](node, last); +}; + +var mapVisit = function (nodes) { + var buf = ""; + + for (var i = 0, length = nodes.length; i < length; i++) { + buf += visit(nodes[i], i === length - 1); + } + + return buf; +}; + +var compile = function(node){ + return node.stylesheet + .rules.map(function (rule) { return visit(rule); }) + .join(''); +}; + +var traverse = {}; + +traverse.comment = function(node) { + return emit('', node.position); +}; + +traverse.import = function(node) { + return emit('@import ' + node.import + ';', node.position); +}; + +traverse.media = function(node) { + return emit('@media ' + node.media, node.position, true) + + emit('{') + + mapVisit(node.rules) + + emit('}'); +}; + +traverse.document = function(node) { + var doc = '@' + (node.vendor || '') + 'document ' + node.document; + + return emit(doc, node.position, true) + + emit('{') + + mapVisit(node.rules) + + emit('}'); +}; + +traverse.charset = function(node) { + return emit('@charset ' + node.charset + ';', node.position); +}; + +traverse.namespace = function(node) { + return emit('@namespace ' + node.namespace + ';', node.position); +}; + +traverse.supports = function(node){ + return emit('@supports ' + node.supports, node.position, true) + + emit('{') + + mapVisit(node.rules) + + emit('}'); +}; + +traverse.keyframes = function(node) { + return emit('@' + + (node.vendor || '') + + 'keyframes ' + + node.name, node.position, true) + + emit('{') + + mapVisit(node.keyframes) + + emit('}'); +}; + +traverse.keyframe = function(node) { + var decls = node.declarations; + + return emit(node.values.join(','), node.position, true) + + emit('{') + + mapVisit(decls) + + emit('}'); +}; + +traverse.page = function(node) { + var sel = node.selectors.length + ? node.selectors.join(', ') + : ''; + + return emit('@page ' + sel, node.position, true) + + emit('{') + + mapVisit(node.declarations) + + emit('}'); +}; + +traverse.rule = function(node) { + var decls = node.declarations; + if (!decls.length) return ''; + + var selectors = node.selectors.map(function (selector) { + // removes universal selectors like *.class => .class + // removes optional whitespace around '>' and '+' + return selector.replace(/\*\./, '.') + .replace(/\s*>\s*/g, '>') + .replace(/\s*\+\s*/g, '+'); + }); + return emit(selectors.join(','), node.position, true) + + emit('{') + + mapVisit(decls) + + emit('}'); +}; + +traverse.declaration = function(node, last) { + var value = node.value; + + // remove optional quotes around font name + if (node.property === 'font') { + value = value.replace(/\'[^\']+\'/g, function (m) { + if (m.indexOf(' ') !== -1) + return m; + return m.replace(/\'/g, ''); + }); + value = value.replace(/\"[^\"]+\"/g, function (m) { + if (m.indexOf(' ') !== -1) + return m; + return m.replace(/\"/g, ''); + }); + } + // remove url quotes if possible + // in case it is the last declaration, we can omit the semicolon + return emit(node.property + ':' + value, node.position) + + (last ? '' : emit(';')); +}; + + diff --git a/packages/minifiers/package.js b/packages/minifiers/package.js index 6ff951a8a7..23e57cad0e 100644 --- a/packages/minifiers/package.js +++ b/packages/minifiers/package.js @@ -4,14 +4,19 @@ Package.describe({ }); Npm.depends({ - "clean-css": "2.0.6", "uglify-js": "2.4.7", "css-parse": "1.7.0", "css-stringify": "1.4.1" }); Package.on_use(function (api) { - api.export(['CleanCSSProcess', 'UglifyJSMinify']); - api.export(['CssParse', 'CssStringify']); + api.export(['CssTools', 'UglifyJSMinify']); api.add_files('minifiers.js', 'server'); }); + +Package.on_test(function (api) { + api.use('minifiers', 'server'); + api.use('tinytest'); + api.add_files('minifiers-tests.js', 'server'); +}); + diff --git a/tools/bundler.js b/tools/bundler.js index ca0490f528..4b9c2cbb6c 100644 --- a/tools/bundler.js +++ b/tools/bundler.js @@ -770,7 +770,7 @@ _.extend(ClientTarget.prototype, { var cssAsts = _.map(self.css, function (file) { try { - var ast = minifiers.CssParse(file.contents('utf8')); + var ast = minifiers.CssTools.parseCss(file.contents('utf8')); } catch (e) { var fileName = file.url.replace(/^\//, ''); buildmessage.error(e.message, { file: fileName }); @@ -818,10 +818,10 @@ _.extend(ClientTarget.prototype, { return ast; }); - var allCss = - _.map([importsAst].concat(cssAsts), minifiers.CssStringify).join('\n'); + var allCss = _.map([importsAst].concat(cssAsts), + minifiers.CssTools.stringifyCss).join('\n'); - var minifiedCss = minifiers.CleanCSSProcess(allCss); + var minifiedCss = minifiers.CssTools.minifyCss(allCss); self.css = [new File({ data: new Buffer(minifiedCss, 'utf8') })]; self.css[0].setUrlToHash(".css"); From b93fe02ef59c2fb891a1b910ac02a0facd30147d Mon Sep 17 00:00:00 2001 From: Slava Kim Date: Sun, 26 Jan 2014 16:28:22 -0800 Subject: [PATCH 12/34] Introduce the CSS Preprocessing step To run meta-programming on CSS, concatenate files, etc. Opens doors for future CSS manipulations. --- tools/bundler.js | 69 +++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 56 insertions(+), 13 deletions(-) diff --git a/tools/bundler.js b/tools/bundler.js index 4b9c2cbb6c..50b9900698 100644 --- a/tools/bundler.js +++ b/tools/bundler.js @@ -449,6 +449,9 @@ _.extend(Target.prototype, { // Link JavaScript and set up self.js, etc. self._emitResources(); + // Run the preprocessing and concatenation of CSS files. + self.preprocessCss(); + // Minify, if requested if (options.minify) { var minifiers = unipackage.load({ @@ -456,8 +459,7 @@ _.extend(Target.prototype, { packages: ['minifiers'] }).minifiers; self.minifyJs(minifiers); - if (self.minifyCss) // XXX a bit of a hack - self.minifyCss(minifiers); + self.minifyCss(minifiers); } if (options.addCacheBusters) { @@ -685,6 +687,16 @@ _.extend(Target.prototype, { }); }, + // Preprocess CSS in this target + preprocessCss: function () { + // Don't do anything by default + }, + + // Minify the CSS in this target + minifyCss: function (minifiers) { + // Don't do anything by default + }, + // Minify the JS in this target minifyJs: function (minifiers) { var self = this; @@ -741,9 +753,11 @@ var ClientTarget = function (options) { var self = this; Target.apply(this, arguments); - // CSS files. List of File. They will be loaded at page load in the - // order given. + // CSS files. List of File. They will be preprocessed, concatenated into + // single file and loaded at page load. self.css = []; + // Intermediate representation of preprocessed CSS tree. + self._cssAst = null; // List of segments of additional HTML for /. self.head = []; @@ -756,14 +770,18 @@ var ClientTarget = function (options) { inherits(ClientTarget, Target); _.extend(ClientTarget.prototype, { - // Minify the CSS in this target - minifyCss: function (minifiers) { + // Preprocess the CSS in the target + preprocessCss: function () { var self = this; + var minifiers = unipackage.load({ + library: self.library, + packages: ['minifiers'] + }).minifiers; // The straight-forward concatenation of CSS files would break @import rules - // located in the beginning of a file. Before concatenation, pull them to a - // separate syntax tree that will always precede other rules. - var importsAst = { + // located in the beginning of a file. Before concatenation, pull them to + // the beginning of a new syntax tree so they always precede other rules. + var newAst = { type: 'stylesheet', stylesheet: { rules: [] } }; @@ -805,7 +823,7 @@ _.extend(ClientTarget.prototype, { } var imports = ast.stylesheet.rules.splice(0, importCount); - importsAst.stylesheet.rules = importsAst.stylesheet.rules.concat(imports); + newAst.stylesheet.rules = newAst.stylesheet.rules.concat(imports); // if there are imports left in the middle of file, warn user as it might // be a potential bug (imports are valid only in the beginning of file). @@ -818,10 +836,35 @@ _.extend(ClientTarget.prototype, { return ast; }); - var allCss = _.map([importsAst].concat(cssAsts), - minifiers.CssTools.stringifyCss).join('\n'); + // Now we can put the rest of CSS rules into new AST + _.each(cssAsts, function (ast) { + newAst.stylesheet.rules = newAst.stylesheet.rules.concat(ast.stylesheet.rules); + }); - var minifiedCss = minifiers.CssTools.minifyCss(allCss); + // Other build phases might need this AST later + self._cssAst = newAst; + + // Overwrite the CSS files list to the new concatenated file + var stringifiedCss = minifiers.CssTools.stringifyCss(newAst); + self.css = [new File({ data: new Buffer(stringifiedCss, 'utf8') })]; + self.css[0].setUrlToHash(".css"); + }, + // Minify the CSS in this target + minifyCss: function (minifiers) { + var self = this; + var minifiedCss = ''; + + // If there is an AST already calculated, don't waste time on parsing it + // again. + if (self._cssAst) { + minifiedCss = minifiers.CssTools.minifyCssAst(self._cssAst); + } else if (self.css) { + var allCss = _.map(self.css, function (file) { + return file.contents('utf8'); + }).join('\n'); + + minifiedCss = minifiers.CssTools.minifyCss(allCss); + } self.css = [new File({ data: new Buffer(minifiedCss, 'utf8') })]; self.css[0].setUrlToHash(".css"); From 11cc8bbff7e2f9f1e1d34579abd32bba8f5dbe90 Mon Sep 17 00:00:00 2001 From: Slava Kim Date: Sun, 26 Jan 2014 16:29:14 -0800 Subject: [PATCH 13/34] Minor clean-up unused linker reference, whitespace --- tools/bundler.js | 1 - 1 file changed, 1 deletion(-) diff --git a/tools/bundler.js b/tools/bundler.js index 50b9900698..0c96497fbf 100644 --- a/tools/bundler.js +++ b/tools/bundler.js @@ -162,7 +162,6 @@ var path = require('path'); var util = require('util'); var files = require(path.join(__dirname, 'files.js')); var packages = require(path.join(__dirname, 'packages.js')); -var linker = require(path.join(__dirname, 'linker.js')); var Builder = require(path.join(__dirname, 'builder.js')); var archinfo = require(path.join(__dirname, 'archinfo.js')); var buildmessage = require('./buildmessage.js'); From 1d576de990c3c06232ec2be1b4f9812bb4cc44c2 Mon Sep 17 00:00:00 2001 From: Slava Kim Date: Sun, 26 Jan 2014 19:28:49 -0800 Subject: [PATCH 14/34] Base for CSS sourcemaps --- tools/bundler.js | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/tools/bundler.js b/tools/bundler.js index 0c96497fbf..d65a1a3b07 100644 --- a/tools/bundler.js +++ b/tools/bundler.js @@ -776,6 +776,7 @@ _.extend(ClientTarget.prototype, { library: self.library, packages: ['minifiers'] }).minifiers; + var CssTools = minifiers.CssTools; // The straight-forward concatenation of CSS files would break @import rules // located in the beginning of a file. Before concatenation, pull them to @@ -786,10 +787,11 @@ _.extend(ClientTarget.prototype, { }; var cssAsts = _.map(self.css, function (file) { + var fileName = file.url.replace(/^\//, ''); try { - var ast = minifiers.CssTools.parseCss(file.contents('utf8')); + var parseOptions = { source: fileName, position: true }; + var ast = CssTools.parseCss(file.contents('utf8'), parseOptions); } catch (e) { - var fileName = file.url.replace(/^\//, ''); buildmessage.error(e.message, { file: fileName }); return { type: "stylesheet", stylesheet: { rules: [] } }; } @@ -844,7 +846,7 @@ _.extend(ClientTarget.prototype, { self._cssAst = newAst; // Overwrite the CSS files list to the new concatenated file - var stringifiedCss = minifiers.CssTools.stringifyCss(newAst); + var stringifiedCss = CssTools.stringifyCss(newAst, {sourcemap: true}).code; self.css = [new File({ data: new Buffer(stringifiedCss, 'utf8') })]; self.css[0].setUrlToHash(".css"); }, From 6071b611d1e6c491db5bd70ad447ca06ef681efa Mon Sep 17 00:00:00 2001 From: Slava Kim Date: Sun, 26 Jan 2014 20:24:56 -0800 Subject: [PATCH 15/34] Sourcemaps for CSS!!11 --- tools/bundler.js | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/tools/bundler.js b/tools/bundler.js index d65a1a3b07..f2f5ba3795 100644 --- a/tools/bundler.js +++ b/tools/bundler.js @@ -786,8 +786,12 @@ _.extend(ClientTarget.prototype, { stylesheet: { rules: [] } }; + // Filenames passed to AST manipulator mapped to their original files + var originals = {}; + var cssAsts = _.map(self.css, function (file) { var fileName = file.url.replace(/^\//, ''); + originals[fileName] = file; try { var parseOptions = { source: fileName, position: true }; var ast = CssTools.parseCss(file.contents('utf8'), parseOptions); @@ -846,8 +850,15 @@ _.extend(ClientTarget.prototype, { self._cssAst = newAst; // Overwrite the CSS files list to the new concatenated file - var stringifiedCss = CssTools.stringifyCss(newAst, {sourcemap: true}).code; - self.css = [new File({ data: new Buffer(stringifiedCss, 'utf8') })]; + var stringifiedCss = CssTools.stringifyCss(newAst, {sourcemap: true}); + self.css = [new File({ data: new Buffer(stringifiedCss.code, 'utf8')})]; + + // Set the contents of sourcemapped files + stringifiedCss.map.sourcesContent = + _.map(stringifiedCss.map.sources, function (filename) { + return originals[filename].contents('utf8'); + }); + self.css[0].setSourceMap(JSON.stringify(stringifiedCss.map)); self.css[0].setUrlToHash(".css"); }, // Minify the CSS in this target From 98f49d71d01a28c7c222edf217985e6491dc8b80 Mon Sep 17 00:00:00 2001 From: Slava Kim Date: Sun, 26 Jan 2014 20:25:12 -0800 Subject: [PATCH 16/34] fileName -> filename for consistency --- tools/bundler.js | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/tools/bundler.js b/tools/bundler.js index f2f5ba3795..1676db837d 100644 --- a/tools/bundler.js +++ b/tools/bundler.js @@ -790,13 +790,13 @@ _.extend(ClientTarget.prototype, { var originals = {}; var cssAsts = _.map(self.css, function (file) { - var fileName = file.url.replace(/^\//, ''); - originals[fileName] = file; + var filename = file.url.replace(/^\//, ''); + originals[filename] = file; try { - var parseOptions = { source: fileName, position: true }; + var parseOptions = { source: filename, position: true }; var ast = CssTools.parseCss(file.contents('utf8'), parseOptions); } catch (e) { - buildmessage.error(e.message, { file: fileName }); + buildmessage.error(e.message, { file: filename }); return { type: "stylesheet", stylesheet: { rules: [] } }; } @@ -813,9 +813,9 @@ _.extend(ClientTarget.prototype, { // Pick only the imports from the beginning of file ignoring @charset // rules as Meteor assumes every file is in utf-8. if (_.any(ast.stylesheet.rules, rulePredicate("charset"))) { - var fileName = file.url.replace(/^\//, ''); + var filename = file.url.replace(/^\//, ''); // XXX make this a buildmessage.warning call rather than a random log - console.log("%s: warn: @charset rules in this file will be ignored as Meteor supports only utf-8 at the moment.", fileName); + console.log("%s: warn: @charset rules in this file will be ignored as Meteor supports only utf-8 at the moment.", filename); } ast.stylesheet.rules = _.reject(ast.stylesheet.rules, @@ -833,9 +833,9 @@ _.extend(ClientTarget.prototype, { // if there are imports left in the middle of file, warn user as it might // be a potential bug (imports are valid only in the beginning of file). if (_.any(ast.stylesheet.rules, rulePredicate("import"))) { - var fileName = file.url.replace(/^\//, ''); + var filename = file.url.replace(/^\//, ''); // XXX make this a buildmessage.warning call rather than a random log - console.log("%s: warn: there are some @import rules those are not taking effect as they are required to be in the beginning of the file.", fileName); + console.log("%s: warn: there are some @import rules those are not taking effect as they are required to be in the beginning of the file.", filename); } return ast; From 7317188fed05a8543b58373f647e936f0d03aa73 Mon Sep 17 00:00:00 2001 From: Slava Kim Date: Mon, 27 Jan 2014 00:36:53 -0800 Subject: [PATCH 17/34] Update Less to 1.6.1 XXX review the changelog --- .../plugin/compileLess/npm-shrinkwrap.json | 106 +++++++++++++++++- packages/less/package.js | 2 +- 2 files changed, 104 insertions(+), 4 deletions(-) diff --git a/packages/less/.npm/plugin/compileLess/npm-shrinkwrap.json b/packages/less/.npm/plugin/compileLess/npm-shrinkwrap.json index 257eeb9951..f2a90d9a9f 100644 --- a/packages/less/.npm/plugin/compileLess/npm-shrinkwrap.json +++ b/packages/less/.npm/plugin/compileLess/npm-shrinkwrap.json @@ -1,10 +1,110 @@ { "dependencies": { "less": { - "version": "1.3.3", + "version": "1.6.1", "dependencies": { - "ycssmin": { - "version": "1.0.1" + "mime": { + "version": "1.2.11" + }, + "request": { + "version": "2.33.0", + "dependencies": { + "qs": { + "version": "0.6.6" + }, + "json-stringify-safe": { + "version": "5.0.0" + }, + "forever-agent": { + "version": "0.5.0" + }, + "node-uuid": { + "version": "1.4.1" + }, + "tough-cookie": { + "version": "0.12.1", + "dependencies": { + "punycode": { + "version": "1.2.3" + } + } + }, + "form-data": { + "version": "0.1.2", + "dependencies": { + "combined-stream": { + "version": "0.0.4", + "dependencies": { + "delayed-stream": { + "version": "0.0.5" + } + } + }, + "async": { + "version": "0.2.10" + } + } + }, + "tunnel-agent": { + "version": "0.3.0" + }, + "http-signature": { + "version": "0.10.0", + "dependencies": { + "assert-plus": { + "version": "0.1.2" + }, + "asn1": { + "version": "0.1.11" + }, + "ctype": { + "version": "0.5.2" + } + } + }, + "oauth-sign": { + "version": "0.3.0" + }, + "hawk": { + "version": "1.0.0", + "dependencies": { + "hoek": { + "version": "0.9.1" + }, + "boom": { + "version": "0.4.2" + }, + "cryptiles": { + "version": "0.2.2" + }, + "sntp": { + "version": "0.2.4" + } + } + }, + "aws-sign2": { + "version": "0.5.0" + } + } + }, + "mkdirp": { + "version": "0.3.5" + }, + "clean-css": { + "version": "2.0.7", + "dependencies": { + "commander": { + "version": "2.0.0" + } + } + }, + "source-map": { + "version": "0.1.31", + "dependencies": { + "amdefine": { + "version": "0.1.0" + } + } } } } diff --git a/packages/less/package.js b/packages/less/package.js index afe116d38b..830012e1e4 100644 --- a/packages/less/package.js +++ b/packages/less/package.js @@ -8,7 +8,7 @@ Package._transitional_registerBuildPlugin({ sources: [ 'plugin/compile-less.js' ], - npmDependencies: {"less": "1.3.3"} + npmDependencies: {"less": "1.6.1"} }); Package.on_test(function (api) { From 2f78babda1f04a59b330003c30b79d8b542e14d8 Mon Sep 17 00:00:00 2001 From: Slava Kim Date: Mon, 27 Jan 2014 00:37:10 -0800 Subject: [PATCH 18/34] Enable less sourcemaps --- packages/less/plugin/compile-less.js | 23 +++++++++++++++++++---- tools/bundler.js | 3 ++- tools/packages.js | 8 ++++++-- 3 files changed, 27 insertions(+), 7 deletions(-) diff --git a/packages/less/plugin/compile-less.js b/packages/less/plugin/compile-less.js index 41980738a8..875a2a5e7c 100644 --- a/packages/less/plugin/compile-less.js +++ b/packages/less/plugin/compile-less.js @@ -23,11 +23,12 @@ Plugin.registerSourceHandler("less", function (compileStep) { paths: [path.dirname(compileStep._fullInputPath)] // for @import }; + var parser = new(less.Parser)(options); var f = new Future; - var css; + var ast, css; try { - less.render(source, options, f.resolver()); - css = f.wait(); + parser.parse(source, f.resolver()); + ast = f.wait(); } catch (e) { // less.render() is supposed to report any errors via its // callback. But sometimes, it throws them instead. This is @@ -41,9 +42,23 @@ Plugin.registerSourceHandler("less", function (compileStep) { return; } + f2 = new Future; + css = ast.toCSS({ + sourceMap: Boolean(true), + writeSourceMap: function (sourceMap) { + f2.return(sourceMap); + } + }); + + sourceMap = JSON.parse(f2.wait()); + + sourceMap.sources = [compileStep.inputPath]; + sourceMap.sourcesContent = [source]; + compileStep.addStylesheet({ path: compileStep.inputPath + ".css", - data: css + data: css, + sourceMap: JSON.stringify(sourceMap) }); });; diff --git a/tools/bundler.js b/tools/bundler.js index 1676db837d..9a50b46134 100644 --- a/tools/bundler.js +++ b/tools/bundler.js @@ -658,7 +658,8 @@ _.extend(Target.prototype, { } } - if (resource.type === "js" && resource.sourceMap) { + // Both CSS and JS files can have sourcemaps + if (resource.sourceMap) { f.setSourceMap(resource.sourceMap, path.dirname(relPath)); } diff --git a/tools/packages.js b/tools/packages.js index e6d9ce239d..808ac86141 100644 --- a/tools/packages.js +++ b/tools/packages.js @@ -291,7 +291,8 @@ _.extend(Slice.prototype, { // - appendDocument({ section: "head", data: "my markup" }) // Browser targets only. Add markup to the "head" or "body" // section of the document. - // - addStylesheet({ path: "my/stylesheet.css", data: "my css" }) + // - addStylesheet({ path: "my/stylesheet.css", + // data: "my css", sourceMap: "{version:3, ...}"}) // Browser targets only. Add a stylesheet to the // document. 'path' is a requested URL for the stylesheet that // may or may not ultimately be honored. (Meteor will add @@ -405,10 +406,13 @@ _.extend(Slice.prototype, { "browser targets"); if (typeof options.data !== "string") throw new Error("'data' option to addStylesheet must be a string"); + if (typeof options.sourceMap !== "string" && options.sourceMap !== undefined) + throw new Error("'sourceMap' option to addStylesheet must be a string"); resources.push({ type: "css", data: new Buffer(options.data, 'utf8'), - servePath: path.join(self.pkg.serveRoot, options.path) + servePath: path.join(self.pkg.serveRoot, options.path), + sourceMap: options.sourceMap }); }, addJavaScript: function (options) { From ca71fc1920e12a62c0b19c7a099069f41caa2cc8 Mon Sep 17 00:00:00 2001 From: Slava Kim Date: Mon, 27 Jan 2014 14:09:40 -0800 Subject: [PATCH 19/34] Sourcemap chains for CSS Now we support Less->CSS->CSS sourcemaps. --- tools/bundler.js | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/tools/bundler.js b/tools/bundler.js index 9a50b46134..9075a781d3 100644 --- a/tools/bundler.js +++ b/tools/bundler.js @@ -859,7 +859,16 @@ _.extend(ClientTarget.prototype, { _.map(stringifiedCss.map.sources, function (filename) { return originals[filename].contents('utf8'); }); - self.css[0].setSourceMap(JSON.stringify(stringifiedCss.map)); + + // Apply all previous sourcemaps if those existed + // Ex.: less -> css sourcemap sould be applied to css -> css sourcemap + var newMap = sourcemap.SourceMapGenerator.fromSourceMap(new sourcemap.SourceMapConsumer(stringifiedCss.map)); + _.each(originals, function (file, name) { + if (file.sourceMap) + newMap.applySourceMap(new sourcemap.SourceMapConsumer(file.sourceMap), name); + }); + + self.css[0].setSourceMap(JSON.stringify(newMap)); self.css[0].setUrlToHash(".css"); }, // Minify the CSS in this target From ace1f018496af30eb9416c30f00edb39d145c8a3 Mon Sep 17 00:00:00 2001 From: Slava Kim Date: Mon, 27 Jan 2014 14:13:01 -0800 Subject: [PATCH 20/34] style: Reduce code width to normal 80 chars --- tools/bundler.js | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/tools/bundler.js b/tools/bundler.js index 9075a781d3..0bdcbe028b 100644 --- a/tools/bundler.js +++ b/tools/bundler.js @@ -844,7 +844,8 @@ _.extend(ClientTarget.prototype, { // Now we can put the rest of CSS rules into new AST _.each(cssAsts, function (ast) { - newAst.stylesheet.rules = newAst.stylesheet.rules.concat(ast.stylesheet.rules); + newAst.stylesheet.rules = + newAst.stylesheet.rules.concat(ast.stylesheet.rules); }); // Other build phases might need this AST later @@ -862,10 +863,14 @@ _.extend(ClientTarget.prototype, { // Apply all previous sourcemaps if those existed // Ex.: less -> css sourcemap sould be applied to css -> css sourcemap - var newMap = sourcemap.SourceMapGenerator.fromSourceMap(new sourcemap.SourceMapConsumer(stringifiedCss.map)); + var newMap = sourcemap.SourceMapGenerator.fromSourceMap( + new sourcemap.SourceMapConsumer(stringifiedCss.map)); + _.each(originals, function (file, name) { - if (file.sourceMap) - newMap.applySourceMap(new sourcemap.SourceMapConsumer(file.sourceMap), name); + if (! file.sourceMap) + return; + newMap.applySourceMap( + new sourcemap.SourceMapConsumer(file.sourceMap), name); }); self.css[0].setSourceMap(JSON.stringify(newMap)); From 57e670440a62258bf726bf751f101ed9d3d1ea30 Mon Sep 17 00:00:00 2001 From: Maxime Quandalle Date: Fri, 27 Sep 2013 10:27:53 +0200 Subject: [PATCH 21/34] less package ignores `.import.less` files, so you can import them and still haves syntax highlighting in your text editor. --- packages/less/less_tests.import.less | 2 ++ packages/less/less_tests.js | 1 + packages/less/less_tests.less | 2 ++ packages/less/plugin/compile-less.js | 5 ++++- 4 files changed, 9 insertions(+), 1 deletion(-) create mode 100644 packages/less/less_tests.import.less diff --git a/packages/less/less_tests.import.less b/packages/less/less_tests.import.less new file mode 100644 index 0000000000..b18defc965 --- /dev/null +++ b/packages/less/less_tests.import.less @@ -0,0 +1,2 @@ +// This should be @import'able into other .less files +@important-border: double; \ No newline at end of file diff --git a/packages/less/less_tests.js b/packages/less/less_tests.js index 262439491c..f64a5b7304 100644 --- a/packages/less/less_tests.js +++ b/packages/less/less_tests.js @@ -10,6 +10,7 @@ Tinytest.add("less - presence", function(test) { // test @import test.equal(getStyleProperty(p, 'border-right-style'), "dotted"); + test.equal(getStyleProperty(p, 'border-bottom-style'), "double"); d.kill(); }); diff --git a/packages/less/less_tests.less b/packages/less/less_tests.less index 56e810f570..f97edef951 100644 --- a/packages/less/less_tests.less +++ b/packages/less/less_tests.less @@ -1,4 +1,5 @@ @import "less_tests_constants.lessimport"; +@import "less_tests.import.less"; #less-tests { zoom: 1; /* prop this rule open */ } @@ -7,4 +8,5 @@ .less-dashy-left-border { border-left: @dashy; border-right: @external-dotty; + border-bottom: @important-border; } diff --git a/packages/less/plugin/compile-less.js b/packages/less/plugin/compile-less.js index 875a2a5e7c..0d1184673f 100644 --- a/packages/less/plugin/compile-less.js +++ b/packages/less/plugin/compile-less.js @@ -64,6 +64,9 @@ Plugin.registerSourceHandler("less", function (compileStep) { // Register lessimport files with the dependency watcher, without actually // processing them. -Plugin.registerSourceHandler("lessimport", function () { +Plugin.registerSourceHandler("import.less", function () { // Do nothing }); + +// Backward compatibility +Plugin.registerSourceHandler("lessimport", function () {}); From a63a3b0057ee6a09dd92bcde371823bfae8a5a14 Mon Sep 17 00:00:00 2001 From: Maxime Quandalle Date: Thu, 10 Oct 2013 18:44:26 +0200 Subject: [PATCH 22/34] Update documentation: lessimport -> import.less --- docs/client/packages/less.html | 2 +- packages/less/less_tests.import.less | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/client/packages/less.html b/docs/client/packages/less.html index da5145b03d..a4da2ec02f 100644 --- a/docs/client/packages/less.html +++ b/docs/client/packages/less.html @@ -11,7 +11,7 @@ automatically compiled to CSS and the results are included in the client CSS bundle. {{#note}} -If you want to `@import` a file, give it the extension `.lessimport` +If you want to `@import` a file, give it the extension `.import.less` to prevent Meteor from processing it independently. {{/note}} diff --git a/packages/less/less_tests.import.less b/packages/less/less_tests.import.less index b18defc965..f2cbfa1f4c 100644 --- a/packages/less/less_tests.import.less +++ b/packages/less/less_tests.import.less @@ -1,2 +1,2 @@ // This should be @import'able into other .less files -@important-border: double; \ No newline at end of file +@important-border: double; From 69a208fe1e0b5163bb1b7e619b6e054c447672f2 Mon Sep 17 00:00:00 2001 From: Slava Kim Date: Mon, 27 Jan 2014 15:16:47 -0800 Subject: [PATCH 23/34] Add forgotten file to tests section in package.js for less tests --- packages/less/package.js | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/packages/less/package.js b/packages/less/package.js index 830012e1e4..4e242a699a 100644 --- a/packages/less/package.js +++ b/packages/less/package.js @@ -14,5 +14,6 @@ Package._transitional_registerBuildPlugin({ Package.on_test(function (api) { api.use(['test-helpers', 'tinytest', 'less']); api.use(['spark']); - api.add_files(['less_tests.less', 'less_tests.js'], 'client'); + api.add_files(['less_tests.less', 'less_tests.js', 'less_tests.import.less'], + 'client'); }); From 0d7ef87732a625de473d88eee13842ec02e249ab Mon Sep 17 00:00:00 2001 From: Slava Kim Date: Mon, 27 Jan 2014 15:37:24 -0800 Subject: [PATCH 24/34] Updated History.md with XXX items --- History.md | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/History.md b/History.md index ef07249e1f..13e81e1765 100644 --- a/History.md +++ b/History.md @@ -1,5 +1,11 @@ ## v.NEXT +* XXX upgraded `less` from 1.3.3 to 1.6.1 +* XXX sourcemaps support for stylesheets, including less sourcemaps +* XXX css linting (breaks on errors) +* XXX css preprocessing to concatenate files correctly (pulls @imports to the + beginning) + * Hash login tokens before storing them in the database. * Cursors with a field specifier containing `{_id: 0}` can no longer be used From efb700f4f951036f69f550a8aebd6428dca68d2d Mon Sep 17 00:00:00 2001 From: Slava Kim Date: Mon, 3 Feb 2014 13:51:04 -0800 Subject: [PATCH 25/34] Rename futures for less package --- packages/less/plugin/compile-less.js | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/packages/less/plugin/compile-less.js b/packages/less/plugin/compile-less.js index 0d1184673f..efae3df8b9 100644 --- a/packages/less/plugin/compile-less.js +++ b/packages/less/plugin/compile-less.js @@ -24,11 +24,11 @@ Plugin.registerSourceHandler("less", function (compileStep) { }; var parser = new(less.Parser)(options); - var f = new Future; + var astFuture = new Future; var ast, css; try { - parser.parse(source, f.resolver()); - ast = f.wait(); + parser.parse(source, astFuture.resolver()); + ast = astFuture.wait(); } catch (e) { // less.render() is supposed to report any errors via its // callback. But sometimes, it throws them instead. This is @@ -42,15 +42,15 @@ Plugin.registerSourceHandler("less", function (compileStep) { return; } - f2 = new Future; + var cssFuture = new Future; css = ast.toCSS({ sourceMap: Boolean(true), writeSourceMap: function (sourceMap) { - f2.return(sourceMap); + cssFuture.return(sourceMap); } }); - sourceMap = JSON.parse(f2.wait()); + sourceMap = JSON.parse(cssFuture.wait()); sourceMap.sources = [compileStep.inputPath]; sourceMap.sourcesContent = [source]; From 830300cb2ecbe07b48433f04e3f2f7b16d7d4031 Mon Sep 17 00:00:00 2001 From: Slava Kim Date: Mon, 3 Feb 2014 14:48:05 -0800 Subject: [PATCH 26/34] Move css-asts concatenation to the minifiers package --- packages/minifiers/minification.js | 137 +++++++++++++++++++++++ packages/minifiers/minifiers.js | 174 ++++++++--------------------- packages/minifiers/package.js | 3 +- tools/bundler.js | 65 ++--------- 4 files changed, 195 insertions(+), 184 deletions(-) create mode 100644 packages/minifiers/minification.js diff --git a/packages/minifiers/minification.js b/packages/minifiers/minification.js new file mode 100644 index 0000000000..567b8af8c9 --- /dev/null +++ b/packages/minifiers/minification.js @@ -0,0 +1,137 @@ + +// Stringifier based on css-stringify +var emit = function (str) { + return str.toString(); +}; + +var visit = function (node, last) { + return traverse[node.type](node, last); +}; + +var mapVisit = function (nodes) { + var buf = ""; + + for (var i = 0, length = nodes.length; i < length; i++) { + buf += visit(nodes[i], i === length - 1); + } + + return buf; +}; + +MinifyAst = function(node) { + return node.stylesheet + .rules.map(function (rule) { return visit(rule); }) + .join(''); +}; + +var traverse = {}; + +traverse.comment = function(node) { + return emit('', node.position); +}; + +traverse.import = function(node) { + return emit('@import ' + node.import + ';', node.position); +}; + +traverse.media = function(node) { + return emit('@media ' + node.media, node.position, true) + + emit('{') + + mapVisit(node.rules) + + emit('}'); +}; + +traverse.document = function(node) { + var doc = '@' + (node.vendor || '') + 'document ' + node.document; + + return emit(doc, node.position, true) + + emit('{') + + mapVisit(node.rules) + + emit('}'); +}; + +traverse.charset = function(node) { + return emit('@charset ' + node.charset + ';', node.position); +}; + +traverse.namespace = function(node) { + return emit('@namespace ' + node.namespace + ';', node.position); +}; + +traverse.supports = function(node){ + return emit('@supports ' + node.supports, node.position, true) + + emit('{') + + mapVisit(node.rules) + + emit('}'); +}; + +traverse.keyframes = function(node) { + return emit('@' + + (node.vendor || '') + + 'keyframes ' + + node.name, node.position, true) + + emit('{') + + mapVisit(node.keyframes) + + emit('}'); +}; + +traverse.keyframe = function(node) { + var decls = node.declarations; + + return emit(node.values.join(','), node.position, true) + + emit('{') + + mapVisit(decls) + + emit('}'); +}; + +traverse.page = function(node) { + var sel = node.selectors.length + ? node.selectors.join(', ') + : ''; + + return emit('@page ' + sel, node.position, true) + + emit('{') + + mapVisit(node.declarations) + + emit('}'); +}; + +traverse.rule = function(node) { + var decls = node.declarations; + if (!decls.length) return ''; + + var selectors = node.selectors.map(function (selector) { + // removes universal selectors like *.class => .class + // removes optional whitespace around '>' and '+' + return selector.replace(/\*\./, '.') + .replace(/\s*>\s*/g, '>') + .replace(/\s*\+\s*/g, '+'); + }); + return emit(selectors.join(','), node.position, true) + + emit('{') + + mapVisit(decls) + + emit('}'); +}; + +traverse.declaration = function(node, last) { + var value = node.value; + + // remove optional quotes around font name + if (node.property === 'font') { + value = value.replace(/\'[^\']+\'/g, function (m) { + if (m.indexOf(' ') !== -1) + return m; + return m.replace(/\'/g, ''); + }); + value = value.replace(/\"[^\"]+\"/g, function (m) { + if (m.indexOf(' ') !== -1) + return m; + return m.replace(/\"/g, ''); + }); + } + // remove url quotes if possible + // in case it is the last declaration, we can omit the semicolon + return emit(node.property + ':' + value, node.position) + + (last ? '' : emit(';')); +}; + + diff --git a/packages/minifiers/minifiers.js b/packages/minifiers/minifiers.js index b8807a1a97..2055d8e24a 100644 --- a/packages/minifiers/minifiers.js +++ b/packages/minifiers/minifiers.js @@ -10,143 +10,59 @@ CssTools = { return CssTools.minifyCssAst(cssParse(cssText)); }, minifyCssAst: function (cssAst) { - return compile(cssAst); - } -}; + return MinifyAst(cssAst); + }, + concatenateCssAsts: function (cssAsts, warnCb) { + var rulesPredicate = function (rules) { + if (! _.isArray(rules)) + rules = [rules]; + return function (node) { + return _.contains(rules, node.type); + } + }; -// Stringifier based on css-stringify -var emit = function (str) { - return str.toString(); -}; + // The straight-forward concatenation of CSS files would break @import rules + // located in the beginning of a file. Before concatenation, pull them to + // the beginning of a new syntax tree so they always precede other rules. + var newAst = { + type: 'stylesheet', + stylesheet: { rules: [] } + }; -var visit = function (node, last) { - return traverse[node.type](node, last); -}; + _.each(cssAsts, function (ast) { + // Pick only the imports from the beginning of file ignoring @charset + // rules as Meteor assumes every file is in utf-8. + if (_.any(ast.stylesheet.rules, rulesPredicate("charset"))) { + warnCb(ast.filename, "@charset rules in this file will be ignored as Meteor supports only utf-8 at the moment."); + } -var mapVisit = function (nodes) { - var buf = ""; + ast.stylesheet.rules = _.reject(ast.stylesheet.rules, + rulesPredicate("charset")); + var importCount = 0; + for (var i = 0; i < ast.stylesheet.rules.length; i++) + if (!rulesPredicate(["import", "comment"])(ast.stylesheet.rules[i])) { + importCount = i; + break; + } - for (var i = 0, length = nodes.length; i < length; i++) { - buf += visit(nodes[i], i === length - 1); - } + var imports = ast.stylesheet.rules.splice(0, importCount); + newAst.stylesheet.rules = newAst.stylesheet.rules.concat(imports); - return buf; -}; + // if there are imports left in the middle of file, warn user as it might + // be a potential bug (imports are valid only in the beginning of file). + if (_.any(ast.stylesheet.rules, rulesPredicate("import"))) { + warnCb(ast.filename, "warn: there are some @import rules those are not taking effect as they are required to be in the beginning of the file."); + } -var compile = function(node){ - return node.stylesheet - .rules.map(function (rule) { return visit(rule); }) - .join(''); -}; - -var traverse = {}; - -traverse.comment = function(node) { - return emit('', node.position); -}; - -traverse.import = function(node) { - return emit('@import ' + node.import + ';', node.position); -}; - -traverse.media = function(node) { - return emit('@media ' + node.media, node.position, true) - + emit('{') - + mapVisit(node.rules) - + emit('}'); -}; - -traverse.document = function(node) { - var doc = '@' + (node.vendor || '') + 'document ' + node.document; - - return emit(doc, node.position, true) - + emit('{') - + mapVisit(node.rules) - + emit('}'); -}; - -traverse.charset = function(node) { - return emit('@charset ' + node.charset + ';', node.position); -}; - -traverse.namespace = function(node) { - return emit('@namespace ' + node.namespace + ';', node.position); -}; - -traverse.supports = function(node){ - return emit('@supports ' + node.supports, node.position, true) - + emit('{') - + mapVisit(node.rules) - + emit('}'); -}; - -traverse.keyframes = function(node) { - return emit('@' - + (node.vendor || '') - + 'keyframes ' - + node.name, node.position, true) - + emit('{') - + mapVisit(node.keyframes) - + emit('}'); -}; - -traverse.keyframe = function(node) { - var decls = node.declarations; - - return emit(node.values.join(','), node.position, true) - + emit('{') - + mapVisit(decls) - + emit('}'); -}; - -traverse.page = function(node) { - var sel = node.selectors.length - ? node.selectors.join(', ') - : ''; - - return emit('@page ' + sel, node.position, true) - + emit('{') - + mapVisit(node.declarations) - + emit('}'); -}; - -traverse.rule = function(node) { - var decls = node.declarations; - if (!decls.length) return ''; - - var selectors = node.selectors.map(function (selector) { - // removes universal selectors like *.class => .class - // removes optional whitespace around '>' and '+' - return selector.replace(/\*\./, '.') - .replace(/\s*>\s*/g, '>') - .replace(/\s*\+\s*/g, '+'); - }); - return emit(selectors.join(','), node.position, true) - + emit('{') - + mapVisit(decls) - + emit('}'); -}; - -traverse.declaration = function(node, last) { - var value = node.value; - - // remove optional quotes around font name - if (node.property === 'font') { - value = value.replace(/\'[^\']+\'/g, function (m) { - if (m.indexOf(' ') !== -1) - return m; - return m.replace(/\'/g, ''); }); - value = value.replace(/\"[^\"]+\"/g, function (m) { - if (m.indexOf(' ') !== -1) - return m; - return m.replace(/\"/g, ''); + + // Now we can put the rest of CSS rules into new AST + _.each(cssAsts, function (ast) { + newAst.stylesheet.rules = + newAst.stylesheet.rules.concat(ast.stylesheet.rules); }); + + return newAst; } - // remove url quotes if possible - // in case it is the last declaration, we can omit the semicolon - return emit(node.property + ':' + value, node.position) - + (last ? '' : emit(';')); }; - diff --git a/packages/minifiers/package.js b/packages/minifiers/package.js index 23e57cad0e..70384d6860 100644 --- a/packages/minifiers/package.js +++ b/packages/minifiers/package.js @@ -10,8 +10,9 @@ Npm.depends({ }); Package.on_use(function (api) { + api.use('underscore', 'server'); api.export(['CssTools', 'UglifyJSMinify']); - api.add_files('minifiers.js', 'server'); + api.add_files(['minification.js', 'minifiers.js'], 'server'); }); Package.on_test(function (api) { diff --git a/tools/bundler.js b/tools/bundler.js index 0bdcbe028b..cf7f13827a 100644 --- a/tools/bundler.js +++ b/tools/bundler.js @@ -690,11 +690,13 @@ _.extend(Target.prototype, { // Preprocess CSS in this target preprocessCss: function () { // Don't do anything by default + // The real implementation is in the subclass (ClientTarget) }, // Minify the CSS in this target minifyCss: function (minifiers) { // Don't do anything by default + // The real implementation is in the subclass (ClientTarget) }, // Minify the JS in this target @@ -779,14 +781,6 @@ _.extend(ClientTarget.prototype, { }).minifiers; var CssTools = minifiers.CssTools; - // The straight-forward concatenation of CSS files would break @import rules - // located in the beginning of a file. Before concatenation, pull them to - // the beginning of a new syntax tree so they always precede other rules. - var newAst = { - type: 'stylesheet', - stylesheet: { rules: [] } - }; - // Filenames passed to AST manipulator mapped to their original files var originals = {}; @@ -796,63 +790,26 @@ _.extend(ClientTarget.prototype, { try { var parseOptions = { source: filename, position: true }; var ast = CssTools.parseCss(file.contents('utf8'), parseOptions); + ast.filename = filename; } catch (e) { buildmessage.error(e.message, { file: filename }); - return { type: "stylesheet", stylesheet: { rules: [] } }; - } - - var rulePredicate = function (rule) { - return function (node) { - return node.type === rule; - } - } - - // Get rid of comments - ast.stylesheet.rules = _.reject(ast.stylesheet.rules, - rulePredicate("comment")); - - // Pick only the imports from the beginning of file ignoring @charset - // rules as Meteor assumes every file is in utf-8. - if (_.any(ast.stylesheet.rules, rulePredicate("charset"))) { - var filename = file.url.replace(/^\//, ''); - // XXX make this a buildmessage.warning call rather than a random log - console.log("%s: warn: @charset rules in this file will be ignored as Meteor supports only utf-8 at the moment.", filename); - } - - ast.stylesheet.rules = _.reject(ast.stylesheet.rules, - rulePredicate("charset")); - var importCount = 0; - for (var i = 0; i < ast.stylesheet.rules.length; i++) - if (!rulePredicate("import")(ast.stylesheet.rules[i])) { - importCount = i; - break; - } - - var imports = ast.stylesheet.rules.splice(0, importCount); - newAst.stylesheet.rules = newAst.stylesheet.rules.concat(imports); - - // if there are imports left in the middle of file, warn user as it might - // be a potential bug (imports are valid only in the beginning of file). - if (_.any(ast.stylesheet.rules, rulePredicate("import"))) { - var filename = file.url.replace(/^\//, ''); - // XXX make this a buildmessage.warning call rather than a random log - console.log("%s: warn: there are some @import rules those are not taking effect as they are required to be in the beginning of the file.", filename); + return { type: "stylesheet", stylesheet: { rules: [] }, + filename: filename }; } return ast; }); - // Now we can put the rest of CSS rules into new AST - _.each(cssAsts, function (ast) { - newAst.stylesheet.rules = - newAst.stylesheet.rules.concat(ast.stylesheet.rules); - }); + var warnCb = function (filename, msg) { + // XXX make this a buildmessage.warning call rather than a random log + console.log("%s: warn: %s", filename, msg); + }; // Other build phases might need this AST later - self._cssAst = newAst; + self._cssAst = CssTools.concatenateCssAsts(cssAsts, warnCb); // Overwrite the CSS files list to the new concatenated file - var stringifiedCss = CssTools.stringifyCss(newAst, {sourcemap: true}); + var stringifiedCss = CssTools.stringifyCss(self._cssAst, {sourcemap: true}); self.css = [new File({ data: new Buffer(stringifiedCss.code, 'utf8')})]; // Set the contents of sourcemapped files From 99faeac0c76d4e718fee81ab3ffb03158867918f Mon Sep 17 00:00:00 2001 From: Maxime Quandalle Date: Sat, 1 Feb 2014 02:31:57 +0100 Subject: [PATCH 27/34] Upgrade stylus to 0.42.2 and nib to 1.0.2 --- .../plugin/compileStylus/npm-shrinkwrap.json | 38 +++++++++++++++---- packages/stylus/package.js | 2 +- 2 files changed, 31 insertions(+), 9 deletions(-) diff --git a/packages/stylus/.npm/plugin/compileStylus/npm-shrinkwrap.json b/packages/stylus/.npm/plugin/compileStylus/npm-shrinkwrap.json index a9590cc196..d55ecb4c42 100644 --- a/packages/stylus/.npm/plugin/compileStylus/npm-shrinkwrap.json +++ b/packages/stylus/.npm/plugin/compileStylus/npm-shrinkwrap.json @@ -1,27 +1,46 @@ { "dependencies": { "stylus": { - "version": "0.37.0", + "version": "0.42.2", "dependencies": { - "cssom": { - "version": "0.2.5" + "css-parse": { + "version": "1.7.0" }, "mkdirp": { "version": "0.3.5" }, "debug": { - "version": "0.7.2" + "version": "0.7.4" }, "sax": { - "version": "0.5.4" + "version": "0.5.8" + }, + "glob": { + "version": "3.2.8", + "dependencies": { + "minimatch": { + "version": "0.2.14", + "dependencies": { + "lru-cache": { + "version": "2.5.0" + }, + "sigmund": { + "version": "1.0.0" + } + } + }, + "inherits": { + "version": "2.0.1" + } + } } } }, "nib": { - "version": "1.0.0", + "version": "1.0.2", "dependencies": { "stylus": { - "version": "0.34.1", + "version": "0.37.0", "dependencies": { "cssom": { "version": "0.2.5" @@ -30,7 +49,10 @@ "version": "0.3.5" }, "debug": { - "version": "0.7.2" + "version": "0.7.4" + }, + "sax": { + "version": "0.5.8" } } } diff --git a/packages/stylus/package.js b/packages/stylus/package.js index 442639ce94..544946825b 100644 --- a/packages/stylus/package.js +++ b/packages/stylus/package.js @@ -8,7 +8,7 @@ Package._transitional_registerBuildPlugin({ sources: [ 'plugin/compile-stylus.js' ], - npmDependencies: { stylus: "0.37.0", nib: "1.0.0" } + npmDependencies: { stylus: "0.42.2", nib: "1.0.2" } }); Package.on_test(function (api) { From cf11139f6cb80ee5b60de45e7f1d29ebae651ebc Mon Sep 17 00:00:00 2001 From: Maxime Quandalle Date: Sat, 1 Feb 2014 02:32:48 +0100 Subject: [PATCH 28/34] Add a `.import.styl` handler to prevent Meteor processing a stylus file Fix #462 --- docs/client/packages/stylus.html | 5 +++++ packages/less/plugin/compile-less.js | 6 +++--- packages/stylus/package.js | 6 +++++- packages/stylus/plugin/compile-stylus.js | 10 ++++++++++ packages/stylus/stylus_tests.import.styl | 5 +++++ packages/stylus/stylus_tests.js | 15 +++++++++++++-- packages/stylus/stylus_tests.styl | 7 +++++++ tools/packages.js | 8 ++------ 8 files changed, 50 insertions(+), 12 deletions(-) create mode 100644 packages/stylus/stylus_tests.import.styl diff --git a/docs/client/packages/stylus.html b/docs/client/packages/stylus.html index 7d3a217028..2752de11a9 100644 --- a/docs/client/packages/stylus.html +++ b/docs/client/packages/stylus.html @@ -14,6 +14,11 @@ The `stylus` package also includes `nib` support. Add `@import 'nib'` to your `.styl` files to enable cross-browser mixins such as `linear-gradient` and `border-radius`. +{{#note}} +If you want to `@import` a file, give it the extension `.import.styl` +to prevent Meteor from processing it independently. +{{/note}} + See for documentation of the nib extensions of Stylus. {{/better_markdown}} diff --git a/packages/less/plugin/compile-less.js b/packages/less/plugin/compile-less.js index efae3df8b9..81cf3e907d 100644 --- a/packages/less/plugin/compile-less.js +++ b/packages/less/plugin/compile-less.js @@ -62,11 +62,11 @@ Plugin.registerSourceHandler("less", function (compileStep) { }); });; -// Register lessimport files with the dependency watcher, without actually -// processing them. +// Register import.less files with the dependency watcher, without actually +// processing them. There is a similar rule in the stylus package. Plugin.registerSourceHandler("import.less", function () { // Do nothing }); -// Backward compatibility +// Backward compatibility with Meteor 0.7 Plugin.registerSourceHandler("lessimport", function () {}); diff --git a/packages/stylus/package.js b/packages/stylus/package.js index 544946825b..85f04f6552 100644 --- a/packages/stylus/package.js +++ b/packages/stylus/package.js @@ -14,5 +14,9 @@ Package._transitional_registerBuildPlugin({ Package.on_test(function (api) { api.use(['tinytest', 'stylus', 'test-helpers']); api.use('spark'); - api.add_files(['stylus_tests.styl', 'stylus_tests.js'], 'client'); + api.add_files([ + 'stylus_tests.styl', + 'stylus_tests.import.styl', + 'stylus_tests.js' + ],'client'); }); diff --git a/packages/stylus/plugin/compile-stylus.js b/packages/stylus/plugin/compile-stylus.js index 7ddc33dcf5..7e3c7372e5 100644 --- a/packages/stylus/plugin/compile-stylus.js +++ b/packages/stylus/plugin/compile-stylus.js @@ -1,6 +1,7 @@ var fs = Npm.require('fs'); var stylus = Npm.require('stylus'); var nib = Npm.require('nib'); +var path = Npm.require('path'); var Future = Npm.require('fibers/future'); Plugin.registerSourceHandler("styl", function (compileStep) { @@ -17,6 +18,8 @@ Plugin.registerSourceHandler("styl", function (compileStep) { stylus(compileStep.read().toString('utf8')) .use(nib()) .set('filename', compileStep.inputPath) + // Include needed to allow relative @imports in stylus files + .include(path.dirname(compileStep._fullInputPath)) .render(f.resolver()); try { @@ -32,3 +35,10 @@ Plugin.registerSourceHandler("styl", function (compileStep) { data: css }); }); + +// Register import.styl files with the dependency watcher, without actually +// processing them. There is a similar rule in the less package. +Plugin.registerSourceHandler("import.styl", function () { + // Do nothing +}); + diff --git a/packages/stylus/stylus_tests.import.styl b/packages/stylus/stylus_tests.import.styl new file mode 100644 index 0000000000..d5e4779860 --- /dev/null +++ b/packages/stylus/stylus_tests.import.styl @@ -0,0 +1,5 @@ +// Variable used in stylus_test.styl +importDashy = dashed + +.stylus-overwrite-color + font-size: 20px !important diff --git a/packages/stylus/stylus_tests.js b/packages/stylus/stylus_tests.js index 0fddbd3420..af8d924a04 100644 --- a/packages/stylus/stylus_tests.js +++ b/packages/stylus/stylus_tests.js @@ -1,6 +1,5 @@ Tinytest.add("stylus - presence", function(test) { - var d = OnscreenDiv(Meteor.render(function() { return '

'; })); d.node().style.display = 'block'; @@ -10,5 +9,17 @@ Tinytest.add("stylus - presence", function(test) { test.equal(leftBorder, "dashed"); d.kill(); - +}); + +Tinytest.add("stylus - @import", function(test) { + var d = OnscreenDiv(Meteor.render(function() { + return '

'; + })); + d.node().style.display = 'block'; + + var p = d.node().firstChild; + test.equal(getStyleProperty(p, 'font-size'), "20px"); + test.equal(getStyleProperty(p, 'border-left-style'), "dashed"); + + d.kill(); }); diff --git a/packages/stylus/stylus_tests.styl b/packages/stylus/stylus_tests.styl index feedadbdf2..46687d5ae2 100644 --- a/packages/stylus/stylus_tests.styl +++ b/packages/stylus/stylus_tests.styl @@ -1,3 +1,4 @@ +@import "stylus_tests.import.styl" #stylus-tests zoom: 1 @@ -7,3 +8,9 @@ dashy = dashed .stylus-dashy-left-border border-left: 1px dashy black +.stylus-overwrite-size + // This property is overwritten in stylus_test.import.styl + font-size: 10px + +.stylus-import-dashy-border + border-left: 1px importDashy black diff --git a/tools/packages.js b/tools/packages.js index 808ac86141..e6d9ce239d 100644 --- a/tools/packages.js +++ b/tools/packages.js @@ -291,8 +291,7 @@ _.extend(Slice.prototype, { // - appendDocument({ section: "head", data: "my markup" }) // Browser targets only. Add markup to the "head" or "body" // section of the document. - // - addStylesheet({ path: "my/stylesheet.css", - // data: "my css", sourceMap: "{version:3, ...}"}) + // - addStylesheet({ path: "my/stylesheet.css", data: "my css" }) // Browser targets only. Add a stylesheet to the // document. 'path' is a requested URL for the stylesheet that // may or may not ultimately be honored. (Meteor will add @@ -406,13 +405,10 @@ _.extend(Slice.prototype, { "browser targets"); if (typeof options.data !== "string") throw new Error("'data' option to addStylesheet must be a string"); - if (typeof options.sourceMap !== "string" && options.sourceMap !== undefined) - throw new Error("'sourceMap' option to addStylesheet must be a string"); resources.push({ type: "css", data: new Buffer(options.data, 'utf8'), - servePath: path.join(self.pkg.serveRoot, options.path), - sourceMap: options.sourceMap + servePath: path.join(self.pkg.serveRoot, options.path) }); }, addJavaScript: function (options) { From 17d6bbcee062034068471f23e1b252673205118b Mon Sep 17 00:00:00 2001 From: Maxime Quandalle Date: Sat, 1 Feb 2014 02:44:20 +0100 Subject: [PATCH 29/34] Update History.md --- History.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/History.md b/History.md index 13e81e1765..556c181076 100644 --- a/History.md +++ b/History.md @@ -1,10 +1,13 @@ ## v.NEXT * XXX upgraded `less` from 1.3.3 to 1.6.1 +* XXX upgraded `stylus` from 0.37.0 to 0.42.2 and `nib` from `1.0.0` to `1.0.2` * XXX sourcemaps support for stylesheets, including less sourcemaps * XXX css linting (breaks on errors) * XXX css preprocessing to concatenate files correctly (pulls @imports to the beginning) +* XXX supports `.import.less` and `.import.styl` to prevent Meteor processing + stylesheets. `.lessimport` is deprecated * Hash login tokens before storing them in the database. From 84917c9fa90ba6ed816d45f34707c69e31d9698d Mon Sep 17 00:00:00 2001 From: David Glasser Date: Tue, 4 Feb 2014 16:24:56 -0800 Subject: [PATCH 30/34] Remove warning for dev_bundle max version --- meteor | 4 ---- 1 file changed, 4 deletions(-) diff --git a/meteor b/meteor index 4b711f8d62..16e72487b1 100755 --- a/meteor +++ b/meteor @@ -1,9 +1,5 @@ #!/bin/bash -# danger will robinson! mother:config/download-dev-bundles.sh only goes up to -# 0.3.30! - -# Before you increment this again, fix the script listed above. BUNDLE_VERSION=0.3.30 # OS Check. Put here because here is where we download the precompiled From a26822ec9684086114d4e8257b8b6c8471fe7e8b Mon Sep 17 00:00:00 2001 From: Slava Kim Date: Wed, 5 Feb 2014 13:54:30 -0800 Subject: [PATCH 31/34] Style fixes, renames, comments --- packages/less/plugin/compile-less.js | 10 ++--- packages/minifiers/minifiers-tests.js | 2 +- packages/minifiers/minifiers.js | 11 ++--- tools/bundler.js | 59 +++++++++++++-------------- 4 files changed, 40 insertions(+), 42 deletions(-) diff --git a/packages/less/plugin/compile-less.js b/packages/less/plugin/compile-less.js index 81cf3e907d..73f24b5206 100644 --- a/packages/less/plugin/compile-less.js +++ b/packages/less/plugin/compile-less.js @@ -23,14 +23,14 @@ Plugin.registerSourceHandler("less", function (compileStep) { paths: [path.dirname(compileStep._fullInputPath)] // for @import }; - var parser = new(less.Parser)(options); + var parser = new less.Parser(options); var astFuture = new Future; - var ast, css; + var ast; try { parser.parse(source, astFuture.resolver()); ast = astFuture.wait(); } catch (e) { - // less.render() is supposed to report any errors via its + // less.Parser.parse is supposed to report any errors via its // callback. But sometimes, it throws them instead. This is // probably a bug in less. Be prepared for either behavior. compileStep.error({ @@ -43,14 +43,14 @@ Plugin.registerSourceHandler("less", function (compileStep) { } var cssFuture = new Future; - css = ast.toCSS({ + var css = ast.toCSS({ sourceMap: Boolean(true), writeSourceMap: function (sourceMap) { cssFuture.return(sourceMap); } }); - sourceMap = JSON.parse(cssFuture.wait()); + var sourceMap = JSON.parse(cssFuture.wait()); sourceMap.sources = [compileStep.inputPath]; sourceMap.sourcesContent = [source]; diff --git a/packages/minifiers/minifiers-tests.js b/packages/minifiers/minifiers-tests.js index e42f753635..282517b430 100644 --- a/packages/minifiers/minifiers-tests.js +++ b/packages/minifiers/minifiers-tests.js @@ -4,7 +4,7 @@ Tinytest.add("minifiers - simple css minification", function (test) { } t('a \t\n{ color: red } \n', 'a{color:red}', 'whitespace check'); - t('a \t\n{ color: red; margin: 1; } \n', 'a{color:red;margin:1}', 'only last one looses semicolon'); + t('a \t\n{ color: red; margin: 1; } \n', 'a{color:red;margin:1}', 'only last one loses semicolon'); t('a \t\n{ color: red;;; margin: 1;;; } \n', 'a{color:red;margin:1}', 'more semicolons than needed'); t('a , p \t\n{ color: red; } \n', 'a,p{color:red}', 'multiple selectors'); t('body {}', '', 'removing empty rules'); diff --git a/packages/minifiers/minifiers.js b/packages/minifiers/minifiers.js index 2055d8e24a..fa2773e158 100644 --- a/packages/minifiers/minifiers.js +++ b/packages/minifiers/minifiers.js @@ -12,7 +12,7 @@ CssTools = { minifyCssAst: function (cssAst) { return MinifyAst(cssAst); }, - concatenateCssAsts: function (cssAsts, warnCb) { + mergeCssAsts: function (cssAsts, warnCb) { var rulesPredicate = function (rules) { if (! _.isArray(rules)) rules = [rules]; @@ -21,7 +21,7 @@ CssTools = { } }; - // The straight-forward concatenation of CSS files would break @import rules + // Simple concatenation of CSS files would break @import rules // located in the beginning of a file. Before concatenation, pull them to // the beginning of a new syntax tree so they always precede other rules. var newAst = { @@ -31,7 +31,7 @@ CssTools = { _.each(cssAsts, function (ast) { // Pick only the imports from the beginning of file ignoring @charset - // rules as Meteor assumes every file is in utf-8. + // rules as every file is assumed to be in UTF-8. if (_.any(ast.stylesheet.rules, rulesPredicate("charset"))) { warnCb(ast.filename, "@charset rules in this file will be ignored as Meteor supports only utf-8 at the moment."); } @@ -40,7 +40,7 @@ CssTools = { rulesPredicate("charset")); var importCount = 0; for (var i = 0; i < ast.stylesheet.rules.length; i++) - if (!rulesPredicate(["import", "comment"])(ast.stylesheet.rules[i])) { + if (! rulesPredicate(["import", "comment"])(ast.stylesheet.rules[i])) { importCount = i; break; } @@ -51,7 +51,8 @@ CssTools = { // if there are imports left in the middle of file, warn user as it might // be a potential bug (imports are valid only in the beginning of file). if (_.any(ast.stylesheet.rules, rulesPredicate("import"))) { - warnCb(ast.filename, "warn: there are some @import rules those are not taking effect as they are required to be in the beginning of the file."); + // XXX make this an error? + warnCb(ast.filename, "there are some @import rules those are not taking effect as they are required to be in the beginning of the file"); } }); diff --git a/tools/bundler.js b/tools/bundler.js index cf7f13827a..08d364dfe5 100644 --- a/tools/bundler.js +++ b/tools/bundler.js @@ -448,8 +448,10 @@ _.extend(Target.prototype, { // Link JavaScript and set up self.js, etc. self._emitResources(); - // Run the preprocessing and concatenation of CSS files. - self.preprocessCss(); + // Preprocess and concatenate CSS files for client targets. + if (self instanceof ClientTarget) { + self.mergeCss(); + } // Minify, if requested if (options.minify) { @@ -458,7 +460,11 @@ _.extend(Target.prototype, { packages: ['minifiers'] }).minifiers; self.minifyJs(minifiers); - self.minifyCss(minifiers); + + // CSS is minified only for client targets. + if (self instanceof ClientTarget) { + self.minifyCss(minifiers); + } } if (options.addCacheBusters) { @@ -658,7 +664,7 @@ _.extend(Target.prototype, { } } - // Both CSS and JS files can have sourcemaps + // Both CSS and JS files can have source maps if (resource.sourceMap) { f.setSourceMap(resource.sourceMap, path.dirname(relPath)); } @@ -687,18 +693,6 @@ _.extend(Target.prototype, { }); }, - // Preprocess CSS in this target - preprocessCss: function () { - // Don't do anything by default - // The real implementation is in the subclass (ClientTarget) - }, - - // Minify the CSS in this target - minifyCss: function (minifiers) { - // Don't do anything by default - // The real implementation is in the subclass (ClientTarget) - }, - // Minify the JS in this target minifyJs: function (minifiers) { var self = this; @@ -755,11 +749,11 @@ var ClientTarget = function (options) { var self = this; Target.apply(this, arguments); - // CSS files. List of File. They will be preprocessed, concatenated into - // single file and loaded at page load. + // CSS files. List of File. They will be loaded in the order given. self.css = []; - // Intermediate representation of preprocessed CSS tree. - self._cssAst = null; + // Cached CSS AST. If non-null, self.css has one item in it, processed CSS + // from merged input files, and this is its parse tree. + self._cssAstCache = null; // List of segments of additional HTML for /. self.head = []; @@ -772,8 +766,10 @@ var ClientTarget = function (options) { inherits(ClientTarget, Target); _.extend(ClientTarget.prototype, { - // Preprocess the CSS in the target - preprocessCss: function () { + // Lints CSS files and merges them into one file, fixing up source maps and + // pulling any @import directives up to the top since the CSS spec does not + // allow them to appear in the middle of a file. + mergeCss: function () { var self = this; var minifiers = unipackage.load({ library: self.library, @@ -806,20 +802,21 @@ _.extend(ClientTarget.prototype, { }; // Other build phases might need this AST later - self._cssAst = CssTools.concatenateCssAsts(cssAsts, warnCb); + self._cssAstCache = CssTools.mergeCssAsts(cssAsts, warnCb); - // Overwrite the CSS files list to the new concatenated file - var stringifiedCss = CssTools.stringifyCss(self._cssAst, {sourcemap: true}); - self.css = [new File({ data: new Buffer(stringifiedCss.code, 'utf8')})]; + // Overwrite the CSS files list with the new concatenated file + var stringifiedCss = CssTools.stringifyCss(self._cssAstCache, + { sourcemap: true }); + self.css = [new File({ data: new Buffer(stringifiedCss.code, 'utf8') })]; - // Set the contents of sourcemapped files + // Add the contents of the input files to the source map of the new file stringifiedCss.map.sourcesContent = _.map(stringifiedCss.map.sources, function (filename) { return originals[filename].contents('utf8'); }); - // Apply all previous sourcemaps if those existed - // Ex.: less -> css sourcemap sould be applied to css -> css sourcemap + // If any input files had source maps, apply them. + // Ex.: less -> css source map should be composed with css -> css source map var newMap = sourcemap.SourceMapGenerator.fromSourceMap( new sourcemap.SourceMapConsumer(stringifiedCss.map)); @@ -840,8 +837,8 @@ _.extend(ClientTarget.prototype, { // If there is an AST already calculated, don't waste time on parsing it // again. - if (self._cssAst) { - minifiedCss = minifiers.CssTools.minifyCssAst(self._cssAst); + if (self._cssAstCache) { + minifiedCss = minifiers.CssTools.minifyCssAst(self._cssAstCache); } else if (self.css) { var allCss = _.map(self.css, function (file) { return file.contents('utf8'); From 6b9af2b058ce005d4af956b5161812d356aaa092 Mon Sep 17 00:00:00 2001 From: Slava Kim Date: Wed, 5 Feb 2014 13:54:51 -0800 Subject: [PATCH 32/34] Warn about @charset rules only if they specify anything but utf-8 --- packages/minifiers/minifiers.js | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/packages/minifiers/minifiers.js b/packages/minifiers/minifiers.js index fa2773e158..133cf3610c 100644 --- a/packages/minifiers/minifiers.js +++ b/packages/minifiers/minifiers.js @@ -32,8 +32,15 @@ CssTools = { _.each(cssAsts, function (ast) { // Pick only the imports from the beginning of file ignoring @charset // rules as every file is assumed to be in UTF-8. - if (_.any(ast.stylesheet.rules, rulesPredicate("charset"))) { - warnCb(ast.filename, "@charset rules in this file will be ignored as Meteor supports only utf-8 at the moment."); + var charsetRules = _.filter(ast.stylesheet.rules, + rulesPredicate("charset")); + + if (_.any(charsetRules, function (rule) { + // According to MDN, only 'UTF-8' and "UTF-8" are the correct encoding + // directives representing UTF-8. + return ! /^(['"])UTF-8\1$/.test(rule.charset); + })) { + warnCb(ast.filename, "@charset rules in this file will be ignored as UTF-8 is the only encoding supported"); } ast.stylesheet.rules = _.reject(ast.stylesheet.rules, From 23b75a20b1fe07790c8760b00ca4d7eacae2b51e Mon Sep 17 00:00:00 2001 From: Slava Kim Date: Wed, 5 Feb 2014 22:21:44 -0800 Subject: [PATCH 33/34] Update license refs Clean-CSS is no longer used. Instead css-parse and css-stringify are added. --- LICENSE.txt | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/LICENSE.txt b/LICENSE.txt index 0f25743305..9897ae8e37 100644 --- a/LICENSE.txt +++ b/LICENSE.txt @@ -71,13 +71,6 @@ handlebars: https://github.com/wycats/handlebars.js/ Copyright (C) 2011 by Yehuda Katz ----------- -clean-css: https://github.com/GoalSmashers/clean-css ----------- - -Copyright (c) 2011 GoalSmashers.com - - ---------- progress: https://github.com/visionmedia/node-progress qs: https://github.com/visionmedia/node-querystring @@ -91,11 +84,14 @@ pause: https://github.com/visionmedia/node-pause range-parser: https://github.com/visionmedia/node-range-parser send: https://github.com/visionmedia/send methods: https://github.com/visionmedia/node-methods +css-parse: https://github.com/reworkcss/css-parse +css-stringify: https://github.com/reworkcss/css-stringify ---------- Copyright (c) 2010 TJ Holowaychuk Copyright (c) 2011 TJ Holowaychuk Copyright (c) 2012 TJ Holowaychuk +Copyright (c) 2013 TJ Holowaychuk ---------- From 59c3b468a76a13527bb5eb8553b0e5e3017afbbf Mon Sep 17 00:00:00 2001 From: David Glasser Date: Wed, 5 Feb 2014 17:03:11 -0800 Subject: [PATCH 34/34] slightly changed awssum --- scripts/admin/publish-release/packages/awssum | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/admin/publish-release/packages/awssum b/scripts/admin/publish-release/packages/awssum index 0221218663..69dc3c7afb 160000 --- a/scripts/admin/publish-release/packages/awssum +++ b/scripts/admin/publish-release/packages/awssum @@ -1 +1 @@ -Subproject commit 0221218663b12b47f61cd9745da9c2be3f247bdb +Subproject commit 69dc3c7afb455cb487b6fbe551478384dea0cb0b