less 3.0.0-pre.2 → 3.0.1

package/lib/less/import-manager.js

@@ -1,6 +1,8 @@
 var contexts = require("./contexts"),
     Parser = require('./parser/parser'),
-    LessError = require('./less-error');
+    LessError = require('./less-error'),
+    utils = require('./utils'),
+    PromiseConstructor = typeof Promise === 'undefined' ? require('promise') : Promise;
 
 module.exports = function(environment) {
 
@@ -26,6 +28,7 @@ module.exports = function(environment) {
         this.queue = [];        // Files which haven't been imported yet
         this.files = {};        // Holds the imported parse trees.
     };
+    
     /**
      * Add an import to be imported
      * @param path - the raw path
@@ -48,7 +51,9 @@ module.exports = function(environment) {
                 callback(null, {rules:[]}, false, null);
             }
             else {
-                importManager.files[fullPath] = root;
+                if (!importManager.files[fullPath]) {
+                    importManager.files[fullPath] = { root: root, options: importOptions };
+                } 
                 if (e && !importManager.error) { importManager.error = e; }
                 callback(e, root, importedEqualsRoot, fullPath);
             }
@@ -68,10 +73,6 @@ module.exports = function(environment) {
             return;
         }
 
-        if (tryAppendExtension) {
-            path = importOptions.isPlugin ? path : fileManager.tryAppendExtension(path, ".less");
-        }
-
         var loadFileCallback = function(loadedFile) {
             var plugin,
                 resolvedFilename = loadedFile.filename,
@@ -107,7 +108,7 @@ module.exports = function(environment) {
             }
 
             if (importOptions.isPlugin) {
-                plugin = pluginLoader.evalPlugin(contents, newEnv, importOptions.pluginArgs, newFileInfo);
+                plugin = pluginLoader.evalPlugin(contents, newEnv, importManager, importOptions.pluginArgs, newFileInfo);
                 if (plugin instanceof LessError) {
                     fileParsedFunc(plugin, null, resolvedFilename);
                 }
@@ -117,34 +118,45 @@ module.exports = function(environment) {
             } else if (importOptions.inline) {
                 fileParsedFunc(null, contents, resolvedFilename);
             } else {
-                new Parser(newEnv, importManager, newFileInfo).parse(contents, function (e, root) {
-                    fileParsedFunc(e, root, resolvedFilename);
-                });
-            }
-        };
-        var promise;
-        var done = function(err, loadedFile) {
-            if (err) {
-                fileParsedFunc(err);
-            } else {
-                loadFileCallback(loadedFile);
+                
+                // import (multiple) parse trees apparently get altered and can't be cached.
+                // TODO: investigate why this is
+                if (importManager.files[resolvedFilename] 
+                    && !importManager.files[resolvedFilename].options.multiple
+                    && !importOptions.multiple) {
+
+                    fileParsedFunc(null, importManager.files[resolvedFilename].root, resolvedFilename);
+                }
+                else {
+                    new Parser(newEnv, importManager, newFileInfo).parse(contents, function (e, root) {
+                        fileParsedFunc(e, root, resolvedFilename);
+                    });
+                }
             }
         };
+        var promise, context = utils.clone(this.context);
+
+        if (tryAppendExtension) {
+            context.ext = importOptions.isPlugin ? ".js" : ".less";
+        }
+
         if (importOptions.isPlugin) {
-            try {
-                pluginLoader.tryLoadPlugin(path, currentFileInfo.currentDirectory, done);
-            }
-            catch(e) {
-                callback(e);
-            }
+            promise = pluginLoader.loadPlugin(path, currentFileInfo.currentDirectory, context, environment, fileManager);
         }
         else {
-            promise = fileManager.loadFile(path, currentFileInfo.currentDirectory, this.context, environment, done);
-            if (promise) {
-                promise.then(loadFileCallback, fileParsedFunc);
-            }
+            promise = fileManager.loadFile(path, currentFileInfo.currentDirectory, context, environment, 
+                function(err, loadedFile) {
+                    if (err) {
+                        fileParsedFunc(err);
+                    } else {
+                        loadFileCallback(loadedFile);
+                    }
+                });
         }
-        
+        if (promise) {
+            promise.then(loadFileCallback, fileParsedFunc);
+        }
+
     };
     return ImportManager;
 };

package/lib/less/index.js

@@ -1,8 +1,8 @@
 module.exports = function(environment, fileManagers) {
     var SourceMapOutput, SourceMapBuilder, ParseTree, ImportManager, Environment;
 
-    var less = {
-        version: [3, 0, 0],
+    var initial = {
+        version: [3, 0, 1],
         data: require('./data'),
         tree: require('./tree'),
         Environment: (Environment = require("./environment/environment")),
@@ -26,5 +26,30 @@ module.exports = function(environment, fileManagers) {
         logger: require('./logger')
     };
 
-    return less;
+    // Create a public API
+
+    var ctor = function(t) {
+        return function() {
+            var obj = Object.create(t.prototype);
+            t.apply(obj, Array.prototype.slice.call(arguments, 0));
+            return obj;
+        };
+    };
+    var t, api = Object.create(initial);
+    for (var n in initial.tree) {
+        /* eslint guard-for-in: 0 */
+        t = initial.tree[n];
+        if (typeof t === "function") {
+            api[n.toLowerCase()] = ctor(t);
+        }
+        else {
+            api[n] = Object.create(null);
+            for (var o in t) {
+                /* eslint guard-for-in: 0 */
+                api[n][o.toLowerCase()] = ctor(t[o]);
+            }
+        }
+    }
+
+    return api;
 };

