less 1.2.2 → 1.3.3

package/test/less/urls.less

@@ -0,0 +1,33 @@
+@font-face {
+  src: url("/fonts/garamond-pro.ttf");
+  src: local(Futura-Medium),
+       url(fonts.svg#MyGeometricModern) format("svg");
+}
+#shorthands {
+  background: url("http://www.lesscss.org/spec.html") no-repeat 0 4px;
+}
+#misc {
+  background-image: url(images/image.jpg);
+}
+#data-uri {
+  background: url(data:image/png;charset=utf-8;base64,
+    kiVBORw0KGgoAAAANSUhEUgAAABAAAAAQAQMAAAAlPW0iAAAABlBMVEUAAAD/
+    k//+l2Z/dAAAAM0lEQVR4nGP4/5/h/1+G/58ZDrAz3D/McH8yw83NDDeNGe4U
+    kg9C9zwz3gVLMDA/A6P9/AFGGFyjOXZtQAAAAAElFTkSuQmCC);
+  background-image: url(data:image/x-png,f9difSSFIIGFIFJD1f982FSDKAA9==);
+  background-image: url(http://fonts.googleapis.com/css?family=\"Rokkitt\":\(400\),700);
+}
+
+#svg-data-uri {
+  background: transparent url('data:image/svg+xml, <svg version="1.1"><g></g></svg>');
+}
+
+.comma-delimited {
+  background: url(bg.jpg) no-repeat, url(bg.png) repeat-x top left, url(bg);
+}
+.values {
+    @a: 'Trebuchet';
+    url: url(@a);
+}
+
+@import "import/import-and-relative-paths-test";

package/test/less/variables.less

@@ -35,7 +35,6 @@
     @multi: 'A', B, C;
     font-family: @a, @a, @a;
     color: @c !important;
-    url: url(@a);
     multi: something @multi, @a;
 }
 

package/test/less/whitespace.less

@@ -35,3 +35,10 @@
 .empty {
   
 }
+.sel
+.newline_ws	.tab_ws	{
+color:
+white;
+background-position: 45
+-23;
+}

package/test/less-test.js

@@ -3,47 +3,170 @@ var path = require('path'),
     sys = require('util');
 
 var less = require('../lib/less');
+var stylize = require('../lib/less/lessc_helper').stylize;
+
+var oneTestOnly = process.argv[2];
+
+var totalTests = 0,
+    failedTests = 0,
+    passedTests = 0;
 
 less.tree.functions.add = function (a, b) {
     return new(less.tree.Dimension)(a.value + b.value);
-}
+};
 less.tree.functions.increment = function (a) {
     return new(less.tree.Dimension)(a.value + 1);
-}
+};
 less.tree.functions._color = function (str) {
     if (str.value === "evil red") { return new(less.tree.Color)("600") }
-}
+};
 
 sys.puts("\n" + stylize("LESS", 'underline') + "\n");
 
