less 2.1.2 → 2.4.0

package/bin/lessc

@@ -3,8 +3,15 @@
 var path = require('path'),
     fs = require('../lib/less-node/fs'),
     os = require('os'),
+    errno,
     mkdirp;
 
+try {
+    errno = require('errno');
+} catch (err) {
+    errno = null;
+}
+
 var less = require('../lib/less-node'),
     pluginLoader = new less.PluginLoader(less),
     plugin,
@@ -27,8 +34,8 @@ var silent = false,
     ieCompat: true,
     strictMath: false,
     strictUnits: false,
-    globalVariables: '',
-    modifyVariables: '',
+    globalVars: null,
+    modifyVars: null,
     urlArgs: '',
     plugins: plugins
 };
@@ -52,16 +59,16 @@ 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) {
-        console.log(" 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 parseVariableOption = function(option, variables) {
     var parts = option.split('=', 2);
-    return '@' + parts[0] + ': ' + parts[1] + ';\n';
+    variables[parts[0]] = parts[1];
 };
 
 var warningMessages = "";
@@ -73,351 +80,411 @@ function printUsage() {
     continueProcessing = false;
 }
 
-args = args.filter(function (arg) {
-    var match;
+// self executing function so we can return
+(function() {
+    args = args.filter(function (arg) {
+        var match;
 
-    match = arg.match(/^-I(.+)$/);
-    if (match) {
-        options.paths.push(match[1]);
-        return false;
-    }
+        match = arg.match(/^-I(.+)$/);
+        if (match) {
+            options.paths.push(match[1]);
+            return false;
+        }
 
-    match = arg.match(/^--?([a-z][0-9a-z-]*)(?:=(.*))?$/i);
-    if (match) { arg = match[1]; }
-    else { return arg; }
-
-    switch (arg) {
-        case 'v':
-        case 'version':
-            console.log("lessc " + less.version.join('.') + " (Less Compiler) [JavaScript]");
-            continueProcessing = false;
-            break;
-        case 'verbose':
-            verbose = true;
-            break;
-        case 's':
-        case 'silent':
-            silent = true;
-            break;
-        case 'l':
-        case 'lint':
-            options.lint = true;
-            break;
-        case 'strict-imports':
-            options.strictImports = true;
-            break;
-        case 'h':
-        case 'help':
-            printUsage();
-            break;
-        case 'x':
-        case 'compress':
-            options.compress = true;
-            break;
-        case 'insecure':
-            options.insecure = true;
-            break;
-        case 'M':
-        case 'depends':
-            options.depends = true;
-            break;
-        case 'max-line-len':
-            if (checkArgFunc(arg, match[2])) {
-                options.maxLineLen = parseInt(match[2], 10);
-                if (options.maxLineLen <= 0) {
-                  options.maxLineLen = -1;
-                }
-            }
-            break;
-        case 'no-color':
-            options.color = false;
-            break;
-        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/) ? ';' : ':')
-                    .map(function(p) {
-                        if (p) {
-                            return path.resolve(process.cwd(), p);
-                        }
-                    });
-            }
-            break;
-        case 'line-numbers':
-            if (checkArgFunc(arg, match[2])) {
-                options.dumpLineNumbers = match[2];
-            }
-            break;
-        case 'source-map':
-            options.sourceMap = true;
-            if (match[2]) {
-                sourceMapOptions.sourceMapFullFilename = match[2];
-            }
-            break;
-        case 'source-map-rootpath':
-            if (checkArgFunc(arg, match[2])) {
-                sourceMapOptions.sourceMapRootpath = match[2];
-            }
-            break;
-        case 'source-map-basepath':
-            if (checkArgFunc(arg, match[2])) {
-                sourceMapOptions.sourceMapBasepath = match[2];
-            }
-            break;
-        case 'source-map-map-inline':
-            sourceMapFileInline = true;
-            options.sourceMap = true;
-            break;
-        case 'source-map-less-inline':
-            sourceMapOptions.outputSourceFiles = true;
-            break;
-        case 'source-map-url':
-            if (checkArgFunc(arg, match[2])) {
-                sourceMapOptions.sourceMapURL = match[2];
-            }
-            break;
-        case 'rp':
-        case 'rootpath':
-            if (checkArgFunc(arg, match[2])) {
-                options.rootpath = match[2].replace(/\\/g, '/');
-            }
-            break;
-        case "ru":
-        case "relative-urls":
-            options.relativeUrls = true;
-            break;
-        case "sm":
-        case "strict-math":
-            if (checkArgFunc(arg, match[2])) {
-                options.strictMath = checkBooleanArg(match[2]);
-            }
-            break;
-        case "su":
-        case "strict-units":
-            if (checkArgFunc(arg, match[2])) {
-                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 'url-args':
-            if (checkArgFunc(arg, match[2])) {
-                options.urlArgs = match[2];
-            }
-            break;
-        case 'plugin':
-            var splitupArg = match[2].match(/^([^=]+)(=(.*))?/),
-                name = splitupArg[1],
-                pluginOptions = splitupArg[3];
-
-            plugin = pluginLoader.tryLoadPlugin(name, pluginOptions);
-            if (plugin) {
-                plugins.push(plugin);
-            } else {
-                console.log("Unable to load plugin " + name + " please make sure that it is installed under or at the same level as less");
-                console.log();
-                printUsage();
-                currentErrorcode = 1;
-            }
-            break;
-        default:
-            plugin = pluginLoader.tryLoadPlugin("less-plugin-" + arg, match[2]);
-            if (plugin) {
-                plugins.push(plugin);
-            } else {
-                console.log("Unable to interpret argument " + arg + " - if it is a plugin (less-plugin-" + arg + "), make sure that it is installed under or at the same level as less");
-                console.log();
+        match = arg.match(/^--?([a-z][0-9a-z-]*)(?:=(.*))?$/i);
+        if (match) {
+            arg = match[1];
+        } else {
+            return arg;
+        }
+
+        switch (arg) {
+            case 'v':
+            case 'version':
+                console.log("lessc " + less.version.join('.') + " (Less Compiler) [JavaScript]");
+                continueProcessing = false;
+                break;
+            case 'verbose':
+                verbose = true;
+                break;
+            case 's':
+            case 'silent':
+                silent = true;
+                break;
+            case 'l':
+            case 'lint':
+                options.lint = true;
+                break;
+            case 'strict-imports':
+                options.strictImports = true;
+                break;
+            case 'h':
+            case 'help':
                 printUsage();
-                currentErrorcode = 1;
-            }
-            break;
-    }
-});
+                break;
+            case 'x':
+            case 'compress':
+                options.compress = true;
+                break;
+            case 'insecure':
+                options.insecure = true;
+                break;
+            case 'M':
+            case 'depends':
+                options.depends = true;
+                break;
+            case 'max-line-len':
+                if (checkArgFunc(arg, match[2])) {
+                    options.maxLineLen = parseInt(match[2], 10);
+                    if (options.maxLineLen <= 0) {
+                        options.maxLineLen = -1;
+                    }
+                }
+                break;
+            case 'no-color':
+                options.color = false;
+                break;
+            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/) ? ';' : ':')
+                        .map(function(p) {
+                            if (p) {
+                                return path.resolve(process.cwd(), p);
+                            }
+                        });
+                }
+                break;
+            case 'line-numbers':
+                if (checkArgFunc(arg, match[2])) {
+                    options.dumpLineNumbers = match[2];
+                }
+                break;
+            case 'source-map':
+                options.sourceMap = true;
+                if (match[2]) {
+                    sourceMapOptions.sourceMapFullFilename = match[2];
+                }
+                break;
+            case 'source-map-rootpath':
+                if (checkArgFunc(arg, match[2])) {
+                    sourceMapOptions.sourceMapRootpath = match[2];
+                }
+                break;
+            case 'source-map-basepath':
+                if (checkArgFunc(arg, match[2])) {
+                    sourceMapOptions.sourceMapBasepath = match[2];
+                }
+                break;
+            case 'source-map-map-inline':
+                sourceMapFileInline = true;
+                options.sourceMap = true;
+                break;
+            case 'source-map-less-inline':
+                sourceMapOptions.outputSourceFiles = true;
+                break;
+            case 'source-map-url':
+                if (checkArgFunc(arg, match[2])) {
+                    sourceMapOptions.sourceMapURL = match[2];
+                }
+                break;
+            case 'rp':
+            case 'rootpath':
+                if (checkArgFunc(arg, match[2])) {
+                    options.rootpath = match[2].replace(/\\/g, '/');
+                }
+                break;
+            case "ru":
+            case "relative-urls":
+                options.relativeUrls = true;
+                break;
+            case "sm":
+            case "strict-math":
+                if (checkArgFunc(arg, match[2])) {
+                    options.strictMath = checkBooleanArg(match[2]);
+                }
+                break;
+            case "su":
+            case "strict-units":
+                if (checkArgFunc(arg, match[2])) {
+                    options.strictUnits = checkBooleanArg(match[2]);
+                }
+                break;
+            case "global-var":
+                if (checkArgFunc(arg, match[2])) {
+                    if (!options.globalVars) {
+                        options.globalVars = {};
+                    }
+                    parseVariableOption(match[2], options.globalVars);
+                }
+                break;
+            case "modify-var":
+                if (checkArgFunc(arg, match[2])) {
+                    if (!options.modifyVars) {
+                        options.modifyVars = {};
+                    }
 
-if (!continueProcessing) {
-    return;
-}
+                    parseVariableOption(match[2], options.modifyVars);
+                }
+                break;
+            case 'url-args':
+                if (checkArgFunc(arg, match[2])) {
+                    options.urlArgs = match[2];
+                }
+                break;
+            case 'plugin':
+                var splitupArg = match[2].match(/^([^=]+)(=(.*))?/),
+                    name = splitupArg[1],
+                    pluginOptions = splitupArg[3];
+
+                plugin = pluginLoader.tryLoadPlugin(name, pluginOptions);
+                if (plugin) {
+                    plugins.push(plugin);
+                } else {
+                    console.log("Unable to load plugin " + name +
+                        " please make sure that it is installed under or at the same level as less");
+                    console.log();
+                    printUsage();
+                    currentErrorcode = 1;
+                }
+                break;
+            default:
+                plugin = pluginLoader.tryLoadPlugin("less-plugin-" + arg, match[2]);
+                if (plugin) {
+                    plugins.push(plugin);
+                } else {
+                    console.log("Unable to interpret argument " + arg +
+                        " - if it is a plugin (less-plugin-" + arg + "), make sure that it is installed under or at" +
+                        " the same level as less");
+                    console.log();
+                    printUsage();
+                    currentErrorcode = 1;
+                }
+                break;
+        }
+    });
 
