import interpolation finished. refactored the import phase to occur only within the import visitor - so that the import eval env can be passed between imports.

Author: lukeapage

lib/less/browser.js

@@ -249,26 +249,32 @@ function loadStyleSheet(sheet, callback, reload, remaining) {
     var timestamp = cache && cache.getItem(href + ':timestamp');
     var styles    = { css: css, timestamp: timestamp };
     var env;
+    var newFileInfo = {
+            relativeUrls: less.relativeUrls,
+            currentDirectory: hrefParts.path,
+            filename: href
+        };
 
     if (sheet instanceof less.tree.parseEnv) {
         env = new less.tree.parseEnv(sheet);
+        newFileInfo.entryPath = env.currentFileInfo.entryPath;
+        newFileInfo.rootpath = env.currentFileInfo.rootpath;
+        newFileInfo.rootFilename = env.currentFileInfo.rootFilename;
     } else {
         env = new less.tree.parseEnv(less);
-        env.entryPath = hrefParts.path;
         env.mime = sheet.type;
+        newFileInfo.entryPath = hrefParts.path;
+        newFileInfo.rootpath = less.rootpath || hrefParts.path;
+        newFileInfo.rootFilename = href;
     }
 
     if (env.relativeUrls) {
         //todo - this relies on option being set on less object rather than being passed in as an option
         //     - need an originalRootpath
         if (less.rootpath) {
-            env.rootpath = extractUrlParts(less.rootpath + pathDiff(hrefParts.path, env.entryPath)).path;
+            newFileInfo.rootpath = extractUrlParts(less.rootpath + pathDiff(hrefParts.path, newFileInfo.entryPath)).path;
         } else {
-            env.rootpath = hrefParts.path;
-        }
-    } else  {
-        if (!less.rootpath) {
-            env.rootpath = env.entryPath;
+            newFileInfo.rootpath = hrefParts.path;
         }
     }
 
@@ -287,16 +293,16 @@ function loadStyleSheet(sheet, callback, reload, remaining) {
             try {
                 env.contents[href] = data;  // Updating content cache
                 env.paths = [hrefParts.path];
-                env.filename = href;
-                env.rootFilename = env.rootFilename || href;
+                env.currentFileInfo = newFileInfo;
+
                 new(less.Parser)(env).parse(data, function (e, root) {
                     if (e) { return callback(e, null, null, sheet); }
                     try {
                         callback(e, root, data, sheet, { local: false, lastModified: lastModified, remaining: remaining }, href);
                         //TODO - there must be a better way? A generic less-to-css function that can both call error
                         //and removeNode where appropriate
                         //should also add tests
-                        if (env.rootFilename === href) {
+                        if (env.currentFileInfo.rootFilename === href) {
                             removeNode(document.getElementById('less-error-message:' + extractId(href)));
                         }
                     } catch (e) {

lib/less/env.js

@@ -1,28 +1,46 @@
 (function (tree) {
 
     var parseCopyProperties = [
-        'paths',            // paths to search for imports on
+        'paths',            // option - unmodified - paths to search for imports on
         'optimization',     // option - optimization level (for the chunker)
-        'filename',         // current filename, used for error reporting
         'files',            // list of files that have been imported, used for import-once
         'contents',         // browser-only, contents of all the files
-        'rootpath',         // current rootpath to append to all url's
         'relativeUrls',     // option - whether to adjust URL's to be relative
         'strictImports',    // option -
         'dumpLineNumbers',  // option - whether to dump line numbers
         'compress',         // option - whether to compress
+        'processImports',   // option - whether to process imports. if false then imports will not be imported
         'mime',             // browser only - mime type for sheet import
-        'entryPath',        // browser only - path of entry less file
-        'rootFilename',     // browser only - href of the entry less file
-        'currentDirectory'  // node only - the current directory
+        'currentFileInfo'   // information about the current file - for error reporting and importing and making urls relative etc.
     ];
 
+    //currentFileInfo = {
+    //  'relativeUrls' - option - whether to adjust URL's to be relative
+    //  'filename' - full resolved filename of current file
+    //  'rootpath' - path to append to normal URLs for this node
+    //  'currentDirectory' - path to the current file, absolute
+    //  'rootFilename' - filename of the base file
+    //  'entryPath' = absolute path to the entry file
+
     tree.parseEnv = function(options) {
         copyFromOriginal(options, this, parseCopyProperties);
 
         if (!this.contents) { this.contents = {}; }
-        if (!this.rootpath) { this.rootpath = ''; }
         if (!this.files) { this.files = {}; }
+
+        if (!this.currentFileInfo) {
+            var filename = options.filename || "input";
+            options.filename = null;
+            var entryPath = filename.replace(/[^\/\\]*$/, "");
+            this.currentFileInfo = {
+                filename: filename,
+                relativeUrls: this.relativeUrls,
+                rootpath: options.rootpath || "",
+                currentDirectory: entryPath,
+                entryPath: entryPath,
+                rootFilename: filename
+            };
+        }
     };
 
     tree.parseEnv.prototype.toSheet = function (path) {

lib/less/functions.js

@@ -376,7 +376,7 @@ tree.functions = {
     "data-uri": function(mimetypeNode, filePathNode) {
 
         if (typeof window !== 'undefined') {
-            return new tree.URL(filePathNode || mimetypeNode, this.rootpath).eval(this.env);
+            return new tree.URL(filePathNode || mimetypeNode, this.currentFileInfo).eval(this.env);
         }
 
         var mimetype = mimetypeNode.value;
@@ -390,8 +390,12 @@ tree.functions = {
             filePath = mimetype;
         }
 
-        if (this.currentDirectory && this.env.isPathRelative(filePath)) {
-            filePath = path.join(this.currentDirectory, filePath);
+        if (this.env.isPathRelative(filePath)) {
+            if (this.currentFileInfo.relativeUrls) {
+                filePath = path.join(this.currentFileInfo.currentDirectory, filePath);
+            } else {
+                filePath = path.join(this.currentFileInfo.entryPath, filePath);
+            }
         }
 
         // detect the mimetype if not given
@@ -421,15 +425,13 @@ tree.functions = {
         var DATA_URI_MAX_KB = 32,
             fileSizeInKB = parseInt((buf.length / 1024), 10);
         if (fileSizeInKB >= DATA_URI_MAX_KB) {
-            // the url() must be relative, not an absolute file path
-            filePath = path.relative(this.currentDirectory, filePath);
 
             if (this.env.ieCompat !== false) {
                 if (!this.env.silent) {
                     console.warn("Skipped data-uri embedding of %s because its size (%dKB) exceeds IE8-safe %dKB!", filePath, fileSizeInKB, DATA_URI_MAX_KB);
                 }
 
-                return new tree.URL(filePathNode || mimetypeNode, this.rootpath).eval(this.env);
+                return new tree.URL(filePathNode || mimetypeNode, this.currentFileInfo).eval(this.env);
             } else if (!this.env.silent) {
                 // if explicitly disabled (via --no-ie-compat on CLI, or env.ieCompat === false), merely warn
                 console.warn("WARNING: Embedding %s (%dKB) exceeds IE8's data-uri size limit of %dKB!", filePath, fileSizeInKB, DATA_URI_MAX_KB);
@@ -517,10 +519,9 @@ function clamp(val) {
     return Math.min(1, Math.max(0, val));
 }
 
-tree.functionCall = function(env, rootpath, currentDirectory) {
+tree.functionCall = function(env, currentFileInfo) {
     this.env = env;
-    this.rootpath = rootpath;
-    this.currentDirectory = currentDirectory;
+    this.currentFileInfo = currentFileInfo;
 };
 
 tree.functionCall.prototype = tree.functions;

lib/less/import-visitor.js

@@ -1,22 +1,62 @@
 (function (tree) {
-    tree.importVisitor = function(root, importer) {
+    tree.importVisitor = function(root, importer, finish, evalEnv) {
         this._visitor = new tree.visitor(this);
         this._importer = importer;
-        this.env = new tree.evalEnv();
+        this._finish = finish;
+        this.env = evalEnv || new tree.evalEnv();
+        this.importCount = 0;
 
         // process the contents
         this._visitor.visit(root);
+
+        this.isFinished = true;
+
+        if (this.importCount === 0) {
+            this._finish();
+        }
     };
 
     tree.importVisitor.prototype = {
         visitImport: function (importNode, visitArgs) {
+            var importVisitor = this,
+                evaldImportNode;
+
             if (!importNode.css) {
-                importNode = importNode.evalForImport(this.env);
-                this._importer.push(importNode.getPath(), function (e, root, imported) {
-                    if (e) { e.index = importNode.index; }
-                    if (imported && importNode.once) { importNode.skip = imported; }
-                    importNode.root = root || new(tree.Ruleset)([], []);
-                });
+
+                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) {
+                    importNode = evaldImportNode;
+                    this.importCount++;
+                    var env = new tree.evalEnv(this.env, this.env.frames.slice(0));
+                    this._importer.push(importNode.getPath(), importNode.currentFileInfo, function (e, root, imported) {
+                        if (e && !e.filename) { e.index = importNode.index; e.filename = importNode.currentFileInfo.filename; }
+                        if (imported && importNode.once) { importNode.skip = imported; }
+
+                        var subFinish = function() {
+                            importVisitor.importCount--;
+
+                            if (importVisitor.importCount === 0 && importVisitor.isFinished) {
+                                importVisitor._finish();
+                            }
+                        };
+
+                        if (root) {
+                            importNode.root = root;
+                            new(tree.importVisitor)(root, importVisitor._importer, subFinish, env);
+                        } else {
+                            subFinish();
+                        }
+                    });
+                }
             }
             visitArgs.visitDeeper = false;
             return importNode;

lib/less/index.js

@@ -103,13 +103,20 @@ var less = {
 
 var isUrlRe = /^(?:https?:)?\/\//i;
 
-less.Parser.importer = function (file, paths, callback, env) {
-    var pathname, dirname, data;
+less.Parser.importer = function (file, currentFileInfo, callback, env) {
+    var pathname, dirname, data,
+        newFileInfo = {
+            relativeUrls: env.relativeUrls,
+            entryPath: currentFileInfo.entryPath,
+            rootpath: currentFileInfo.rootpath,
+            rootFilename: currentFileInfo.rootFilename
+        };
 
     function parseFile(e, data) {
         if (e) { return callback(e); }
 
         env = new less.tree.parseEnv(env);
+        env.processImports = false;
 
         var j = file.lastIndexOf('/');
 
@@ -121,23 +128,22 @@ less.Parser.importer = function (file, paths, callback, env) {
         //   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(env.relativeUrls && !/^(?:[a-z-]+:|\/)/.test(file) && j != -1) {
-            env.rootpath = env.rootpath + file.slice(0, j+1); // append (sub|sup) directory path of imported file
-        }
-        if (env.relativeUrls) {
-            env.currentDirectory = pathname.replace(/[^\\\/]*$/, "");
+        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;
 
         env.contents[pathname] = data;      // Updating top importing parser content cache.
-        env.paths = [dirname].concat(paths);
-        env.filename = pathname;
+        env.currentFileInfo = newFileInfo;
         new(less.Parser)(env).parse(data, function (e, root) {
             callback(e, root, pathname);
         });
     };
 
     var isUrl = isUrlRe.test( file );
-    if (isUrl || isUrlRe.test(paths[0])) {
+    if (isUrl || isUrlRe.test(currentFileInfo.currentDirectory)) {
         if (request === undefined) {
             try { request = require('request'); }
             catch(e) { request = null; }
@@ -147,7 +153,7 @@ less.Parser.importer = function (file, paths, callback, env) {
             return;
         }
 
-        var urlStr = isUrl ? file : url.resolve(paths[0], file),
+        var urlStr = isUrl ? file : url.resolve(currentFileInfo.currentDirectory, file),
             urlObj = url.parse(urlStr),
             req = {
                 host:   urlObj.hostname,
@@ -172,9 +178,7 @@ less.Parser.importer = function (file, paths, callback, env) {
         });
     } else {
 
-        // TODO: Undo this at some point,
-        // or use different approach.
-        var paths = [].concat(paths);
+        var paths = [currentFileInfo.currentDirectory].concat(env.paths);
         paths.push('.');
 
         for (var i = 0; i < paths.length; i++) {
@@ -187,8 +191,6 @@ less.Parser.importer = function (file, paths, callback, env) {
             }
         }
 
-        paths = paths.slice(0, paths.length - 1);
-
         if (!pathname) {
 
             callback({ type: 'File', message: "'" + file + "' wasn't found" });