less 2.2.2 → 2.6.0

data/lib/less/js/lib/less/import-visitor.js

@@ -0,0 +1,142 @@
+(function (tree) {
+    tree.importVisitor = function(importer, finish, evalEnv, onceFileDetectionMap, recursionDetector) {
+        this._visitor = new tree.visitor(this);
+        this._importer = importer;
+        this._finish = finish;
+        this.env = evalEnv || new tree.evalEnv();
+        this.importCount = 0;
+        this.onceFileDetectionMap = onceFileDetectionMap || {};
+        this.recursionDetector = {};
+        if (recursionDetector) {
+            for(var fullFilename in recursionDetector) {
+                if (recursionDetector.hasOwnProperty(fullFilename)) {
+                    this.recursionDetector[fullFilename] = true;
+                }
+            }
+        }
+    };
+
+    tree.importVisitor.prototype = {
+        isReplacing: true,
+        run: function (root) {
+            var error;
+            try {
+                // process the contents
+                this._visitor.visit(root);
+            }
+            catch(e) {
+                error = e;
+            }
+
+            this.isFinished = true;
+
+            if (this.importCount === 0) {
+                this._finish(error);
+            }
+        },
+        visitImport: function (importNode, visitArgs) {
+            var importVisitor = this,
+                evaldImportNode,
+                inlineCSS = importNode.options.inline;
+            
+            if (!importNode.css || inlineCSS) {
+
+                try {
+                    evaldImportNode = importNode.evalForImport(this.env);
+                } catch(e){
+                    if (!e.filename) { e.index = importNode.index; e.filename = importNode.currentFileInfo.filename; }
+                    // attempt to eval properly and treat as css
+                    importNode.css = true;
+                    // if that fails, this error will be thrown
+                    importNode.error = e;
+                }
+
+                if (evaldImportNode && (!evaldImportNode.css || inlineCSS)) {
+                    importNode = evaldImportNode;
+                    this.importCount++;
+                    var env = new tree.evalEnv(this.env, this.env.frames.slice(0));
+
+                    if (importNode.options.multiple) {
+                        env.importMultiple = true;
+                    }
+
+                    this._importer.push(importNode.getPath(), importNode.currentFileInfo, importNode.options, function (e, root, importedAtRoot, fullPath) {
+                        if (e && !e.filename) { e.index = importNode.index; e.filename = importNode.currentFileInfo.filename; }
+
+                        if (!env.importMultiple) { 
+                            if (importedAtRoot) {
+                                importNode.skip = true;
+                            } else {
+                                importNode.skip = function() {
+                                    if (fullPath in importVisitor.onceFileDetectionMap) {
+                                        return true;
+                                    }
+                                    importVisitor.onceFileDetectionMap[fullPath] = true;
+                                    return false;
+                                }; 
+                            }
+                        }
+
+                        var subFinish = function(e) {
+                            importVisitor.importCount--;
+
+                            if (importVisitor.importCount === 0 && importVisitor.isFinished) {
+                                importVisitor._finish(e);
+                            }
+                        };
+
+                        if (root) {
+                            importNode.root = root;
+                            importNode.importedFilename = fullPath;
+                            var duplicateImport = importedAtRoot || fullPath in importVisitor.recursionDetector;
+
+                            if (!inlineCSS && (env.importMultiple || !duplicateImport)) {
+                                importVisitor.recursionDetector[fullPath] = true;
+                                new(tree.importVisitor)(importVisitor._importer, subFinish, env, importVisitor.onceFileDetectionMap, importVisitor.recursionDetector)
+                                    .run(root);
+                                return;
+                            }
+                        }
+
+                        subFinish();
+                    });
+                }
+            }
+            visitArgs.visitDeeper = false;
+            return importNode;
+        },
+        visitRule: function (ruleNode, visitArgs) {
+            visitArgs.visitDeeper = false;
+            return ruleNode;
+        },
+        visitDirective: function (directiveNode, visitArgs) {
+            this.env.frames.unshift(directiveNode);
+            return directiveNode;
+        },
+        visitDirectiveOut: function (directiveNode) {
+            this.env.frames.shift();
+        },
+        visitMixinDefinition: function (mixinDefinitionNode, visitArgs) {
+            this.env.frames.unshift(mixinDefinitionNode);
+            return mixinDefinitionNode;
+        },
+        visitMixinDefinitionOut: function (mixinDefinitionNode) {
+            this.env.frames.shift();
+        },
+        visitRuleset: function (rulesetNode, visitArgs) {
+            this.env.frames.unshift(rulesetNode);
+            return rulesetNode;
+        },
+        visitRulesetOut: function (rulesetNode) {
+            this.env.frames.shift();
+        },
+        visitMedia: function (mediaNode, visitArgs) {
+            this.env.frames.unshift(mediaNode.ruleset);
+            return mediaNode;
+        },
+        visitMediaOut: function (mediaNode) {
+            this.env.frames.shift();
+        }
+    };
+
+})(require('./tree'));