-var input = args[1];
-if (input && input != '-') {
-    input = path.resolve(process.cwd(), input);
-}
-var output = args[2];
-var outputbase = args[2];
-if (output) {
-    output = path.resolve(process.cwd(), output);
-    if (warningMessages) {
-        console.log(warningMessages);
+    if (!continueProcessing) {
+        return;
     }
-}
 
-if (options.sourceMap) {
-
-    sourceMapOptions.sourceMapInputFilename = input;
-    if (!sourceMapOptions.sourceMapFullFilename) {
-        if (!output && !sourceMapFileInline) {
-            console.log("the sourcemap option only has an optional filename if the css filename is given");
-            console.log("consider adding --source-map-map-inline which embeds the sourcemap into the css");
-            return;
+    var input = args[1];
+    if (input && input != '-') {
+        input = path.resolve(process.cwd(), input);
+    }
+    var output = args[2];
+    var outputbase = args[2];
+    if (output) {
+        output = path.resolve(process.cwd(), output);
+        if (warningMessages) {
+            console.log(warningMessages);
         }
-        // its in the same directory, so always just the basename
-        sourceMapOptions.sourceMapOutputFilename = path.basename(output);
-        sourceMapOptions.sourceMapFullFilename = output + ".map";
-        // its in the same directory, so always just the basename
-        sourceMapOptions.sourceMapFilename = path.basename(sourceMapOptions.sourceMapFullFilename);
-    } else if (options.sourceMap && !sourceMapFileInline) {
-        var mapFilename = path.resolve(process.cwd(), sourceMapOptions.sourceMapFullFilename),
-            mapDir = path.dirname(mapFilename),
-            outputDir = path.dirname(output);
-        // find the path from the map to the output file
-        sourceMapOptions.sourceMapOutputFilename = path.join(
-            path.relative(mapDir, outputDir), path.basename(output));
-
-        // make the sourcemap filename point to the sourcemap relative to the css file output directory
-        sourceMapOptions.sourceMapFilename = path.join(
-            path.relative(outputDir, mapDir), path.basename(sourceMapOptions.sourceMapFullFilename));
     }
-}
 
-if (sourceMapOptions.sourceMapBasepath === undefined) {
-    sourceMapOptions.sourceMapBasepath = input ? path.dirname(input) : process.cwd();
-}
-
-if (sourceMapOptions.sourceMapRootpath === undefined) {
-    var pathToMap = path.dirname(sourceMapFileInline ? output : sourceMapOptions.sourceMapFullFilename),
-        pathToInput = path.dirname(sourceMapOptions.sourceMapInputFilename);
-    sourceMapOptions.sourceMapRootpath = path.relative(pathToMap, pathToInput);
-}
-
-
-if (! input) {
-    console.log("lessc: no input files");
-    console.log("");
-    printUsage();
-    currentErrorcode = 1;
-    return;
-}
+    if (options.sourceMap) {
 
-var ensureDirectory = function (filepath) {
-    var dir = path.dirname(filepath),
-        cmd,
-        existsSync = fs.existsSync || path.existsSync;
-    if (!existsSync(dir)) {
-        if (mkdirp === undefined) {
-            try {mkdirp = require('mkdirp');}
-            catch(e) { mkdirp = null; }
+        sourceMapOptions.sourceMapInputFilename = input;
+        if (!sourceMapOptions.sourceMapFullFilename) {
+            if (!output && !sourceMapFileInline) {
+                console.log("the sourcemap option only has an optional filename if the css filename is given");
+                console.log("consider adding --source-map-map-inline which embeds the sourcemap into the css");
+                return;
+            }
+            // its in the same directory, so always just the basename
+            sourceMapOptions.sourceMapOutputFilename = path.basename(output);
+            sourceMapOptions.sourceMapFullFilename = output + ".map";
+            // its in the same directory, so always just the basename
+            sourceMapOptions.sourceMapFilename = path.basename(sourceMapOptions.sourceMapFullFilename);
+        } else if (options.sourceMap && !sourceMapFileInline) {
+            var mapFilename = path.resolve(process.cwd(), sourceMapOptions.sourceMapFullFilename),
+                mapDir = path.dirname(mapFilename),
+                outputDir = path.dirname(output);
+            // find the path from the map to the output file
+            sourceMapOptions.sourceMapOutputFilename = path.join(
+                path.relative(mapDir, outputDir), path.basename(output));
+
+            // make the sourcemap filename point to the sourcemap relative to the css file output directory
+            sourceMapOptions.sourceMapFilename = path.join(
+                path.relative(outputDir, mapDir), path.basename(sourceMapOptions.sourceMapFullFilename));
         }
-        cmd = mkdirp && mkdirp.sync || fs.mkdirSync;
-        cmd(dir);
     }
-};
 
-if (options.depends) {
-    if (!outputbase) {
-        console.log("option --depends requires an output path to be specified");
-        return;
+    if (sourceMapOptions.sourceMapBasepath === undefined) {
+        sourceMapOptions.sourceMapBasepath = input ? path.dirname(input) : process.cwd();
     }
-    process.stdout.write(outputbase + ": ");
-}
 
-if (!sourceMapFileInline) {
-    var writeSourceMap = function(output) {
-        var filename = sourceMapOptions.sourceMapFullFilename;
-        ensureDirectory(filename);
-        fs.writeFileSync(filename, output, 'utf8');
-    };
-}
+    if (sourceMapOptions.sourceMapRootpath === undefined) {
+        var pathToMap = path.dirname(sourceMapFileInline ? output : sourceMapOptions.sourceMapFullFilename),
+            pathToInput = path.dirname(sourceMapOptions.sourceMapInputFilename);
+        sourceMapOptions.sourceMapRootpath = path.relative(pathToMap, pathToInput);
+    }
 
-var parseLessFile = function (e, data) {
-    if (e) {
-        console.log("lessc: " + e.message);
+    if (! input) {
+        console.log("lessc: no input files");
+        console.log("");
+        printUsage();
         currentErrorcode = 1;
         return;
     }
 
-    data = options.globalVariables + data + '\n' + options.modifyVariables;
-
-    options.paths = [path.dirname(input)].concat(options.paths);
-    options.filename = input;
+    var ensureDirectory = function (filepath) {
+        var dir = path.dirname(filepath),
+            cmd,
+            existsSync = fs.existsSync || path.existsSync;
+        if (!existsSync(dir)) {
+            if (mkdirp === undefined) {
+                try {mkdirp = require('mkdirp');}
+                catch(e) { mkdirp = null; }
+            }
+            cmd = mkdirp && mkdirp.sync || fs.mkdirSync;
+            cmd(dir);
+        }
+    };
 
-    if (options.lint) {
-        options.sourceMap = false;
+    if (options.depends) {
+        if (!outputbase) {
+            console.log("option --depends requires an output path to be specified");
+            return;
+        }
+        process.stdout.write(outputbase + ": ");
     }
-    sourceMapOptions.sourceMapFileInline = sourceMapFileInline;
 
-    if (options.sourceMap) {
-        options.sourceMap = sourceMapOptions;
+    if (!sourceMapFileInline) {
+        var writeSourceMap = function(output, onDone) {
+            var filename = sourceMapOptions.sourceMapFullFilename;
+            ensureDirectory(filename);
+            fs.writeFile(filename, output, 'utf8', function (err) {
+                if (err) {
+                    var description = "Error: ";
+                    if (errno && errno.errno[err.errno]) {
+                        description += errno.errno[err.errno].description;
+                    } else {
+                        description += err.code + " " + err.message;
+                    }
+                    less.logger.error('lessc: failed to create file ' + filename);
+                    less.logger.error(description);
+                } else {
+                    less.logger.info('lessc: wrote ' + filename);
+                }
+                onDone();
+            });
+        };
     }
 
-    less.logger.addListener({
-        info: function(msg) {
-            if (verbose) {
-                console.log(msg);
-            }
-        },
-        warn: function(msg) {
-            if (!silent) {
-                console.warn(msg);
-            }
-        },
-        error: function(msg) {
-            console.log(msg);
+    var writeSourceMapIfNeeded = function(output, onDone) {
+        if (options.sourceMap && !sourceMapFileInline) {
+            writeSourceMap(output, onDone);
+        } else {
+            onDone();
         }
-    });
+    };
 
-    less.render(data, options)
-        .then(function(result) {
-            if(!options.lint) {
-                if (output) {
-                    ensureDirectory(output);
-                    fs.writeFileSync(output, result.css, 'utf8');
+    var writeOutput = function(output, result, onSuccess) {
+        if (output) {
+            ensureDirectory(output);
+            fs.writeFile(output, result.css, {encoding: 'utf8'}, function (err) {
+                if (err) {
+                    var description = "Error: ";
+                    if (errno && errno.errno[err.errno]) {
+                        description += errno.errno[err.errno].description;
+                    } else {
+                        description += err.code + " " + err.message;
+                    }
+                    less.logger.error('lessc: failed to create file ' + output);
+                    less.logger.error(description);
+                } else {
                     less.logger.info('lessc: wrote ' + output);
-                } else if (!options.depends) {
-                    process.stdout.write(result.css);
+                    onSuccess();
                 }
-                if (options.sourceMap && !sourceMapFileInline) {
-                    writeSourceMap(result.map);
+            });
+        } else if (!options.depends) {
+            process.stdout.write(result.css);
+            onSuccess();
+        }
+    };
+
+    var logDependencies = function(options, result) {
+        if (options.depends) {
+            var depends = "";
+            for (var i = 0; i < result.imports.length; i++) {
+                depends += result.imports[i] + " ";
+            }
+            console.log(depends);
+        }
+    };
+
+    var parseLessFile = function (e, data) {
+        if (e) {
+            console.log("lessc: " + e.message);
+            currentErrorcode = 1;
+            return;
+        }
+
+        data = data.replace(/^\uFEFF/, '');
+
+        options.paths = [path.dirname(input)].concat(options.paths);
+        options.filename = input;
+
+        if (options.lint) {
+            options.sourceMap = false;
+        }
+        sourceMapOptions.sourceMapFileInline = sourceMapFileInline;
+
+        if (options.sourceMap) {
+            options.sourceMap = sourceMapOptions;
+        }
+
+        less.logger.addListener({
+            info: function(msg) {
+                if (verbose) {
+                    console.log(msg);
                 }
-                if (options.depends) {
-                    var depends = "";
-                    for(var i = 0; i < result.imports.length; i++) {
-                        depends += result.imports[i] + " ";
-                    }
-                    console.log(depends);
+            },
+            warn: function(msg) {
+                // do not show warning if outputting css to the console or the silent option is used
+                if (!silent && output) {
+                    console.warn(msg);
                 }
+            },
+            error: function(msg) {
+                console.log(msg);
             }
-        },
-        function(err) {
-            less.writeError(err, options);
-            currentErrorcode = 1;
         });
-};
 
-if (input != '-') {
-    fs.readFile(input, 'utf8', parseLessFile);
-} else {
-    process.stdin.resume();
-    process.stdin.setEncoding('utf8');
+        less.render(data, options)
+            .then(function(result) {
+                if (!options.lint) {
+                    writeOutput(output, result, function() {
+                        writeSourceMapIfNeeded(result.map, function() {
+                            logDependencies(options, result);
+                        });
+                    });
+                }
+            },
+            function(err) {
+                less.writeError(err, options);
+                currentErrorcode = 1;
+            });
+    };
+
+    if (input != '-') {
+        fs.readFile(input, 'utf8', parseLessFile);
+    } else {
+        process.stdin.resume();
+        process.stdin.setEncoding('utf8');
 
-    var buffer = '';
-    process.stdin.on('data', function(data) {
-        buffer += data;
-    });
+        var buffer = '';
+        process.stdin.on('data', function(data) {
+            buffer += data;
+        });
 
-    process.stdin.on('end', function() {
-        parseLessFile(false, buffer);
-    });
-}
+        process.stdin.on('end', function() {
+            parseLessFile(false, buffer);
+        });
+    }
+})();