less 2.2.2 → 2.6.0

data/lib/less/js/lib/less/rhino.js

@@ -1,22 +1,140 @@
-var name;
+/*jshint rhino:true, unused: false */
+/*global name:true, less, loadStyleSheet, os */
+
+function formatError(ctx, options) {
+    options = options || {};
+
+    var message = "";
+    var extract = ctx.extract;
+    var error = [];
+
+//    var stylize = options.color ? require('./lessc_helper').stylize : function (str) { return str; };
+    var stylize = function (str) { return str; };
+
+    // only output a stack if it isn't a less error
+    if (ctx.stack && !ctx.type) { return stylize(ctx.stack, 'red'); }
+
+    if (!ctx.hasOwnProperty('index') || !extract) {
+        return ctx.stack || ctx.message;
+    }
+
+    if (typeof(extract[0]) === 'string') {
+        error.push(stylize((ctx.line - 1) + ' ' + extract[0], 'grey'));
+    }
+
+    if (typeof(extract[1]) === 'string') {
+        var errorTxt = ctx.line + ' ';
+        if (extract[1]) {
+            errorTxt += extract[1].slice(0, ctx.column) +
+                    stylize(stylize(stylize(extract[1][ctx.column], 'bold') +
+                            extract[1].slice(ctx.column + 1), 'red'), 'inverse');
+        }
+        error.push(errorTxt);
+    }
+
+    if (typeof(extract[2]) === 'string') {
+        error.push(stylize((ctx.line + 1) + ' ' + extract[2], 'grey'));
+    }
+    error = error.join('\n') + stylize('', 'reset') + '\n';
+
+    message += stylize(ctx.type + 'Error: ' + ctx.message, 'red');
+    if (ctx.filename) {
+     message += stylize(' in ', 'red') + ctx.filename +
+            stylize(' on line ' + ctx.line + ', column ' + (ctx.column + 1) + ':', 'grey');
+    }
+
+    message += '\n' + error;
+
+    if (ctx.callLine) {
+        message += stylize('from ', 'red') + (ctx.filename || '') + '/n';
+        message += stylize(ctx.callLine, 'grey') + ' ' + ctx.callExtract + '/n';
+    }
+
+    return message;
+}
+
+function writeError(ctx, options) {
+    options = options || {};
+    if (options.silent) { return; }
+    print(formatError(ctx, options));
+}
 
 function loadStyleSheet(sheet, callback, reload, remaining) {
-    var sheetName = name.slice(0, name.lastIndexOf('/') + 1) + sheet.href;
-    var input = readFile(sheetName);
+    var endOfPath = Math.max(name.lastIndexOf('/'), name.lastIndexOf('\\')),
+        sheetName = name.slice(0, endOfPath + 1) + sheet.href,
+        contents = sheet.contents || {},
+        input = readFile(sheetName);
+
+    input = input.replace(/^\xEF\xBB\xBF/, '');
+        
+    contents[sheetName] = input;
+        
     var parser = new less.Parser({
-        paths: [sheet.href.replace(/[\w\.-]+$/, '')]
+        paths: [sheet.href.replace(/[\w\.-]+$/, '')],
+        contents: contents
     });
     parser.parse(input, function (e, root) {
         if (e) {
-            print("Error: " + e);
-            quit(1);
+            return writeError(e);
+        }
+        try {
+            callback(e, root, input, sheet, { local: false, lastModified: 0, remaining: remaining }, sheetName);
+        } catch(e) {
+            writeError(e);
         }
-        callback(root, sheet, { local: false, lastModified: 0, remaining: remaining });
     });
-
-    // callback({}, sheet, { local: true, remaining: remaining });
 }
 