data/lib/less/js/lib/less/index.js

@@ -1,17 +1,18 @@
 var path = require('path'),
-    sys = require('util'),
+    url = require('url'),
+    request,
     fs = require('fs');
 
 var less = {
-    version: [1, 3, 0],
+    version: [1, 7, 0],
     Parser: require('./parser').Parser,
-    importer: require('./parser').importer,
     tree: require('./tree'),
     render: function (input, options, callback) {
         options = options || {};
 
         if (typeof(options) === 'function') {
-            callback = options, options = {};
+            callback = options;
+            options = {};
         }
 
         var parser = new(less.Parser)(options),
@@ -19,130 +20,233 @@ var less = {
 
         if (callback) {
             parser.parse(input, function (e, root) {
-                callback(e, root && root.toCSS && root.toCSS(options));
+                if (e) { callback(e); return; }
+                var css;
+                try {
+                    css = root && root.toCSS && root.toCSS(options);
+                } 
+                catch (err) { callback(err); return; }
+                callback(null, css);
             });
         } else {
-            ee = new(require('events').EventEmitter);
+            ee = new (require('events').EventEmitter)();
 
             process.nextTick(function () {
                 parser.parse(input, function (e, root) {
-                    if (e) { ee.emit('error', e) }
-                    else   { ee.emit('success', root.toCSS(options)) }
+                    if (e) { return ee.emit('error', e); }
+                    try { ee.emit('success', root.toCSS(options)); } 
+                    catch (err) { ee.emit('error', err); }
                 });
             });
             return ee;
         }
     },
-    writeError: function (ctx, options) {
+    formatError: function(ctx, options) {
         options = options || {};
 
         var message = "";
         var extract = ctx.extract;
         var error = [];
-        var stylize = options.color ? less.stylize : function (str) { return str };
-
-        if (options.silent) { return }
+        var stylize = options.color ? require('./lessc_helper').stylize : function (str) { return str; };
 
-        if (ctx.stack) { return sys.error(stylize(ctx.stack, 'red')) }
+        // 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')) {
-            return sys.error(ctx.stack || ctx.message);
+        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 (extract[1]) {
-            error.push(ctx.line + ' ' + extract[1].slice(0, ctx.column)
-                                + stylize(stylize(stylize(extract[1][ctx.column], 'bold')
-                                + extract[1].slice(ctx.column + 1), 'red'), 'inverse'));
+        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') + '\033[0m\n';
+        error = error.join('\n') + stylize('', 'reset') + '\n';
 
         message += stylize(ctx.type + 'Error: ' + ctx.message, 'red');
-        ctx.filename && (message += stylize(' in ', 'red') + ctx.filename +
-                stylize(':' + ctx.line + ':' + ctx.column, 'grey'));
+        if (ctx.filename) {
+            message += stylize(' in ', 'red') + ctx.filename +
+                stylize(' on line ' + ctx.line + ', column ' + (ctx.column + 1) + ':', 'grey');
+        }
 
-        sys.error(message, error);
+        message += '\n' + error;
 
         if (ctx.callLine) {
-            sys.error(stylize('from ', 'red')       + (ctx.filename || ''));
-            sys.error(stylize(ctx.callLine, 'grey') + ' ' + ctx.callExtract);
+            message += stylize('from ', 'red') + (ctx.filename || '') + '/n';
+            message += stylize(ctx.callLine, 'grey') + ' ' + ctx.callExtract + '/n';
         }
+
+        return message;
+    },
+    writeError: function (ctx, options) {
+        options = options || {};
+        if (options.silent) { return; }
+        console.error(less.formatError(ctx, options));
     }
 };
 
-['color',      'directive',  'operation',  'dimension',
- 'keyword',    'variable',   'ruleset',    'element',
- 'selector',   'quoted',     'expression', 'rule',
- 'call',       'url',        'alpha',      'import',
- 'mixin',      'comment',    'anonymous',  'value',
- 'javascript', 'assignment', 'condition',  'paren',
- 'media'
-].forEach(function (n) {
-    require('./tree/' + n);
-});
-
-less.Parser.importer = function (file, paths, callback, env) {
-    var pathname;
-
-    // TODO: Undo this at some point,
-    // or use different approach.
-    paths.unshift('.');
-
-    for (var i = 0; i < paths.length; i++) {
-        try {
-            pathname = path.join(paths[i], file);
-            fs.statSync(pathname);
-            break;
-        } catch (e) {
-            pathname = null;
+require('./tree/color');
+require('./tree/directive');
+require('./tree/detached-ruleset');
+require('./tree/operation');
+require('./tree/dimension');
+require('./tree/keyword');
+require('./tree/variable');
+require('./tree/ruleset');
+require('./tree/element');
+require('./tree/selector');
+require('./tree/quoted');
+require('./tree/expression');
+require('./tree/rule');
+require('./tree/call');
+require('./tree/url');
+require('./tree/alpha');
+require('./tree/import');
+require('./tree/mixin');
+require('./tree/comment');
+require('./tree/anonymous');
+require('./tree/value');
+require('./tree/javascript');
+require('./tree/assignment');
+require('./tree/condition');
+require('./tree/paren');
+require('./tree/media');
+require('./tree/unicode-descriptor');
+require('./tree/negative');
+require('./tree/extend');
+require('./tree/ruleset-call');
+
+
+var isUrlRe = /^(?:https?:)?\/\//i;
+
+less.Parser.fileLoader = function (file, currentFileInfo, callback, env) {
+    var pathname, dirname, data,
+        newFileInfo = {
+            relativeUrls: env.relativeUrls,
+            entryPath: currentFileInfo.entryPath,
+            rootpath: currentFileInfo.rootpath,
+            rootFilename: currentFileInfo.rootFilename
+        };
+
+    function handleDataAndCallCallback(data) {
+        var j = file.lastIndexOf('/');
+
+        // Pass on an updated rootpath if path of imported file is relative and file 
+        // is in a (sub|sup) directory
+        // 
+        // Examples: 
+        // - If path of imported file is 'module/nav/nav.less' and rootpath is 'less/',
+        //   then rootpath should become 'less/module/nav/'
+        // - If path of imported file is '../mixins.less' and rootpath is 'less/', 
+        //   then rootpath should become 'less/../'
+        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 = pathname.replace(/[^\\\/]*$/, "");
+        newFileInfo.filename = pathname;
 
-    if (pathname) {
-        fs.readFile(pathname, 'utf-8', function(e, data) {
-            if (e) return callback(e);
+        callback(null, data, pathname, newFileInfo);
+    }
+    
+    var isUrl = isUrlRe.test( file );
+    if (isUrl || isUrlRe.test(currentFileInfo.currentDirectory)) {
+        if (request === undefined) {
+            try { request = require('request'); }
+            catch(e) { request = null; }
+        }
+        if (!request) {
+            callback({ type: 'File', message: "optional dependency 'request' required to import over http(s)\n" });
+            return;
+        }
 
-            new(less.Parser)({
-                paths: [path.dirname(pathname)].concat(paths),
-                filename: pathname
-            }).parse(data, function (e, root) {
-                callback(e, root, data);
-            });
+        var urlStr = isUrl ? file : url.resolve(currentFileInfo.currentDirectory, file),
+            urlObj = url.parse(urlStr);
+
+        request.get({uri: urlStr, strictSSL: !env.insecure }, function (error, res, body) {
+            if (res.statusCode === 404) {
+                callback({ type: 'File', message: "resource '" + urlStr + "' was not found\n" });
+                return;
+            }
+            if (!body) {
+                console.error( 'Warning: Empty body (HTTP '+ res.statusCode + ') returned by "' + urlStr +'"' );
+            }
+            if (error) {
+                callback({ type: 'File', message: "resource '" + urlStr + "' gave this Error:\n  "+ error +"\n" });
+            }
+            pathname = urlStr;
+            dirname = urlObj.protocol +'//'+ urlObj.host + urlObj.pathname.replace(/[^\/]*$/, '');
+            handleDataAndCallCallback(body);
         });
     } else {
-        if (typeof(env.errback) === "function") {
-            env.errback(file, paths, callback);
+
+        var paths = [currentFileInfo.currentDirectory].concat(env.paths);
+        paths.push('.');
+
+        if (env.syncImport) {
+            for (var i = 0; i < paths.length; i++) {
+                try {
+                    pathname = path.join(paths[i], file);
+                    fs.statSync(pathname);
+                    break;
+                } catch (e) {
+                    pathname = null;
+                }
+            }
+
+            if (!pathname) {
+                callback({ type: 'File', message: "'" + file + "' wasn't found" });
+                return;
+            }
+
+            try {
+                data = fs.readFileSync(pathname, 'utf-8');
+                handleDataAndCallCallback(data);
+            } catch (e) {
+                callback(e);
+            }
         } else {
-            callback({ type: 'File', message: "'" + file + "' wasn't found.\n" });
+            (function tryPathIndex(i) {
+                if (i < paths.length) {
+                    pathname = path.join(paths[i], file);
+                    fs.stat(pathname, function (err) {
+                        if (err) {
+                            tryPathIndex(i + 1);
+                        } else {
+                            fs.readFile(pathname, 'utf-8', function(e, data) {
+                                if (e) { callback(e); }
+                                handleDataAndCallCallback(data);
+                            });
+                        }
+                    });
+                } else {
+                    callback({ type: 'File', message: "'" + file + "' wasn't found" });
+                }
+            }(0));
         }
     }
-}
+};
 
+require('./env');
 require('./functions');
 require('./colors');
-
-for (var k in less) { exports[k] = less[k] }
-
-// 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],
-        'grey'      : [90, 39]
-    };
-    return '\033[' + styles[style][0] + 'm' + str +
-           '\033[' + styles[style][1] + 'm';
-}
-less.stylize = stylize;
-
+require('./visitor.js');
+require('./import-visitor.js');
+require('./extend-visitor.js');
+require('./join-selector-visitor.js');
+require('./to-css-visitor.js');
+require('./source-map-output.js');
+
+for (var k in less) { if (less.hasOwnProperty(k)) { exports[k] = less[k]; }}

data/lib/less/js/lib/less/join-selector-visitor.js

@@ -0,0 +1,44 @@
+(function (tree) {
+    tree.joinSelectorVisitor = function() {
+        this.contexts = [[]];
+        this._visitor = new tree.visitor(this);
+    };
+
+    tree.joinSelectorVisitor.prototype = {
+        run: function (root) {
+            return this._visitor.visit(root);
+        },
+        visitRule: function (ruleNode, visitArgs) {
+            visitArgs.visitDeeper = false;
+        },
+        visitMixinDefinition: function (mixinDefinitionNode, visitArgs) {
+            visitArgs.visitDeeper = false;
+        },
+
+        visitRuleset: function (rulesetNode, visitArgs) {
+            var context = this.contexts[this.contexts.length - 1],
+                paths = [], selectors;
+
+            this.contexts.push(paths);
+
+            if (! rulesetNode.root) {
+                selectors = rulesetNode.selectors;
+                if (selectors) {
+                    selectors = selectors.filter(function(selector) { return selector.getIsOutput(); });
+                    rulesetNode.selectors = selectors.length ? selectors : (selectors = null);
+                    if (selectors) { rulesetNode.joinSelectors(paths, context, selectors); }
+                }
+                if (!selectors) { rulesetNode.rules = null; }
+                rulesetNode.paths = paths;
+            }
+        },
+        visitRulesetOut: function (rulesetNode) {
+            this.contexts.length = this.contexts.length - 1;
+        },
+        visitMedia: function (mediaNode, visitArgs) {
+            var context = this.contexts[this.contexts.length - 1];
+            mediaNode.rules[0].root = (context.length === 0 || context[0].multiMedia);
+        }
+    };
+
+})(require('./tree'));

data/lib/less/js/lib/less/lessc_helper.js

@@ -0,0 +1,82 @@
+// lessc_helper.js
+//
+//      helper functions for lessc
+var lessc_helper = {
+
+    //Stylize a string
+    stylize : function(str, style) {
+        var 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';
+    },
+
+    //Print command line options
+    printUsage: function() {
+        console.log("usage: lessc [option option=parameter ...] <source> [destination]");
+        console.log("");
+        console.log("If source is set to `-' (dash or hyphen-minus), input is read from stdin.");
+        console.log("");
+        console.log("options:");
+        console.log("  -h, --help               Print help (this message) and exit.");
+        console.log("  --include-path=PATHS     Set include paths. Separated by `:'. Use `;' on Windows.");
+        console.log("  -M, --depends            Output a makefile import dependency list to stdout");
+        console.log("  --no-color               Disable colorized output.");
+        console.log("  --no-ie-compat           Disable IE compatibility checks.");
+        console.log("  --no-js                  Disable JavaScript in less files");
+        console.log("  -l, --lint               Syntax check only (lint).");
+        console.log("  -s, --silent             Suppress output of error messages.");
+        console.log("  --strict-imports         Force evaluation of imports.");
+        console.log("  --insecure               Allow imports from insecure https hosts.");
+        console.log("  -v, --version            Print version number and exit.");
+        console.log("  -x, --compress           Compress output by removing some whitespaces.");
+        console.log("  --clean-css              Compress output using clean-css");
+        console.log("  --clean-option=opt:val   Pass an option to clean css, using CLI arguments from ");
+        console.log("                           https://github.com/GoalSmashers/clean-css e.g.");
+        console.log("                           --clean-option=--selectors-merge-mode:ie8");
+        console.log("                           and to switch on advanced use --clean-option=--advanced");
+        console.log("  --source-map[=FILENAME]  Outputs a v3 sourcemap to the filename (or output filename.map)");
+        console.log("  --source-map-rootpath=X  adds this path onto the sourcemap filename and less file paths");
+        console.log("  --source-map-basepath=X  Sets sourcemap base path, defaults to current working directory.");
+        console.log("  --source-map-less-inline puts the less files into the map instead of referencing them");
+        console.log("  --source-map-map-inline  puts the map (and any less files) into the output css file");
+        console.log("  --source-map-url=URL     the complete url and filename put in the less file");
+        console.log("  -rp, --rootpath=URL      Set rootpath for url rewriting in relative imports and urls.");
+        console.log("                           Works with or without the relative-urls option.");
+        console.log("  -ru, --relative-urls     re-write relative urls to the base less file.");
+        console.log("  -sm=on|off               Turn on or off strict math, where in strict mode, math");
+        console.log("  --strict-math=on|off     requires brackets. This option may default to on and then");
+        console.log("                           be removed in the future.");
+        console.log("  -su=on|off               Allow mixed units, e.g. 1px+1em or 1px*1px which have units");
+        console.log("  --strict-units=on|off    that cannot be represented.");
+        console.log("  --global-var='VAR=VALUE' Defines a variable that can be referenced by the file.");
+        console.log("  --modify-var='VAR=VALUE' Modifies a variable already declared in the file.");
+        console.log("");
+        console.log("-------------------------- Deprecated ----------------");
+        console.log("  -O0, -O1, -O2            Set the parser's optimization level. The lower");
+        console.log("                           the number, the less nodes it will create in the");
+        console.log("                           tree. This could matter for debugging, or if you");
+        console.log("                           want to access the individual nodes in the tree.");
+        console.log("  --line-numbers=TYPE      Outputs filename and line numbers.");
+        console.log("                           TYPE can be either 'comments', which will output");
+        console.log("                           the debug info within comments, 'mediaquery'");
+        console.log("                           that will output the information within a fake");
+        console.log("                           media query which is compatible with the SASS");
+        console.log("                           format, and 'all' which will do both.");
+        console.log("  --verbose                Be verbose.");
+        console.log("");
+        console.log("Report bugs to: http://github.com/less/less.js/issues");
+        console.log("Home page: <http://lesscss.org/>");
+    }
+};
+
+// Exports helper functions
+for (var h in lessc_helper) { if (lessc_helper.hasOwnProperty(h)) { exports[h] = lessc_helper[h]; }}