less 2.4.0 → 2.5.0

data/lib/less/js/benchmark/less-benchmark.js

@@ -10,33 +10,32 @@ if (process.argv[2]) { file = path.join(process.cwd(), process.argv[2]) }
 fs.readFile(file, 'utf8', function (e, data) {
     var tree, css, start, end, total;
 
-    sys.puts("Benchmarking...\n", path.basename(file) + " (" +
+    console.log("Benchmarking...\n", path.basename(file) + " (" +
              parseInt(data.length / 1024) + " KB)", "");
 
     start = new(Date);
 
     new(less.Parser)({ optimization: 2 }).parse(data, function (err, tree) {
-        end = new(Date);
+        end = new Date();
 
         total = end - start;
 
-        sys.puts("Parsing: " +
+        console.log("Parsing: " +
                  total + " ms (" +
-                 parseInt(1000 / total *
-                 data.length / 1024) + " KB\/s)");
+                 Number(1000 / total * data.length / 1024) + " KB\/s)");
 
-        start = new(Date);
+        start = new Date();
         css = tree.toCSS();
-        end = new(Date);
+        end = new Date();
 
-        sys.puts("Generation: " + (end - start) + " ms (" +
+        console.log("Generation: " + (end - start) + " ms (" +
                  parseInt(1000 / (end - start) *
                  data.length / 1024) + " KB\/s)");
 
         total += end - start;
 
-        sys.puts("Total: " + total + "ms (" +
-                 parseInt(1000 / total * data.length / 1024) + " KB/s)");
+        console.log("Total: " + total + "ms (" +
+            Number(1000 / total * data.length / 1024) + " KB/s)");
 
         if (err) {
             less.writeError(err);

data/lib/less/js/bin/lessc

@@ -11,7 +11,7 @@ var args = process.argv.slice(1);
 var options = {
     depends: false,
     compress: false,
-    yuicompress: false,
+    cleancss: false,
     max_line_len: -1,
     optimization: 1,
     silent: false,
@@ -20,12 +20,17 @@ var options = {
     paths: [],
     color: true,
     strictImports: false,
+    insecure: false,
     rootpath: '',
     relativeUrls: false,
     ieCompat: true,
     strictMath: false,
-    strictUnits: false
+    strictUnits: false,
+    globalVariables: '',
+    modifyVariables: '',
+    urlArgs: ''
 };
+var cleancssOptions = {};
 var continueProcessing = true,
     currentErrorcode;
 
@@ -35,7 +40,7 @@ process.on('exit', function() { process.reallyExit(currentErrorcode) });
 
 var checkArgFunc = function(arg, option) {
     if (!option) {
-        sys.puts(arg + " option requires a parameter");
+        console.log(arg + " option requires a parameter");
         continueProcessing = false;
         return false;
     }
@@ -45,13 +50,21 @@ var checkArgFunc = function(arg, option) {
 var checkBooleanArg = function(arg) {
     var onOff = /^((on|t|true|y|yes)|(off|f|false|n|no))$/i.exec(arg);
     if (!onOff) {
-        sys.puts(" unable to parse "+arg+" as a boolean. use one of on/t/true/y/yes/off/f/false/n/no");
+        console.log(" unable to parse "+arg+" as a boolean. use one of on/t/true/y/yes/off/f/false/n/no");
         continueProcessing = false;
         return false;
     }
     return Boolean(onOff[2]);
 };
 
+var parseVariableOption = function(option) {
+    var parts = option.split('=', 2);
+    return '@' + parts[0] + ': ' + parts[1] + ';\n';
+};
+
+var warningMessages = "";
+var sourceMapFileInline = false;
+
 args = args.filter(function (arg) {
     var match;
 
@@ -60,13 +73,13 @@ args = args.filter(function (arg) {
         return false;
     }
 
-    if (match = arg.match(/^--?([a-z][0-9a-z-]*)(?:=([^\s]*))?$/i)) { arg = match[1] }
+    if (match = arg.match(/^--?([a-z][0-9a-z-]*)(?:=(.*))?$/i)) { arg = match[1] }
     else { return arg }
 
     switch (arg) {
         case 'v':
         case 'version':
-            sys.puts("lessc " + less.version.join('.') + " (LESS Compiler) [JavaScript]");
+            console.log("lessc " + less.version.join('.') + " (LESS Compiler) [JavaScript]");
             continueProcessing = false;
         case 'verbose':
             options.verbose = true;
@@ -90,12 +103,18 @@ args = args.filter(function (arg) {
         case 'compress':
             options.compress = true;
             break;
+        case 'insecure':
+            options.insecure = true;
+            break;
         case 'M':
         case 'depends':
             options.depends = true;
             break;
         case 'yui-compress':
-            options.yuicompress = true;
+            warningMessages += "yui-compress option has been removed. ignoring.";
+            break;
+        case 'clean-css':
+            options.cleancss = true;
             break;
         case 'max-line-len':
             if (checkArgFunc(arg, match[2])) {
@@ -111,6 +130,9 @@ args = args.filter(function (arg) {
         case 'no-ie-compat':
             options.ieCompat = false;
             break;
+        case 'no-js':
+            options.javascriptEnabled = false;
+            break;
         case 'include-path':
             if (checkArgFunc(arg, match[2])) {
                 options.paths = match[2].split(os.type().match(/Windows/) ? ';' : ':')
@@ -129,6 +151,35 @@ args = args.filter(function (arg) {
                 options.dumpLineNumbers = match[2];
             }
             break;
+        case 'source-map':
+            if (!match[2]) {
+                options.sourceMap = true;
+            } else {
+                options.sourceMap = match[2];
+            }
+            break;
+        case 'source-map-rootpath':
+            if (checkArgFunc(arg, match[2])) {
+                options.sourceMapRootpath = match[2];
+            }
+            break;
+        case 'source-map-basepath':
+            if (checkArgFunc(arg, match[2])) {
+                options.sourceMapBasepath = match[2];
+            }
+            break;
+        case 'source-map-map-inline':
+            sourceMapFileInline = true;
+            options.sourceMap = true;
+            break;
+        case 'source-map-less-inline':
+            options.outputSourceFiles = true;
+            break;
+        case 'source-map-url':
+            if (checkArgFunc(arg, match[2])) {
+                options.sourceMapURL = match[2];
+            }
+            break;
         case 'rp':
         case 'rootpath':
             if (checkArgFunc(arg, match[2])) {
@@ -151,6 +202,57 @@ args = args.filter(function (arg) {
                 options.strictUnits = checkBooleanArg(match[2]);
             }
             break;
+        case "global-var":
+            if (checkArgFunc(arg, match[2])) {
+                options.globalVariables += parseVariableOption(match[2]);
+            }
+            break;
+        case "modify-var":
+            if (checkArgFunc(arg, match[2])) {
+                options.modifyVariables += parseVariableOption(match[2]);
+            }
+            break;
+        case "clean-option":
+            var cleanOptionArgs = match[2].split(":");
+            switch(cleanOptionArgs[0]) {
+                case "--keep-line-breaks":
+                case "-b":
+                    cleancssOptions.keepBreaks = true;
+                    break;
+                case "--s0":
+                    cleancssOptions.keepSpecialComments = 0;
+                    break;
+                case "--s1":
+                    cleancssOptions.keepSpecialComments = 1;
+                    break;
+                case "--skip-advanced":
+                    cleancssOptions.noAdvanced = true;
+                    break;
+                case "--advanced":
+                    cleancssOptions.noAdvanced = false;
+                    break;
+                case "--selectors-merge-mode":
+                    cleancssOptions.selectorsMergeMode = cleanOptionArgs[1];
+                    break;
+                default:
+                    console.log("unrecognised clean-css option '" + cleanOptionArgs[0] + "'");
+                    console.log("we support only arguments that make sense for less, '--keep-line-breaks', '-b'");
+                    console.log("'--s0', '--s1', '--advanced', '--skip-advanced', '--selectors-merge-mode'");
+                    continueProcessing = false;
+                    currentErrorcode = 1;
+                    break;
+            }
+            break;
+        case 'url-args':
+            if (checkArgFunc(arg, match[2])) {
+                options.urlArgs = match[2];
+            }
+            break;
+        default:
+            require('../lib/less/lessc_helper').printUsage();
+            continueProcessing = false;
+            currentErrorcode = 1;
+            break;
     }
 });
 
@@ -166,12 +268,32 @@ if (input && input != '-') {
 var output = args[2];
 var outputbase = args[2];
 if (output) {
+    options.sourceMapOutputFilename = output;
     output = path.resolve(process.cwd(), output);
+    if (warningMessages) {
+        console.log(warningMessages);
+    }
+}
+
+options.sourceMapBasepath = options.sourceMapBasepath || (input ? path.dirname(input) : process.cwd());
+
+if (options.sourceMap === true) {
+    if (!output && !sourceMapFileInline) {
+        console.log("the sourcemap option only has an optional filename if the css filename is given");
+        return;
+    }
+    options.sourceMapFullFilename = options.sourceMapOutputFilename + ".map";
+    options.sourceMap = path.basename(options.sourceMapFullFilename);
+}
+
+if (options.cleancss && options.sourceMap) {
+    console.log("the sourcemap option is not compatible with sourcemap support at the moment. See Issue #1656");
+    return;
 }
 
 if (! input) {
-    sys.puts("lessc: no input files");
-    sys.puts("");
+    console.log("lessc: no input files");
+    console.log("");
     require('../lib/less/lessc_helper').printUsage();
     currentErrorcode = 1;
     return;
@@ -199,13 +321,23 @@ if (options.depends) {
     sys.print(outputbase + ": ");
 }
 
+if (!sourceMapFileInline) {
+    var writeSourceMap = function(output) {
+        var filename = options.sourceMapFullFilename || options.sourceMap;
+        ensureDirectory(filename);
+        fs.writeFileSync(filename, output, 'utf8');
+    };
+}
+
 var parseLessFile = function (e, data) {
     if (e) {
-        sys.puts("lessc: " + e.message);
+        console.log("lessc: " + e.message);
         currentErrorcode = 1;
         return;
     }
 
+    data = options.globalVariables + data + options.modifyVariables;
+
     options.paths = [path.dirname(input)].concat(options.paths);
     options.filename = input;
 
@@ -227,10 +359,20 @@ var parseLessFile = function (e, data) {
                     verbose: options.verbose,
                     ieCompat: options.ieCompat,
                     compress: options.compress,
-                    yuicompress: options.yuicompress,
+                    cleancss: options.cleancss,
+                    cleancssOptions: cleancssOptions,
+                    sourceMap: Boolean(options.sourceMap),
+                    sourceMapFilename: options.sourceMap,
+                    sourceMapURL: options.sourceMapURL,
+                    sourceMapOutputFilename: options.sourceMapOutputFilename,
+                    sourceMapBasepath: options.sourceMapBasepath,
+                    sourceMapRootpath: options.sourceMapRootpath || "",
+                    outputSourceFiles: options.outputSourceFiles,
+                    writeSourceMap: writeSourceMap,
                     maxLineLen: options.maxLineLen,
                     strictMath: options.strictMath,
-                    strictUnits: options.strictUnits
+                    strictUnits: options.strictUnits,
+                    urlArgs: options.urlArgs
                 });
                 if (output) {
                     ensureDirectory(output);

data/lib/less/js/bower.json

@@ -0,0 +1,18 @@
+{
+  "name": "less",
+  "version": "1.6.2",
+  "main": "./dist/less-1.6.2.js",
+  "ignore": [
+    "**/.*",
+    "benchmark",
+    "bin",
+    "build",
+    "lib",
+    "test",
+    "*.md",
+    "LICENSE",
+    "Gruntfile.js",
+    "package.json",
+    "bower.json"
+  ]
+}

data/lib/less/js/build.gradle

@@ -0,0 +1,347 @@
+import groovy.io.FileType
+import org.apache.tools.ant.taskdefs.condition.Os
+import org.gradle.api.tasks.Exec
+
+buildscript {
+    repositories {
+        mavenCentral()
+		jcenter()
+    }
+    dependencies {
+        classpath 'com.eriwen:gradle-js-plugin:1.8.0'
+		classpath 'com.moowork.gradle:gradle-grunt-plugin:0.2'
+    }
+}
+
+apply plugin: 'js'
+apply plugin: 'grunt'
+
+repositories {
+    mavenCentral()
+}
+
+configurations {
+    rhino
+}
+
+dependencies {
+    rhino 'org.mozilla:rhino:1.7R4'
+}
+
+project.ext {
+    packageProps = new groovy.json.JsonSlurper().parseText(new File("package.json").toURL().text)
+    failures = 0;
+    rhinoTestSrc = "out/rhino-test-${packageProps.version}.js"
+    testSrc = 'test/less'
+    testOut = 'out/test'
+}
+
+task runGruntRhino(type: GruntTask) {
+    gruntArgs = "rhino"
+}
+
+combineJs {
+	dependsOn runGruntRhino
+    source = ["dist/less-rhino-${packageProps.version}.js", "test/rhino/test-header.js","dist/lessc-rhino-${packageProps.version}.js"]
+    dest = file(rhinoTestSrc)
+}
+
+task testRhino(type: AllRhinoTests) {
+//      dependsOn 'testRhinoBase'
+    dependsOn 'testRhinoBase', 'testRhinoErrors', 'testRhinoLegacy', 'testRhinoStaticUrls', 'testRhinoCompression', 'testRhinoDebugAll', 'testRhinoDebugComments', 'testRhinoDebugMediaquery', 'testRhinoNoJsError', 'testRhinoSourceMap'
+}
+
+task testRhinoBase(type: RhinoTest) {
+    options = [ '--strict-math=true', '--relative-urls' ]
+}
+
+task testRhinoDebugAll(type: DebugRhinoTest) {
+    options = [ '--strict-math=true', '--line-numbers=all' ]
+    testDir = 'debug' + fs
+    suffix = "-all"
+}
+
+task testRhinoDebugComments(type: DebugRhinoTest) {
+    options = [ '--strict-math=true', '--line-numbers=comments' ]
+    testDir = 'debug' + fs
+    suffix = "-comments"
+}
+
+task testRhinoDebugMediaquery(type: DebugRhinoTest) {
+    options = [ '--strict-math=true', '--line-numbers=mediaquery' ]
+    testDir = 'debug' + fs
+    suffix = "-mediaquery"
+}
+
+task testRhinoErrors(type: RhinoTest) {
+    options = [ '--strict-math=true', '--strict-units=true' ]
+    testDir = 'errors/'
+    expectErrors = true
+}
+
+task testRhinoChyby(type: RhinoTest) {
+    options = [ '--strict-math=true', '--strict-units=true' ]
+    testDir = 'chyby/'
+   // expectErrors = true
+}
+
+task testRhinoNoJsError(type: RhinoTest) {
+    options = [ '--strict-math=true', '--strict-units=true', '--no-js' ]
+    testDir = 'no-js-errors/'
+    expectErrors = true
+}
+
+task testRhinoLegacy(type: RhinoTest) {
+    testDir = 'legacy/'
+}
+
+task testRhinoStaticUrls(type: RhinoTest) {
+    options = [ '--strict-math=true', '--rootpath=folder (1)/' ]
+    testDir = 'static-urls/'
+}
+
+task testRhinoCompression(type: RhinoTest) {
+    options = [ '--compress=true' ]
+    testDir = 'compression/'
+}
+
+task testRhinoSourceMap(type: SourceMapRhinoTest) {
+    options = [ '--strict-math=true', '--strict-units=true']
+    testDir = 'sourcemaps/'
+}
+
+task setupTest {
+	dependsOn combineJs
+    doLast {
+        file(testOut).deleteDir()
+    }
+}
+
+task clean << {
+    file(rhinoTestSrc).delete()
+    file(testOut).deleteDir()
+}
+
+class SourceMapRhinoTest extends RhinoTest {
+	
+	// helper to get the output map file
+	def getOutputMap(lessFile) {
+		def outFile = project.file(lessFile.path.replace('test/less', project.testOut).replace('.less', '.css'))
+		return project.file(outFile.path + ".map");
+	}
+	
+	// callback to add SourceMap options to the options list
+	def postProcessOptions(options, lessFile) {
+		def outFile = getOutputMap(lessFile)
+		project.file(outFile.parent).mkdirs()
+		options << "--source-map=${testDir}${lessFile.name.replace('.less','.css')}"
+		options << "--source-map-basepath=${lessRootDir}"
+		options << "--source-map-rootpath=testweb/"
+		options << "--source-map-output-map-file=${outFile}"
+
+		options
+	}
+	
+	// Callback to validate output
+	def handleResult(exec, out, lessFile) {
+		def actualFile = getOutputMap(lessFile)
+		def expectedFile = project.file(projectDir + fs + "test" + fs + testDir + fs + lessFile.name.replace(".less", ".json"))		
+		assert actualFile.text == expectedFile.text
+	}
+		
+}
+
+class DebugRhinoTest extends RhinoTest {
+
+    def escapeIt(it) {
+      return it.replaceAll("\\\\", "\\\\\\\\").replaceAll("/", "\\\\/").replaceAll(":", "\\\\:").replaceAll("\\.", "\\\\.");
+    }
+
+    def globalReplacements(input, directory) {
+      def pDirectory = toPlatformFs(directory)
+      def p = lessRootDir + fs + pDirectory 
+      def pathimport = p + toPlatformFs("import/")
+      def pathesc = escapeIt(p)
+      def pathimportesc = escapeIt(pathimport)
+      
+      def result = input.replace("{path}", p).replace("{pathesc}", pathesc).replace("{pathimport}", pathimport)
+      return result.replace("{pathimportesc}", pathimportesc).replace("\r\n", "\n")
+    }
+}
+
+class RhinoTest extends DefaultTask {
+
+    RhinoTest() {
+        dependsOn 'setupTest'
+    }
+
+    def suffix = ""
+    def testDir = ''
+    def options = []
+    def expectErrors = false
+    def fs = File.separator;
+    def projectDir = toUpperCaseDriveLetter(System.getProperty("user.dir"));
+    def lessRootDir = projectDir + fs + "test" + fs + "less"
+ 
+    def toUpperCaseDriveLetter(path) {
+      if (path.charAt(1)==':' && path.charAt(2)=='\\') {
+          return path.substring(0,1).toUpperCase() + path.substring(1);
+      } 
+      return path;
+    }
+
+    def toPlatformFs(path) {
+      return path.replace('\\', fs).replace('/', fs); 
+    }
+
+    def expectedCssPath(lessFilePath) {
+	  lessFilePath.replace('.less', "${suffix}.css").replace("${fs}less${fs}", "${fs}css${fs}");
+    }
+
+    def globalReplacements(input, directory) {
+      return input;
+    }
+
+    def stylize(str, style) {
+        def styles = [
+            reset     : [0,   0],
+            bold      : [1,  22],
+            inverse   : [7,  27],
+            underline : [4,  24],
+            yellow    : [33, 39],
+            green     : [32, 39],
+            red       : [31, 39],
+            grey      : [90, 39]
+        ];
+        return '\033[' + styles[style][0] + 'm' + str +
+                '\033[' + styles[style][1] + 'm';
+    }
+	
+	// Callback for subclasses to make any changes to the options
+	def postProcessOptions(options, lessFile) {
+		options
+	}
+	
+	// Callback to validate output
+	def handleResult(exec, out, lessFile) {
+		def actual = out.toString().trim()
+		def actualResult = project.file(lessFile.path.replace('test/less', project.testOut).replace('.less', '.css'))
+		project.file(actualResult.parent).mkdirs()
+		actualResult << actual
+		def expected
+		if (expectErrors) {
+			assert exec.exitValue != 0
+			expected = project.file(lessFile.path.replace('.less', '.txt')).text.trim().
+					replace('{path}', lessFile.parent + '/').
+					replace('{pathhref}', '').
+					replace('{404status}', '')
+		} else {
+			assert exec.exitValue == 0
+			def expectedFile = expectedCssPath(lessFile.path)
+			expected = project.file(expectedFile).text.trim()
+			expected = globalReplacements(expected, testDir)
+		}
+		actual=actual.trim()
+		actual = actual.replace('\r\n', '\n')
+		expected = expected.replace('\r\n', '\n')
+		actual = actual.replace("/","\\")
+		expected = expected.replace("/","\\")
+//                        println "* actual *"
+//                        println actual
+//                        new File("actual.txt").write(actual)
+//                        println "* expected *"
+//                        println expected
+//                        new File("expected.txt").write(expected)
+		assert actual == expected
+		actualResult.delete()
+
+	}
+
+    @TaskAction
+    def runTest() {
+        int testSuccesses = 0, testFailures = 0, testErrors = 0
+        project.file('test/less/' + testDir).eachFileMatch(FileType.FILES, ~/.*\.less/) { lessFile ->
+            println "lessfile: $lessFile"
+            if (!project.hasProperty('test') || lessFile.name.startsWith(project.test)) {
+                def out = new java.io.ByteArrayOutputStream()
+                def processedOptions = postProcessOptions([project.rhinoTestSrc, lessFile] + options, lessFile)
+                def execOptions = {
+                    main = 'org.mozilla.javascript.tools.shell.Main'
+//                    main = 'org.mozilla.javascript.tools.debugger.Main'
+                    classpath = project.configurations.rhino
+                    args = processedOptions
+                    standardOutput = out
+                    ignoreExitValue = true
+                }
+                println "rhinoTestSrc: ${project.rhinoTestSrc}" 
+                try {
+                    def exec = project.javaexec(execOptions)
+					handleResult(exec, out, lessFile)
+					testSuccesses++
+					println stylize('   ok', 'green')
+                }
+                catch (ex) {
+                    println ex
+                    println()
+                    testErrors++;
+                }
+                catch (AssertionError ae) {
+                    println stylize('   failed', 'red')
+                    println ae
+                    testFailures++
+                }
+            } else {
+                println stylize('   skipped', 'yellow')
+            }
+        }
+        println stylize(testSuccesses + ' ok', 'green')
+        println stylize(testFailures + ' assertion failed', testFailures == 0 ? 'green' : 'red')
+        println stylize(testErrors + ' errors', testErrors == 0 ? 'green' : 'red')
+        if (testFailures != 0 || testErrors != 0) {
+            project.failures++;
+        }
+    }
+}
+
+class AllRhinoTests extends DefaultTask {
+
+    AllRhinoTests() {
+    }
+
+    @TaskAction
+    def runTest() {
+       println stylize(project.failures + ' test suites failed', project.failures == 0 ? 'green' : 'red')
+    }
+
+    def stylize(str, style) {
+        def styles = [
+            reset     : [0,   0],
+            bold      : [1,  22],
+            inverse   : [7,  27],
+            underline : [4,  24],
+            yellow    : [33, 39],
+            green     : [32, 39],
+            red       : [31, 39],
+            grey      : [90, 39]
+        ];
+        return '\033[' + styles[style][0] + 'm' + str +
+                '\033[' + styles[style][1] + 'm';
+    }
+}
+
+class GruntTask extends Exec {
+    private String gruntExecutable = Os.isFamily(Os.FAMILY_WINDOWS) ? "grunt.cmd" : "grunt"
+    private String switches = "--no-color"
+
+    String gruntArgs = "" 
+
+    public GruntTask() {
+        super()
+        this.setExecutable(gruntExecutable)
+    }
+
+    public void setGruntArgs(String gruntArgs) {
+        this.args = "$switches $gruntArgs".trim().split(" ") as List
+    }
+}
+