+less.Parser.fileLoader = function (file, currentFileInfo, callback, env) {
+
+    var href = file;
+    if (currentFileInfo && currentFileInfo.currentDirectory && !/^\//.test(file)) {
+        href = less.modules.path.join(currentFileInfo.currentDirectory, file);
+    }
+
+    var path = less.modules.path.dirname(href);
+
+    var newFileInfo = {
+        currentDirectory: path + '/',
+        filename: href
+    };
+
+    if (currentFileInfo) {
+        newFileInfo.entryPath = currentFileInfo.entryPath;
+        newFileInfo.rootpath = currentFileInfo.rootpath;
+        newFileInfo.rootFilename = currentFileInfo.rootFilename;
+        newFileInfo.relativeUrls = currentFileInfo.relativeUrls;
+    } else {
+        newFileInfo.entryPath = path;
+        newFileInfo.rootpath = less.rootpath || path;
+        newFileInfo.rootFilename = href;
+        newFileInfo.relativeUrls = env.relativeUrls;
+    }
+
+    var j = file.lastIndexOf('/');
+    if(newFileInfo.relativeUrls && !/^(?:[a-z-]+:|\/)/.test(file) && j != -1) {
+        var relativeSubDirectory = file.slice(0, j+1);
+        newFileInfo.rootpath = newFileInfo.rootpath + relativeSubDirectory; // append (sub|sup) directory path of imported file
+    }
+    newFileInfo.currentDirectory = path;
+    newFileInfo.filename = href;
+
+    var data = null;
+    try {
+        data = readFile(href);
+    } catch (e) {
+        callback({ type: 'File', message: "'" + less.modules.path.basename(href) + "' wasn't found" });
+        return;
+    }
+
+    try {
+        callback(null, data, href, newFileInfo, { lastModified: 0 });
+    } catch (e) {
+        callback(e, null, href);
+    }
+};
+
+
 function writeFile(filename, content) {
     var fstream = new java.io.FileWriter(filename);
     var out = new java.io.BufferedWriter(fstream);
@@ -26,37 +144,305 @@ function writeFile(filename, content) {
 
 // Command line integration via Rhino
 (function (args) {
-    name = args[0];
+
+    var options = {
+        depends: false,
+        compress: false,
+        cleancss: false,
+        max_line_len: -1,
+        optimization: 1,
+        silent: false,
+        verbose: false,
+        lint: false,
+        paths: [],
+        color: true,
+        strictImports: false,
+        rootpath: '',
+        relativeUrls: false,
+        ieCompat: true,
+        strictMath: false,
+        strictUnits: false
+    };
+    var continueProcessing = true,
+            currentErrorcode;
+
+    var checkArgFunc = function(arg, option) {
+        if (!option) {
+            print(arg + " option requires a parameter");
+            continueProcessing = false;
+            return false;
+        }
+        return true;
+    };
+
+    var checkBooleanArg = function(arg) {
+        var onOff = /^((on|t|true|y|yes)|(off|f|false|n|no))$/i.exec(arg);
+        if (!onOff) {
+            print(" 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 warningMessages = "";
+    var sourceMapFileInline = false;
+
+    args = args.filter(function (arg) {
+        var 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]; } // was (?:=([^\s]*)), check!
+        else { return arg; }
+
+        switch (arg) {
+            case 'v':
+            case 'version':
+                console.log("lessc " + less.version.join('.') + " (LESS Compiler) [JavaScript]");
+                continueProcessing = false;
+                break;
+            case 'verbose':
+                options.verbose = true;
+                break;
+            case 's':
+            case 'silent':
+                options.silent = true;
+                break;
+            case 'l':
+            case 'lint':
+                options.lint = true;
+                break;
+            case 'strict-imports':
+                options.strictImports = true;
+                break;
+            case 'h':
+            case 'help':
+                    //TODO
+//                require('../lib/less/lessc_helper').printUsage();
+                continueProcessing = false;
+                break;
+            case 'x':
+            case 'compress':
+                options.compress = true;
+                break;
+            case 'M':
+            case 'depends':
+                options.depends = true;
+                break;
+            case 'yui-compress':
+                warningMessages += "yui-compress option has been removed. assuming clean-css.";
+                options.cleancss = true;
+                break;
+            case 'clean-css':
+                options.cleancss = 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);
+                                    return p;
+                                }
+                            });
+                }
+                break;
+            case 'O0': options.optimization = 0; break;
+            case 'O1': options.optimization = 1; break;
+            case 'O2': options.optimization = 2; break;
+            case 'line-numbers':
+                if (checkArgFunc(arg, match[2])) {
+                    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 'source-map-output-map-file':
+                if (checkArgFunc(arg, match[2])) {
+                    options.writeSourceMap = function(sourceMapContent) {
+                         writeFile(match[2], sourceMapContent);
+                    };
+                }
+            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;
+            default:
+                console.log('invalid option ' + arg);
+                continueProcessing = false;
+        }
+    });
+
+    if (!continueProcessing) {
+        return;
+    }
+
+    var name = args[0];
+    if (name && name != '-') {
+//        name = path.resolve(process.cwd(), name);
+    }
     var output = args[1];
+    var outputbase = args[1];
+    if (output) {
+        options.sourceMapOutputFilename = output;
+//        output = path.resolve(process.cwd(), output);
+        if (warningMessages) {
+            console.log(warningMessages);
+        }
+    }
+
+//  options.sourceMapBasepath = process.cwd();
+//    options.sourceMapBasepath = '';
+
+    if (options.sourceMap === true) {
+        console.log("output: " + output);
+        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 = less.modules.path.basename(options.sourceMapFullFilename);
+    } else if (options.sourceMap) {
+        options.sourceMapOutputFilename = options.sourceMap;
+    }
+    
+
+    if (!name) {
+        console.log("lessc: no inout files");
+        console.log("");
+        // TODO
+//        require('../lib/less/lessc_helper').printUsage();
+        currentErrorcode = 1;
+        return;
+    }
+
+//    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.depends) {
+        if (!outputbase) {
+            console.log("option --depends requires an output path to be specified");
+            return;
+        }
+        console.log(outputbase + ": ");
+    }
 
     if (!name) {
-        print('No files present in the fileset; Check your pattern match in build.xml');
+        console.log('No files present in the fileset');
         quit(1);
     }
