less 2.1.2 → 2.4.0

package/lib/less-browser/index.js

@@ -6,250 +6,251 @@ var addDataAttr = require("./utils").addDataAttr,
     browser = require("./browser");
 
 module.exports = function(window, options) {
-var document = window.document;
-var less = require('../less')();
-module.exports = less;
-less.options = options;
-var environment = less.environment,
-    FileManager = require("./file-manager")(options, less.logger),
-    fileManager = new FileManager();
-environment.addFileManager(fileManager);
-less.FileManager = FileManager;
-
-require("./log-listener")(less, options);
-var errors = require("./error-reporting")(window, less, options);
-var cache = less.cache = options.cache || require("./cache")(window, options, less.logger);
-
-//Setup user functions
-if (options.functions) {
-    less.functions.functionRegistry.addMultiple(options.functions);
-}
-
-var typePattern = /^text\/(x-)?less$/;
-
-function postProcessCSS(styles) {
-    if (options.postProcessor && typeof options.postProcessor === 'function') {
-        styles = options.postProcessor.call(styles, styles) || styles;
+    var document = window.document;
+    var less = require('../less')();
+    //module.exports = less;
+    less.options = options;
+    var environment = less.environment,
+        FileManager = require("./file-manager")(options, less.logger),
+        fileManager = new FileManager();
+    environment.addFileManager(fileManager);
+    less.FileManager = FileManager;
+
+    require("./log-listener")(less, options);
+    var errors = require("./error-reporting")(window, less, options);
+    var cache = less.cache = options.cache || require("./cache")(window, options, less.logger);
+
+    //Setup user functions
+    if (options.functions) {
+        less.functions.functionRegistry.addMultiple(options.functions);
     }
-    return styles;
-}
-
-function clone(obj) {
-    var cloned = {};
-    for(var prop in obj) {
-        if (obj.hasOwnProperty(prop)) {
-            cloned[prop] = obj[prop];
+
+    var typePattern = /^text\/(x-)?less$/;
+
+    function postProcessCSS(styles) {
+        if (options.postProcessor && typeof options.postProcessor === 'function') {
+            styles = options.postProcessor.call(styles, styles) || styles;
         }
+        return styles;
     }
-    return cloned;
-}
-
-// only really needed for phantom
-function bind(func, thisArg) {
-    var curryArgs = Array.prototype.slice.call(arguments, 2);
-    return function() {
-        var args = curryArgs.concat(Array.prototype.slice.call(arguments, 0));
-        return func.apply(thisArg, args);
-    };
-}
 
-function loadStyles(modifyVars) {
-    var styles = document.getElementsByTagName('style'),
-        style;
+    function clone(obj) {
+        var cloned = {};
+        for (var prop in obj) {
+            if (obj.hasOwnProperty(prop)) {
+                cloned[prop] = obj[prop];
+            }
+        }
+        return cloned;
+    }
 
-    for (var i = 0; i < styles.length; i++) {
-        style = styles[i];
-        if (style.type.match(typePattern)) {
-            var instanceOptions = clone(options);
-            instanceOptions.modifyVars = modifyVars;
-            var lessText = style.innerHTML || '';
-            instanceOptions.filename = document.location.href.replace(/#.*$/, '');
+    // only really needed for phantom
+    function bind(func, thisArg) {
+        var curryArgs = Array.prototype.slice.call(arguments, 2);
+        return function() {
+            var args = curryArgs.concat(Array.prototype.slice.call(arguments, 0));
+            return func.apply(thisArg, args);
+        };
+    }
 
-            /*jshint loopfunc:true */
-            // use closure to store current style
-            less.render(lessText, instanceOptions,
-                    bind(function(style, e, result) {
-                        if (e) {
-                            errors.add(e, "inline");
-                        } else {
-                            style.type = 'text/css';
-                            if (style.styleSheet) {
-                                style.styleSheet.cssText = result.css;
+    function loadStyles(modifyVars) {
+        var styles = document.getElementsByTagName('style'),
+            style;
+
+        for (var i = 0; i < styles.length; i++) {
+            style = styles[i];
+            if (style.type.match(typePattern)) {
+                var instanceOptions = clone(options);
+                instanceOptions.modifyVars = modifyVars;
+                var lessText = style.innerHTML || '';
+                instanceOptions.filename = document.location.href.replace(/#.*$/, '');
+
+                /*jshint loopfunc:true */
+                // use closure to store current style
+                less.render(lessText, instanceOptions,
+                        bind(function(style, e, result) {
+                            if (e) {
+                                errors.add(e, "inline");
                             } else {
-                                style.innerHTML = result.css;
+                                style.type = 'text/css';
+                                if (style.styleSheet) {
+                                    style.styleSheet.cssText = result.css;
+                                } else {
+                                    style.innerHTML = result.css;
+                                }
                             }
-                        }
-                    }, null, style));
+                        }, null, style));
+            }
         }
     }
-}
 
-function loadStyleSheet(sheet, callback, reload, remaining, modifyVars) {
+    function loadStyleSheet(sheet, callback, reload, remaining, modifyVars) {
 
-    var instanceOptions = clone(options);
-    addDataAttr(instanceOptions, sheet);
-    instanceOptions.mime = sheet.type;
+        var instanceOptions = clone(options);
+        addDataAttr(instanceOptions, sheet);
+        instanceOptions.mime = sheet.type;
 
-    if (modifyVars) {
-        instanceOptions.modifyVars = modifyVars;
-    }
+        if (modifyVars) {
+            instanceOptions.modifyVars = modifyVars;
+        }
 
-    function loadInitialFileCallback(loadedFile) {
+        function loadInitialFileCallback(loadedFile) {
 
-        var data = loadedFile.contents,
-            path = loadedFile.filename,
-            webInfo = loadedFile.webInfo;
+            var data = loadedFile.contents,
+                path = loadedFile.filename,
+                webInfo = loadedFile.webInfo;
 
-        var newFileInfo = {
-            currentDirectory: fileManager.getPath(path),
-            filename: path,
-            rootFilename: path,
-            relativeUrls: instanceOptions.relativeUrls};
+            var newFileInfo = {
+                currentDirectory: fileManager.getPath(path),
+                filename: path,
+                rootFilename: path,
+                relativeUrls: instanceOptions.relativeUrls};
 
-        newFileInfo.entryPath = newFileInfo.currentDirectory;
-        newFileInfo.rootpath = instanceOptions.rootpath || newFileInfo.currentDirectory;
+            newFileInfo.entryPath = newFileInfo.currentDirectory;
+            newFileInfo.rootpath = instanceOptions.rootpath || newFileInfo.currentDirectory;
 
-        if (webInfo) {
-            webInfo.remaining = remaining;
+            if (webInfo) {
+                webInfo.remaining = remaining;
 
-            var css = cache.getCSS(path, webInfo);
-            if (!reload && css) {
-                browser.createCSS(window.document, css, sheet);
-                webInfo.local = true;
-                callback(null, null, data, sheet, webInfo, path);
-                return;
+                if (!instanceOptions.modifyVars) {
+                    var css = cache.getCSS(path, webInfo);
+                    if (!reload && css) {
+                        webInfo.local = true;
+                        callback(null, css, data, sheet, webInfo, path);
+                        return;
+                    }
+                }
             }
-        }
 
-        //TODO add tests around how this behaves when reloading
-        errors.remove(path);
+            //TODO add tests around how this behaves when reloading
+            errors.remove(path);
+
+            instanceOptions.rootFileInfo = newFileInfo;
+            less.render(data, instanceOptions, function(e, result) {
+                if (e) {
+                    e.href = path;
+                    callback(e);
+                } else {
+                    result.css = postProcessCSS(result.css);
+                    if (!instanceOptions.modifyVars) {
+                        cache.setCSS(sheet.href, webInfo.lastModified, result.css);
+                    }
+                    callback(null, result.css, data, sheet, webInfo, path);
+                }
+            });
+        }
 
-        instanceOptions.rootFileInfo = newFileInfo;
-        less.render(data, instanceOptions, function(e, result) {
+        fileManager.loadFile(sheet.href, null, instanceOptions, environment, function(e, loadedFile) {
             if (e) {
-                e.href = path;
                 callback(e);
-            } else {
-                callback(null, result.css, data, sheet, webInfo, path);
+                return;
             }
+            loadInitialFileCallback(loadedFile);
         });
     }
 
-    fileManager.loadFile(sheet.href, null, instanceOptions, environment, function(e, loadedFile) {
-        if (e) {
-            callback(e);
-            return;
+    function loadStyleSheets(callback, reload, modifyVars) {
+        for (var i = 0; i < less.sheets.length; i++) {
+            loadStyleSheet(less.sheets[i], callback, reload, less.sheets.length - (i + 1), modifyVars);
         }
-        loadInitialFileCallback(loadedFile);
-    });
-}
-
-function loadStyleSheets(callback, reload, modifyVars) {
-    for (var i = 0; i < less.sheets.length; i++) {
-        loadStyleSheet(less.sheets[i], callback, reload, less.sheets.length - (i + 1), modifyVars);
-    }
-}
-
-function initRunningMode(){
-    if (less.env === 'development') {
-        less.watchTimer = setInterval(function () {
-            if (less.watchMode) {
-                fileManager.clearFileCache();
-                loadStyleSheets(function (e, css, _, sheet, context) {
-                    if (e) {
-                        errors.add(e, e.href || sheet.href);
-                    } else if (css) {
-                        css = postProcessCSS(css);
-                        browser.createCSS(window.document, css, sheet);
-                        cache.setCSS(sheet.href, context.lastModified, css);
-                    }
-                });
-            }
-        }, options.poll);
     }
-}
 
-//
-// Watch mode
-//
-less.watch   = function () {
-    if (!less.watchMode ){
-        less.env = 'development';
-         initRunningMode();
+    function initRunningMode() {
+        if (less.env === 'development') {
+            less.watchTimer = setInterval(function () {
+                if (less.watchMode) {
+                    fileManager.clearFileCache();
+                    loadStyleSheets(function (e, css, _, sheet, webInfo) {
+                        if (e) {
+                            errors.add(e, e.href || sheet.href);
+                        } else if (css) {
+                            browser.createCSS(window.document, css, sheet);
+                        }
+                    });
+                }
+            }, options.poll);
+        }
     }
-    this.watchMode = true;
-    return true;
-};
-
-less.unwatch = function () {clearInterval(less.watchTimer); this.watchMode = false; return false; };
 
-//
-// Get all <link> tags with the 'rel' attribute set to "stylesheet/less"
-//
-less.registerStylesheets = function() {
-    return new Promise(function(resolve, reject) {
-        var links = document.getElementsByTagName('link');
-        less.sheets = [];
-
-        for (var i = 0; i < links.length; i++) {
-            if (links[i].rel === 'stylesheet/less' || (links[i].rel.match(/stylesheet/) &&
-                (links[i].type.match(typePattern)))) {
-                less.sheets.push(links[i]);
-            }
+    //
+    // Watch mode
+    //
+    less.watch   = function () {
+        if (!less.watchMode ) {
+            less.env = 'development';
+            initRunningMode();
         }
+        this.watchMode = true;
+        return true;
+    };
 
-        resolve();
-    });
-};
+    less.unwatch = function () {clearInterval(less.watchTimer); this.watchMode = false; return false; };
+
+    //
+    // Get all <link> tags with the 'rel' attribute set to "stylesheet/less"
+    //
+    less.registerStylesheets = function() {
+        return new Promise(function(resolve, reject) {
+            var links = document.getElementsByTagName('link');
+            less.sheets = [];
+
+            for (var i = 0; i < links.length; i++) {
+                if (links[i].rel === 'stylesheet/less' || (links[i].rel.match(/stylesheet/) &&
+                    (links[i].type.match(typePattern)))) {
+                    less.sheets.push(links[i]);
+                }
+            }
 
-//
-// With this function, it's possible to alter variables and re-render
-// CSS without reloading less-files
-//
-less.modifyVars = function(record) {
-    return less.refresh(true, record, false);
-};
+            resolve();
+        });
+    };
 
-less.refresh = function (reload, modifyVars, clearFileCache) {
-    if ((reload || clearFileCache) && clearFileCache !== false) {
-        fileManager.clearFileCache();
-    }
-    return new Promise(function (resolve, reject) {
-        var startTime, endTime, totalMilliseconds;
-        startTime = endTime = new Date();
+    //
+    // With this function, it's possible to alter variables and re-render
+    // CSS without reloading less-files
+    //
+    less.modifyVars = function(record) {
+        return less.refresh(true, record, false);
+    };
 
-        loadStyleSheets(function (e, css, _, sheet, webInfo) {
-            if (e) {
-                errors.add(e, e.href || sheet.href);
-                reject(e);
-                return;
-            }
-            if (webInfo.local) {
-                less.logger.info("loading " + sheet.href + " from cache.");
-            } else {
-                less.logger.info("rendered " + sheet.href + " successfully.");
-                css = postProcessCSS(css);
+    less.refresh = function (reload, modifyVars, clearFileCache) {
+        if ((reload || clearFileCache) && clearFileCache !== false) {
+            fileManager.clearFileCache();
+        }
+        return new Promise(function (resolve, reject) {
+            var startTime, endTime, totalMilliseconds;
+            startTime = endTime = new Date();
+
+            loadStyleSheets(function (e, css, _, sheet, webInfo) {
+                if (e) {
+                    errors.add(e, e.href || sheet.href);
+                    reject(e);
+                    return;
+                }
+                if (webInfo.local) {
+                    less.logger.info("loading " + sheet.href + " from cache.");
+                } else {
+                    less.logger.info("rendered " + sheet.href + " successfully.");
+                }
                 browser.createCSS(window.document, css, sheet);
-                cache.setCSS(sheet.href, webInfo.lastModified, css);
-            }
-            less.logger.info("css for " + sheet.href + " generated in " + (new Date() - endTime) + 'ms');
-            if (webInfo.remaining === 0) {
-                totalMilliseconds = new Date() - startTime;
-                less.logger.info("less has finished. css generated in " + totalMilliseconds + 'ms');
-                resolve({
-                    startTime: startTime,
-                    endTime: endTime,
-                    totalMilliseconds: totalMilliseconds,
-                    sheets: less.sheets.length
-                });
-            }
-            endTime = new Date();
-        }, reload, modifyVars);
-
-        loadStyles(modifyVars);
-    });
-};
+                less.logger.info("css for " + sheet.href + " generated in " + (new Date() - endTime) + 'ms');
+                if (webInfo.remaining === 0) {
+                    totalMilliseconds = new Date() - startTime;
+                    less.logger.info("less has finished. css generated in " + totalMilliseconds + 'ms');
+                    resolve({
+                        startTime: startTime,
+                        endTime: endTime,
+                        totalMilliseconds: totalMilliseconds,
+                        sheets: less.sheets.length
+                    });
+                }
+                endTime = new Date();
+            }, reload, modifyVars);
+
+            loadStyles(modifyVars);
+        });
+    };
 
-less.refreshStyles = loadStyles;
+    less.refreshStyles = loadStyles;
     return less;
 };

package/lib/less-browser/log-listener.js

@@ -11,7 +11,7 @@ module.exports = function(less, options) {
     // 1 - Errors
     // 0 - None
     // Defaults to 2
-    options.logLevel = typeof(options.logLevel) !== 'undefined' ? options.logLevel : (options.env === 'development' ?  logLevel_info : logLevel_error);
+    options.logLevel = typeof options.logLevel !== 'undefined' ? options.logLevel : (options.env === 'development' ?  logLevel_info : logLevel_error);
 
     if (!options.loggers) {
         options.loggers = [{
@@ -37,7 +37,7 @@ module.exports = function(less, options) {
             }
         }];
     }
-    for(var i = 0; i < options.loggers.length; i++) {
+    for (var i = 0; i < options.loggers.length; i++) {
         less.logger.addListener(options.loggers[i]);
     }
 };

package/lib/less-browser/utils.js

@@ -1,11 +1,11 @@
 module.exports = {
     extractId: function(href) {
-        return href.replace(/^[a-z-]+:\/+?[^\/]+/, '' )  // Remove protocol & domain
-            .replace(/[\?\&]livereload=\w+/,'' )  // Remove LiveReload cachebuster
-            .replace(/^\//,                 '' )  // Remove root /
-            .replace(/\.[a-zA-Z]+$/,        '' )  // Remove simple extension
-            .replace(/[^\.\w-]+/g,          '-')  // Replace illegal characters
-            .replace(/\./g,                 ':'); // Replace dots with colons(for valid id)
+        return href.replace(/^[a-z-]+:\/+?[^\/]+/, '')  // Remove protocol & domain
+            .replace(/[\?\&]livereload=\w+/, '')        // Remove LiveReload cachebuster
+            .replace(/^\//, '')                         // Remove root /
+            .replace(/\.[a-zA-Z]+$/, '')                // Remove simple extension
+            .replace(/[^\.\w-]+/g, '-')                 // Replace illegal characters
+            .replace(/\./g, ':');                       // Replace dots with colons(for valid id)
     },
     addDataAttr: function(options, tag) {
         for (var opt in tag.dataset) {

package/lib/less-node/file-manager.js

@@ -1,8 +1,13 @@
 var path = require('path'),
     fs = require('./fs'),
-    PromiseConstructor = typeof Promise === 'undefined' ? require('promise') : Promise,
+    PromiseConstructor,
     AbstractFileManager = require("../less/environment/abstract-file-manager.js");
 
+try {
+    PromiseConstructor = typeof Promise === 'undefined' ? require('promise') : Promise;
+} catch(e) {
+}
+
 var FileManager = function() {
 };
 
@@ -17,45 +22,35 @@ FileManager.prototype.supportsSync = function(filename, currentDirectory, option
 
 FileManager.prototype.loadFile = function(filename, currentDirectory, options, environment, callback) {
     var fullFilename,
-        data;
+        data,
+        isAbsoluteFilename = this.isPathAbsolute(filename),
+        filenamesTried = [];
 
     options = options || {};
 
-    var paths = [currentDirectory];
-    if (options.paths) paths.push.apply(paths, options.paths);
-    if (paths.indexOf('.') === -1) paths.push('.');
-
-    if (options.syncImport) {
-        var err, result;
-        for (var i = 0; i < paths.length; i++) {
-            try {
-                fullFilename = path.join(paths[i], filename);
-                fs.statSync(fullFilename);
-                break;
-            } catch (e) {
-                fullFilename = null;
-            }
-        }
-
-        if (!fullFilename) {
-            err = { type: 'File', message: "'" + filename + "' wasn't found" };
-        } else {
-            data = fs.readFileSync(fullFilename, 'utf-8');
-            result = { contents: data, filename: fullFilename};
-        }
-        callback(err, result);
+    if (options.syncImport || !PromiseConstructor) {
+        data = this.loadFileSync(filename, currentDirectory, options, environment, 'utf-8');
+        callback(data.error, data);
         return;
     }
 
+    var paths = isAbsoluteFilename ? [""] : [currentDirectory];
+    if (options.paths) { paths.push.apply(paths, options.paths); }
+    if (!isAbsoluteFilename && paths.indexOf('.') === -1) { paths.push('.'); }
+
     // promise is guarenteed to be asyncronous
     // which helps as it allows the file handle
     // to be closed before it continues with the next file
     return new PromiseConstructor(function(fulfill, reject) {
         (function tryPathIndex(i) {
             if (i < paths.length) {
-                fullFilename = path.join(paths[i], filename);
+                fullFilename = filename;
+                if (paths[i]) {
+                    fullFilename = path.join(paths[i], fullFilename);
+                }
                 fs.stat(fullFilename, function (err) {
                     if (err) {
+                        filenamesTried.push(fullFilename);
                         tryPathIndex(i + 1);
                     } else {
                         fs.readFile(fullFilename, 'utf-8', function(e, data) {
@@ -66,15 +61,48 @@ FileManager.prototype.loadFile = function(filename, currentDirectory, options, e
                     }
                 });
             } else {
-                reject({ type: 'File', message: "'" + filename + "' wasn't found" });
+                reject({ type: 'File', message: "'" + filename + "' wasn't found. Tried - " + filenamesTried.join(",") });
             }
         }(0));
     });
 };
 
-FileManager.prototype.loadFileSync = function(filename, currentDirectory, options, environment) {
-    filename = path.join(currentDirectory, filename);
-    return { contents: fs.readFileSync(filename), filename: filename };
+FileManager.prototype.loadFileSync = function(filename, currentDirectory, options, environment, encoding) {
+    var fullFilename, paths, filenamesTried = [], isAbsoluteFilename = this.isPathAbsolute(filename) , data;
+    options = options || {};
+
+    paths = isAbsoluteFilename ? [""] : [currentDirectory];
+    if (options.paths) {
+        paths.push.apply(paths, options.paths);
+    }
+    if (!isAbsoluteFilename && paths.indexOf('.') === -1) {
+        paths.push('.');
+    }
+
+    var err, result;
+    for (var i = 0; i < paths.length; i++) {
+        try {
+            fullFilename = filename;
+            if (paths[i]) {
+                fullFilename = path.join(paths[i], fullFilename);
+            }
+            filenamesTried.push(fullFilename);
+            fs.statSync(fullFilename);
+            break;
+        } catch (e) {
+            fullFilename = null;
+        }
+    }
+
+    if (!fullFilename) {
+        err = { type: 'File', message: "'" + filename + "' wasn't found. Tried - " + filenamesTried.join(",") };
+        result = { error: err };
+    } else {
+        data = fs.readFileSync(fullFilename, encoding);
+        result = { contents: data, filename: fullFilename};
+    }
+
+    return result;
 };
 
 module.exports = FileManager;

package/lib/less-node/image-size.js

@@ -0,0 +1,34 @@
+var Dimension = require("../less/tree/dimension"),
+    Expression = require("../less/tree/expression"),
+    functionRegistry = require("./../less/functions/function-registry"),
+    path = require("path");
+
+function imageSize(filePathNode) {
+    var filePath = filePathNode.value;
+    var currentDirectory = filePathNode.currentFileInfo.relativeUrls ?
+        filePathNode.currentFileInfo.currentDirectory : filePathNode.currentFileInfo.entryPath;
+
+    var sizeOf = require('image-size');
+    filePath = path.join(currentDirectory, filePath);
+    return sizeOf(filePath);
+}
+
+var imageFunctions = {
+    "image-size": function(filePathNode) {
+        var size = imageSize(filePathNode);
+        return new Expression([
+            new Dimension(size.width, "px"),
+            new Dimension(size.height, "px")
+        ]);
+    },
+    "image-width": function(filePathNode) {
+        var size = imageSize(filePathNode);
+        return new Dimension(size.width, "px");
+    },
+    "image-height": function(filePathNode) {
+        var size = imageSize(filePathNode);
+        return new Dimension(size.height, "px");
+    }
+};
+
+functionRegistry.addMultiple(imageFunctions);