-fs.readdirSync('test/less').forEach(function (file) {
-    if (! /\.less/.test(file)) { return }
+runTestSet({relativeUrls: true});
 
-    toCSS('test/less/' + file, function (err, less) {
-        var name = path.basename(file, '.less');
-
-        fs.readFile(path.join('test/css', name) + '.css', 'utf-8', function (e, css) {
-            sys.print("- " + name + ": ")
-            if (less === css) { sys.print(stylize('OK', 'green')) }
-            else if (err) {
-                sys.print(stylize("ERROR: " + (err && err.message), 'red'));
+runTestSet(null, "errors/", function(name, err, compiledLess, doReplacements) {
+    fs.readFile(path.join('test/less/', name) + '.txt', 'utf8', function (e, expectedErr) {
+        sys.print("- " + name + ": ");
+        expectedErr = doReplacements(expectedErr, 'test/less/errors/');
+        if (!err) {
+            if (compiledLess) {
+                fail("No Error", 'red');
+            } else {
+                fail("No Error, No Output");
+            }
+        } else {
+            var errMessage = less.formatError(err);
+            if (errMessage === expectedErr) {
+                ok('OK');                    
             } else {
-                sys.print(stylize("FAIL", 'yellow'));
+                difference("FAIL", expectedErr, errMessage);
+            }
+        }
+        sys.puts("");
+    });}, null, function(input, directory) {
+        return input.replace(
+            "{path}", path.join(process.cwd(), "/test/less/errors/"))
+            .replace("{pathrel}", path.join("test", "less", "errors/"))
+            .replace(/\r\n/g, '\n');
+    });
+
+runTestSet({dumpLineNumbers: 'comments'}, "debug/", null,
+           function(name) { return name + '-comments'; });
+runTestSet({dumpLineNumbers: 'mediaquery'}, "debug/", null,
+           function(name) { return name + '-mediaquery'; });
+runTestSet({dumpLineNumbers: 'all'}, "debug/", null,
+           function(name) { return name + '-all'; });
+runTestSet({relativeUrls: false, rootpath: "folder (1)/"}, "static-urls/");
+
+function globalReplacements(input, directory) {
+    var p = path.join(process.cwd(), directory),
+        pathimport = path.join(process.cwd(), directory + "import/"),
+        pathesc = p.replace(/[.:\/]/g, '\\$&'),
+        pathimportesc = pathimport.replace(/[.:\/]/g, '\\$&');
+
+    return input.replace(/\{path\}/g, p)
+            .replace(/\{pathesc\}/g, pathesc)
+            .replace(/\{pathimport\}/g, pathimport)
+            .replace(/\{pathimportesc\}/g, pathimportesc)
+            .replace(/\r\n/g, '\n');
+}
+
+function runTestSet(options, foldername, verifyFunction, nameModifier, doReplacements) {
+    foldername = foldername || "";
+
+    if(!doReplacements)
+        doReplacements = globalReplacements;
+
+    fs.readdirSync(path.join('test/less/', foldername)).forEach(function (file) {
+        if (! /\.less/.test(file)) { return }
+        
+        var name = foldername + path.basename(file, '.less');
+        
+        if (oneTestOnly && name !== oneTestOnly) { return; }
+        
+        totalTests++;
+
+        toCSS(options, path.join('test/less/', foldername + file), function (err, less) {
+
+            if (verifyFunction) {
+                return verifyFunction(name, err, less, doReplacements);
             }
-            sys.puts("");
+            var css_name = name;
+            if(nameModifier) css_name=nameModifier(name);
+            fs.readFile(path.join('test/css', css_name) + '.css', 'utf8', function (e, css) {
+                sys.print("- " + css_name + ": ")
+                
+                css = css && doReplacements(css, 'test/less/' + foldername);
+                if (less === css) { ok('OK'); }
+                else if (err) {
+                    fail("ERROR: " + (err && err.message));
+                } else {
+                    difference("FAIL", css, less);
+                }
+                sys.puts("");
+            });
         });
     });
-});
+}
+
+function diff(left, right) {
+    sys.puts("");
+    require('diff').diffLines(left, right).forEach(function(item) {
+      if(item.added || item.removed) {
+        sys.print(stylize(item.value, item.added ? 'green' : 'red'));
+      } else {
+        sys.print(item.value);
+      }
+    });
+}
+
+function fail(msg) {
+    sys.print(stylize(msg, 'red'));
+    failedTests++;
+    endTest();
+}
 
-function toCSS(path, callback) {
+function difference(msg, left, right) {
+    sys.print(stylize(msg, 'yellow'));
+    failedTests++;
+                
+    diff(left, right);
+    endTest();
+}
+
+function ok(msg) {
+    sys.print(stylize(msg, 'green'));
+    passedTests++;
+    endTest();
+}
+
+function endTest() {
+    if (failedTests + passedTests === totalTests) {
+        sys.puts("");
+        sys.puts("");
+        if (failedTests > 0) {
+            sys.print(failedTests);
+            sys.print(stylize(" Failed", "red"));
+            sys.print(", " + passedTests + " passed");
+        } else {
+            sys.print(stylize("All Passed ", "green"));
+            sys.print(passedTests + " run");
+        }
+    }
+}
+
+function toCSS(options, path, callback) {
     var tree, css;
-    fs.readFile(path, 'utf-8', function (e, str) {
+    options = options || {};
+    fs.readFile(path, 'utf8', function (e, str) {
         if (e) { return callback(e) }
+        
+        options.paths = [require('path').dirname(path)];
+        options.filename = require('path').resolve(process.cwd(), path);
+        options.optimization = options.optimization || 0;
 
-        new(less.Parser)({
-            paths: [require('path').dirname(path)],
-            optimization: 0
-        }).parse(str, function (err, tree) {
+        new(less.Parser)(options).parse(str, function (err, tree) {
             if (err) {
                 callback(err);
             } else {
@@ -57,17 +180,3 @@ function toCSS(path, callback) {
         });
     });
 }
-
-// Stylize a string
-function stylize(str, style) {
-    var styles = {
-        'bold'      : [1,  22],
-        'inverse'   : [7,  27],
-        'underline' : [4,  24],
-        'yellow'    : [33, 39],
-        'green'     : [32, 39],
-        'red'       : [31, 39]
-    };
-    return '\033[' + styles[style][0] + 'm' + str +
-           '\033[' + styles[style][1] + 'm';
-}