-    path = name.split("/");path.pop();path=path.join("/")
 
-    var input = readFile(name);
+    var input = null;
+    try {
+        input = readFile(name, 'utf-8');
 
-    if (!input) {
-        print('lesscss: couldn\'t open file ' + name);
+    } catch (e) {
+        console.log('lesscss: couldn\'t open file ' + name);
         quit(1);
     }
 
+    options.filename = name;
     var result;
-    var parser = new less.Parser();
-    parser.parse(input, function (e, root) {
-        if (e) {
-            quit(1);
-        } else {
-            result = root.toCSS();
-            if (output) {
-                writeFile(output, result);
-                print("Written to " + output);
+    try {
+        var parser = new less.Parser(options);
+        parser.parse(input, function (e, root) {
+            if (e) {
+                writeError(e, options);
+                quit(1);
             } else {
-                print(result);
+                result = root.toCSS(options);
+                if (output) {
+                    writeFile(output, result);
+                    console.log("Written to " + output);
+                } else {
+                    print(result);
+                }
+                quit(0);
             }
-            quit(0);
-        }
-    });
-    print("done");
+        });
+    }
+    catch(e) {
+        writeError(e, options);
+        quit(1);
+    }
+    console.log("done");
 }(arguments));

data/lib/less/js/lib/less/source-map-output.js