package/lib/less/less-error.js

@@ -1,34 +1,72 @@
-var utils = require("./utils");
-
-var LessError = module.exports = function LessError(e, importManager, currentFilename) {
-
+var utils = require('./utils');
+/**
+ * This is a centralized class of any error that could be thrown internally (mostly by the parser).
+ * Besides standard .message it keeps some additional data like a path to the file where the error
+ * occurred along with line and column numbers.
+ *
+ * @class
+ * @extends Error
+ * @type {module.LessError}
+ *
+ * @prop {string} type
+ * @prop {string} filename
+ * @prop {number} index
+ * @prop {number} line
+ * @prop {number} column
+ * @prop {number} callLine
+ * @prop {number} callExtract
+ * @prop {string[]} extract
+ *
+ * @param {Object} e              - An error object to wrap around or just a descriptive object
+ * @param {Object} fileContentMap - An object with file contents in 'contents' property (like importManager) @todo - move to fileManager?
+ * @param {string} [currentFilename]
+ */
+var LessError = module.exports = function LessError(e, fileContentMap, currentFilename) {
     Error.call(this);
 
     var filename = e.filename || currentFilename;
 
-    if (importManager && filename) {
-        var input = importManager.contents[filename],
+    this.message = e.message;
+    this.stack = e.stack;
+
+    if (fileContentMap && filename) {
+        var input = fileContentMap.contents[filename],
             loc = utils.getLocation(e.index, input),
             line = loc.line,
             col  = loc.column,
             callLine = e.call && utils.getLocation(e.call, input).line,
-            lines = input.split('\n');
+            lines = input ? input.split('\n') : '';
 
         this.type = e.type || 'Syntax';
         this.filename = filename;
         this.index = e.index;
         this.line = typeof line === 'number' ? line + 1 : null;
+        this.column = col;
+
+        if (!this.line && this.stack) {
+            var found = this.stack.match(/(<anonymous>|Function):(\d+):(\d+)/);
+
+            if (found) {
+                if (found[2]) {
+                    this.line = parseInt(found[2]) - 2;
+                }
+                if (found[3]) {
+                    this.column = parseInt(found[3]);
+                }
+            }
+        }
+
         this.callLine = callLine + 1;
         this.callExtract = lines[callLine];
-        this.column = col;
+
         this.extract = [
-            lines[line - 1],
-            lines[line],
-            lines[line + 1]
+            lines[this.line - 2],
+            lines[this.line - 1],
+            lines[this.line]
         ];
+
     }
-    this.message = e.message;
-    this.stack = e.stack;
+
 };
 
 if (typeof Object.create === 'undefined') {
@@ -40,3 +78,64 @@ if (typeof Object.create === 'undefined') {
 }
 
 LessError.prototype.constructor = LessError;
+
+/**
+ * An overridden version of the default Object.prototype.toString
+ * which uses additional information to create a helpful message.
+ *
+ * @param {Object} options
+ * @returns {string}
+ */
+LessError.prototype.toString = function(options) {
+    options = options || {};
+
+    var message = '';
+    var extract = this.extract || [];
+    var error = [];
+    var stylize = function (str) { return str; };
+    if (options.stylize) {
+        var type = typeof options.stylize;
+        if (type !== 'function') {
+            throw Error('options.stylize should be a function, got a ' + type + '!');
+        }
+        stylize = options.stylize;
+    }
+
+    if (this.line !== null) {
+        if (typeof extract[0] === 'string') {
+            error.push(stylize((this.line - 1) + ' ' + extract[0], 'grey'));
+        }
+
+        if (typeof extract[1] === 'string') {
+            var errorTxt = this.line + ' ';
+            if (extract[1]) {
+                errorTxt += extract[1].slice(0, this.column) +
+                    stylize(stylize(stylize(extract[1].substr(this.column, 1), 'bold') +
+                        extract[1].slice(this.column + 1), 'red'), 'inverse');
+            }
+            error.push(errorTxt);
+        }
+
+        if (typeof extract[2] === 'string') {
+            error.push(stylize((this.line + 1) + ' ' + extract[2], 'grey'));
+        }
+        error = error.join('\n') + stylize('', 'reset') + '\n';
+    }
+
+    message += stylize(this.type + 'Error: ' + this.message, 'red');
+    if (this.filename) {
+        message += stylize(' in ', 'red') + this.filename;
+    }
+    if (this.line) {
+        message += stylize(' on line ' + this.line + ', column ' + (this.column + 1) + ':', 'grey');
+    }
+
+    message += '\n' + error;
+
+    if (this.callLine) {
+        message += stylize('from ', 'red') + (this.filename || '') + '/n';
+        message += stylize(this.callLine, 'grey') + ' ' + this.callExtract + '/n';
+    }
+
+    return message;
+};

package/lib/less/parse.js

@@ -2,15 +2,18 @@ var PromiseConstructor,
     contexts = require("./contexts"),
     Parser = require('./parser/parser'),
     PluginManager = require('./plugin-manager'),
-    LessError = require('./less-error');
+    LessError = require('./less-error'),
+    utils = require('./utils');
 
 module.exports = function(environment, ParseTree, ImportManager) {
     var parse = function (input, options, callback) {
-        options = options || {};
 
         if (typeof options === 'function') {
             callback = options;
-            options = {};
+            options = utils.defaults(this.options, {});
+        }
+        else {
+            options = utils.defaults(this.options, options || {});
         }
 
         if (!callback) {
@@ -30,7 +33,7 @@ module.exports = function(environment, ParseTree, ImportManager) {
         } else {
             var context,
                 rootFileInfo,
-                pluginManager = new PluginManager(this, true);
+                pluginManager = new PluginManager(this, !options.reUsePluginManager);
 
             options.pluginManager = pluginManager;
 
@@ -56,32 +59,32 @@ module.exports = function(environment, ParseTree, ImportManager) {
             }
 
             var imports = new ImportManager(this, context, rootFileInfo);
-            
+            this.importManager = imports;
+
+            // TODO: allow the plugins to be just a list of paths or names
+            // Do an async plugin queue like lessc
+
             if (options.plugins) {
                 options.plugins.forEach(function(plugin) {
                     var evalResult, contents;
                     if (plugin.fileContent) {
                         contents = plugin.fileContent.replace(/^\uFEFF/, '');
-                        evalResult = pluginManager.Loader.evalPlugin(contents, context, plugin.options, plugin.filename);
-                        if (!(evalResult instanceof LessError)) {
-                            pluginManager.addPlugin(plugin);
-                        }
-                        else {
+                        evalResult = pluginManager.Loader.evalPlugin(contents, context, imports, plugin.options, plugin.filename);
+                        if (evalResult instanceof LessError) {
                             return callback(evalResult);
                         }
-                        
                     }
                     else {
                         pluginManager.addPlugin(plugin);
                     }
                 });
             }
-            
+
             new Parser(context, imports, rootFileInfo)
                 .parse(input, function (e, root) {
-                if (e) { return callback(e); }
-                callback(null, root, imports, options);
-            }, options);
+                    if (e) { return callback(e); }
+                    callback(null, root, imports, options);
+                }, options);
         }
     };
     return parse;

package/lib/less/parser/parser-input.js

@@ -1,11 +1,11 @@
 var chunker = require('./chunker');
 
 module.exports = function() {
-    var input,       // LeSS input string
+    var input,       // Less input string
         j,           // current chunk
         saveStack = [],   // holds state for backtracking
         furthest,    // furthest index the parser has gone to
-        furthestPossibleErrorMessage,// if this is furthest we got to, this is the probably cause
+        furthestPossibleErrorMessage, // if this is furthest we got to, this is the probably cause
         chunks,      // chunkified input
         current,     // current chunk
         currentPos,  // index of current chunk, in `input`
@@ -156,7 +156,7 @@ module.exports = function() {
 
         for (var i = 1; i + currentPosition < length; i++) {
             var nextChar = input.charAt(i + currentPosition);
-            switch(nextChar) {
+            switch (nextChar) {
                 case "\\":
                     i++;
                     continue;
@@ -209,7 +209,7 @@ module.exports = function() {
 
     parserInput.peekNotNumeric = function() {
         var c = input.charCodeAt(parserInput.i);
-        //Is the first char of the dimension 0-9, '.', '+' or '-'
+        // Is the first char of the dimension 0-9, '.', '+' or '-'
         return (c > CHARCODE_9 || c < CHARCODE_PLUS) || c === CHARCODE_FORWARD_SLASH || c === CHARCODE_COMMA;
     };