@@ -0,0 +1,141 @@
+(function (tree) {
+
+    tree.sourceMapOutput = function (options) {
+        this._css = [];
+        this._rootNode = options.rootNode;
+        this._writeSourceMap = options.writeSourceMap;
+        this._contentsMap = options.contentsMap;
+        this._contentsIgnoredCharsMap = options.contentsIgnoredCharsMap;
+        this._sourceMapFilename = options.sourceMapFilename;
+        this._outputFilename = options.outputFilename;
+        this._sourceMapURL = options.sourceMapURL;
+        if (options.sourceMapBasepath) {
+            this._sourceMapBasepath = options.sourceMapBasepath.replace(/\\/g, '/');
+        }
+        this._sourceMapRootpath = options.sourceMapRootpath;
+        this._outputSourceFiles = options.outputSourceFiles;
+        this._sourceMapGeneratorConstructor = options.sourceMapGenerator || require("source-map").SourceMapGenerator;
+
+        if (this._sourceMapRootpath && this._sourceMapRootpath.charAt(this._sourceMapRootpath.length-1) !== '/') {
+            this._sourceMapRootpath += '/';
+        }
+
+        this._lineNumber = 0;
+        this._column = 0;
+    };
+
+    tree.sourceMapOutput.prototype.normalizeFilename = function(filename) {
+        filename = filename.replace(/\\/g, '/');
+
+        if (this._sourceMapBasepath && filename.indexOf(this._sourceMapBasepath) === 0) {
+            filename = filename.substring(this._sourceMapBasepath.length);
+            if (filename.charAt(0) === '\\' || filename.charAt(0) === '/') {
+               filename = filename.substring(1);
+            }
+        }
+        return (this._sourceMapRootpath || "") + filename;
+    };
+
+    tree.sourceMapOutput.prototype.add = function(chunk, fileInfo, index, mapLines) {
+
+        //ignore adding empty strings
+        if (!chunk) {
+            return;
+        }
+
+        var lines,
+            sourceLines,
+            columns,
+            sourceColumns,
+            i;
+
+        if (fileInfo) {
+            var inputSource = this._contentsMap[fileInfo.filename];
+            
+            // remove vars/banner added to the top of the file
+            if (this._contentsIgnoredCharsMap[fileInfo.filename]) {
+                // adjust the index
+                index -= this._contentsIgnoredCharsMap[fileInfo.filename];
+                if (index < 0) { index = 0; }
+                // adjust the source
+                inputSource = inputSource.slice(this._contentsIgnoredCharsMap[fileInfo.filename]);
+            }
+            inputSource = inputSource.substring(0, index);
+            sourceLines = inputSource.split("\n");
+            sourceColumns = sourceLines[sourceLines.length-1];
+        }
+
+        lines = chunk.split("\n");
+        columns = lines[lines.length-1];
+
+        if (fileInfo) {
+            if (!mapLines) {
+                this._sourceMapGenerator.addMapping({ generated: { line: this._lineNumber + 1, column: this._column},
+                    original: { line: sourceLines.length, column: sourceColumns.length},
+                    source: this.normalizeFilename(fileInfo.filename)});
+            } else {
+                for(i = 0; i < lines.length; i++) {
+                    this._sourceMapGenerator.addMapping({ generated: { line: this._lineNumber + i + 1, column: i === 0 ? this._column : 0},
+                        original: { line: sourceLines.length + i, column: i === 0 ? sourceColumns.length : 0},
+                        source: this.normalizeFilename(fileInfo.filename)});
+                }
+            }
+        }
+
+        if (lines.length === 1) {
+            this._column += columns.length;
+        } else {
+            this._lineNumber += lines.length - 1;
+            this._column = columns.length;
+        }
+
+        this._css.push(chunk);
+    };
+
+    tree.sourceMapOutput.prototype.isEmpty = function() {
+        return this._css.length === 0;
+    };
+
+    tree.sourceMapOutput.prototype.toCSS = function(env) {
+        this._sourceMapGenerator = new this._sourceMapGeneratorConstructor({ file: this._outputFilename, sourceRoot: null });
+
+        if (this._outputSourceFiles) {
+            for(var filename in this._contentsMap) {
+                if (this._contentsMap.hasOwnProperty(filename))
+                {
+                    var source = this._contentsMap[filename];
+                    if (this._contentsIgnoredCharsMap[filename]) {
+                        source = source.slice(this._contentsIgnoredCharsMap[filename]);
+                    }
+                    this._sourceMapGenerator.setSourceContent(this.normalizeFilename(filename), source);
+                }
+            }
+        }
+
+        this._rootNode.genCSS(env, this);
+
+        if (this._css.length > 0) {
+            var sourceMapURL,
+                sourceMapContent = JSON.stringify(this._sourceMapGenerator.toJSON());
+
+            if (this._sourceMapURL) {
+                sourceMapURL = this._sourceMapURL;
+            } else if (this._sourceMapFilename) {
+                sourceMapURL = this.normalizeFilename(this._sourceMapFilename);
+            }
+
+            if (this._writeSourceMap) {
+                this._writeSourceMap(sourceMapContent);
+            } else {
+                sourceMapURL = "data:application/json," + encodeURIComponent(sourceMapContent);
+            }
+
+            if (sourceMapURL) {
+                this._css.push("/*# sourceMappingURL=" + sourceMapURL + " */");
+            }
+        }
+
+        return this._css.join('');
+    };
+
+})(require('./tree'));