less 3.0.0-pre.2 → 3.0.1

package/lib/less/contexts.js

@@ -40,18 +40,18 @@ contexts.Parse = function(options) {
 };
 
 var evalCopyProperties = [
-    'paths',          // additional include paths
-    'compress',       // whether to compress
-    'ieCompat',       // whether to enforce IE compatibility (IE8 data-uri)
-    'strictMath',     // whether math has to be within parenthesis
-    'strictUnits',    // whether units need to evaluate correctly
-    'sourceMap',      // whether to output a source map
-    'importMultiple', // whether we are currently importing multiple copies
-    'urlArgs',        // whether to add args into url tokens
-    'javascriptEnabled',// option - whether Inline JavaScript is enabled. if undefined, defaults to false
-    'pluginManager',  // Used as the plugin manager for the session
-    'importantScope'  // used to bubble up !important statements
-    ];
+    'paths',             // additional include paths
+    'compress',          // whether to compress
+    'ieCompat',          // whether to enforce IE compatibility (IE8 data-uri)
+    'strictMath',        // whether math has to be within parenthesis
+    'strictUnits',       // whether units need to evaluate correctly
+    'sourceMap',         // whether to output a source map
+    'importMultiple',    // whether we are currently importing multiple copies
+    'urlArgs',           // whether to add args into url tokens
+    'javascriptEnabled', // option - whether Inline JavaScript is enabled. if undefined, defaults to false
+    'pluginManager',     // Used as the plugin manager for the session
+    'importantScope'     // used to bubble up !important statements
+];
 
 contexts.Eval = function(options, frames) {
     copyFromOriginal(options, this, evalCopyProperties);
@@ -73,7 +73,11 @@ contexts.Eval.prototype.outOfParenthesis = function () {
     this.parensStack.pop();
 };
 
+contexts.Eval.prototype.mathOn = true;
 contexts.Eval.prototype.isMathOn = function () {
+    if (!this.mathOn) {
+        return false;
+    }
     return this.strictMath ? (this.parensStack && this.parensStack.length) : true;
 };
 
@@ -83,13 +87,13 @@ contexts.Eval.prototype.isPathRelative = function (path) {
 
 contexts.Eval.prototype.normalizePath = function( path ) {
     var
-      segments = path.split("/").reverse(),
-      segment;
+        segments = path.split("/").reverse(),
+        segment;
 
     path = [];
     while (segments.length !== 0 ) {
         segment = segments.pop();
-        switch( segment ) {
+        switch ( segment ) {
             case ".":
                 break;
             case "..":
@@ -108,4 +112,4 @@ contexts.Eval.prototype.normalizePath = function( path ) {
     return path.join("/");
 };
 
-//todo - do the same for the toCSS ?
+// todo - do the same for the toCSS ?

package/lib/less/default-options.js

@@ -0,0 +1,65 @@
+// Export a new default each time
+module.exports = function() {
+    return {
+        /* Outputs a makefile import dependency list to stdout. */
+        depends: false,
+
+        /* Compress using less built-in compression. 
+         * This does an okay job but does not utilise all the tricks of 
+         * dedicated css compression. */
+        compress: false,
+
+        /* Runs the less parser and just reports errors without any output. */
+        lint: false,
+
+        /* Sets available include paths.
+         * If the file in an @import rule does not exist at that exact location, 
+         * less will look for it at the location(s) passed to this option. 
+         * You might use this for instance to specify a path to a library which 
+         * you want to be referenced simply and relatively in the less files. */
+        paths: [],
+
+        /* color output in the terminal */
+        color: true,
+
+        /* The strictImports controls whether the compiler will allow an @import inside of either 
+         * @media blocks or (a later addition) other selector blocks.
+         * See: https://github.com/less/less.js/issues/656 */
+        strictImports: false,
+
+        /* Allow Imports from Insecure HTTPS Hosts */
+        insecure: false,
+
+        /* Allows you to add a path to every generated import and url in your css. 
+         * This does not affect less import statements that are processed, just ones 
+         * that are left in the output css. */
+        rootpath: '',
+
+        /* By default URLs are kept as-is, so if you import a file in a sub-directory 
+         * that references an image, exactly the same URL will be output in the css. 
+         * This option allows you to re-write URL's in imported files so that the 
+         * URL is always relative to the base imported file */
+        relativeUrls: false,
+
+        /* Compatibility with IE8. Used for limiting data-uri length */
+        ieCompat: false,  // true until 3.0
+
+        /* Without this option on, Less will try and process all math in your css */
+        strictMath: false,
+
+        /* Without this option, less attempts to guess at the output unit when it does maths. */
+        strictUnits: false,
+
+        /* Effectively the declaration is put at the top of your base Less file, 
+         * meaning it can be used but it also can be overridden if this variable 
+         * is defined in the file. */
+        globalVars: null,
+
+        /* As opposed to the global variable option, this puts the declaration at the
+         * end of your base file, meaning it will override anything defined in your Less file. */
+        modifyVars: null,
+
+        /* This option allows you to specify a argument to go on to every URL.  */
+        urlArgs: ''
+    }
+}

package/lib/less/environment/abstract-file-manager.js

@@ -35,7 +35,7 @@ abstractFileManager.prototype.alwaysMakePathsAbsolute = function() {
 abstractFileManager.prototype.isPathAbsolute = function(filename) {
     return (/^(?:[a-z-]+:|\/|\\|#)/i).test(filename);
 };
-// TODO: pull out - this is part of Node & Browserify
+// TODO: pull out / replace?
 abstractFileManager.prototype.join = function(basePath, laterPath) {
     if (!basePath) {
         return laterPath;
@@ -76,7 +76,7 @@ abstractFileManager.prototype.extractUrlParts = function extractUrlParts(url, ba
 
     var urlPartsRegex = /^((?:[a-z-]+:)?\/{2}(?:[^\/\?#]*\/)|([\/\\]))?((?:[^\/\\\?#]*[\/\\])*)([^\/\\\?#]*)([#\?].*)?$/i,
         urlParts = url.match(urlPartsRegex),
-        returner = {}, directories = [], i, baseUrlParts;
+        returner = {}, rawDirectories = [], directories = [], i, baseUrlParts;
 
     if (!urlParts) {
         throw new Error("Could not parse sheet href - '" + url + "'");
@@ -95,27 +95,26 @@ abstractFileManager.prototype.extractUrlParts = function extractUrlParts(url, ba
     }
 
     if (urlParts[3]) {
-        directories = urlParts[3].replace(/\\/g, "/").split("/");
+        rawDirectories = urlParts[3].replace(/\\/g, "/").split("/");
 
-        // extract out . before .. so .. doesn't absorb a non-directory
-        for (i = 0; i < directories.length; i++) {
-            if (directories[i] === ".") {
-                directories.splice(i, 1);
-                i -= 1;
-            }
-        }
+        // collapse '..' and skip '.'
+        for (i = 0; i < rawDirectories.length; i++) {
 
-        for (i = 0; i < directories.length; i++) {
-            if (directories[i] === ".." && i > 0) {
-                directories.splice(i - 1, 2);
-                i -= 2;
+            if (rawDirectories[i] === "..") {
+                directories.pop();
+            }
+            else if (rawDirectories[i] !== ".") {
+                directories.push(rawDirectories[i]);
             }
+        
         }
     }
 
     returner.hostPart = urlParts[1];
     returner.directories = directories;
+    returner.rawPath = (urlParts[1] || "") + rawDirectories.join("/");
     returner.path = (urlParts[1] || "") + directories.join("/");
+    returner.filename = urlParts[4];
     returner.fileUrl = returner.path + (urlParts[4] || "");
     returner.url = returner.fileUrl + (urlParts[5] || "");
     return returner;

package/lib/less/environment/abstract-plugin-loader.js

@@ -12,13 +12,12 @@ function error(msg, type) {
         }
     );
 }
-AbstractPluginLoader.prototype.evalPlugin = function(contents, context, pluginOptions, fileInfo) {
+AbstractPluginLoader.prototype.evalPlugin = function(contents, context, imports, pluginOptions, fileInfo) {
 
     var loader,
         registry,
         pluginObj,
         localModule,
-        localExports,
         pluginManager,
         filename;
 
@@ -32,13 +31,21 @@ AbstractPluginLoader.prototype.evalPlugin = function(contents, context, pluginOp
             filename = fileInfo.filename;
         }
     }
+    var shortname = (new this.less.FileManager()).extractUrlParts(filename).filename;
+
     if (filename) {
         pluginObj = pluginManager.get(filename);
 
         if (pluginObj) {
-            this.trySetOptions(pluginObj, filename, pluginOptions);
-            if (pluginObj.use) {
-                pluginObj.use(this.less);
+            this.trySetOptions(pluginObj, filename, shortname, pluginOptions);
+            try {
+                if (pluginObj.use) {
+                    pluginObj.use.call(this.context, pluginObj);
+                }
+            }
+            catch (e) {
+                e.message = 'Error during @plugin call';
+                return new this.less.LessError(e, imports, filename);
             }
             return pluginObj;
         }
@@ -48,52 +55,54 @@ AbstractPluginLoader.prototype.evalPlugin = function(contents, context, pluginOp
         pluginManager: pluginManager,
         fileInfo: fileInfo
     };
-    localExports = localModule.exports;
     registry = functionRegistry.create();
 
-    try {
-        loader = new Function("module", "require", "functions", "tree", "fileInfo", contents);
-        pluginObj = loader(localModule, this.require, registry, this.less.tree, fileInfo);
+    var registerPlugin = function(obj) {
+        pluginObj = obj;
+    };
 
-        if (!pluginObj) {
-            pluginObj = localModule.exports;
-        }
+    try {
+        loader = new Function("module", "require", "registerPlugin", "functions", "tree", "less", "fileInfo", contents);
+        loader(localModule, this.require, registerPlugin, registry, this.less.tree, this.less, fileInfo);
+    } catch (e) {
+        return new this.less.LessError(e, imports, filename);
+    }
 
-        pluginObj = this.validatePlugin(pluginObj, filename);
+    if (!pluginObj) {
+        pluginObj = localModule.exports;
+    }
+    pluginObj = this.validatePlugin(pluginObj, filename, shortname);
 
-        if (pluginObj) {
-            // Run on first load
-            pluginManager.addPlugin(pluginObj, fileInfo.filename);
-            pluginObj.functions = registry.getLocalFunctions();
+    if (pluginObj) {
+        // Run on first load
+        pluginManager.addPlugin(pluginObj, fileInfo.filename, registry);
+        pluginObj.functions = registry.getLocalFunctions();
+        pluginObj.imports = imports;
+        pluginObj.filename = filename;
 
-            this.trySetOptions(pluginObj, filename, pluginOptions);
+        this.trySetOptions(pluginObj, filename, shortname, pluginOptions);
 
-            // Run every @plugin call
+        // Run every @plugin call
+        try {
             if (pluginObj.use) {
-                pluginObj.use(this.less);
+                pluginObj.use.call(this.context, pluginObj);
             }
         }
-        else {
-            throw new SyntaxError("Not a valid plugin");
+        catch (e) {
+            e.message = 'Error during @plugin call';
+            return new this.less.LessError(e, imports, filename);
         }
 
-    } catch(e) {
-        // TODO pass the error
-        console.log(e);
-        return new this.less.LessError({
-            message: "Plugin evaluation error: '" + e.name + ': ' + e.message.replace(/["]/g, "'") + "'" ,
-            filename: filename,
-            line: this.line,
-            col: this.column
-        });
+    }
+    else {
+        return new this.less.LessError({ message: "Not a valid plugin" });
     }
 
     return pluginObj;
 
 };
 
-AbstractPluginLoader.prototype.trySetOptions = function(plugin, filename, options) {
-    var name = require('path').basename(filename);
+AbstractPluginLoader.prototype.trySetOptions = function(plugin, filename, name, options) {
     if (options) {
         if (!plugin.setOptions) {
             error("Options have been provided but the plugin " + name + " does not support any options.");
@@ -102,21 +111,21 @@ AbstractPluginLoader.prototype.trySetOptions = function(plugin, filename, option
         try {
             plugin.setOptions(options);
         }
-        catch(e) {
+        catch (e) {
             error("Error setting options on plugin " + name + '\n' + e.message);
             return null;
         }
     }
 };
 
-AbstractPluginLoader.prototype.validatePlugin = function(plugin, filename) {
+AbstractPluginLoader.prototype.validatePlugin = function(plugin, filename, name) {
     if (plugin) {
         // support plugins being a function
         // so that the plugin can be more usable programmatically
         if (typeof plugin === "function") {
             plugin = new plugin();
         }
-        var name = require('path').basename(filename);
+
         if (plugin.minVersion) {
             if (this.compareVersion(plugin.minVersion, this.less.version) < 0) {
                 error("Plugin " + name + " requires version " + this.versionToString(plugin.minVersion));

package/lib/less/environment/environment.js

@@ -1,3 +1,8 @@
+/**
+ * @todo Document why this abstraction exists, and the relationship between
+ *       environment, file managers, and plugin manager
+ */
+
 var logger = require("../logger");
 var environment = function(externalEnvironment, fileManagers) {
     this.fileManagers = fileManagers || [];

package/lib/less/functions/boolean.js

@@ -0,0 +1,15 @@
+
+var functionRegistry = require("./function-registry"),
+    Anonymous = require("../tree/anonymous"),
+    Keyword = require("../tree/keyword");
+
+functionRegistry.addMultiple({
+    boolean: function(condition) {
+        return condition ? Keyword.True : Keyword.False;
+    },
+
+    'if': function(condition, trueValue, falseValue) {
+        return condition ? trueValue
+            : (falseValue || new Anonymous);
+    }
+});

package/lib/less/functions/color.js

@@ -266,43 +266,73 @@ colorFunctions = {
     greyscale: function (color) {
         return colorFunctions.desaturate(color, new Dimension(100));
     },
-    contrast: function (color, color1, color2, threshold) {
-        // Return which of `color1` and `color2` has the greatest contrast with `color`
-        // according to the standard WCAG contrast ratio calculation.
-        // http://www.w3.org/TR/WCAG20/#contrast-ratiodef
-        // The threshold param is no longer used, in line with SASS.
+    contrast: function (color, dark, light, threshold) {
         // filter: contrast(3.2);
         // should be kept as is, so check for color
         if (!color.rgb) {
             return null;
         }
-        if (typeof color1 === 'undefined') {
-            color1 = colorFunctions.rgba(0, 0, 0, 1.0);
+        if (typeof light === 'undefined') {
+            light = colorFunctions.rgba(255, 255, 255, 1.0);
         }
-        if (typeof color2 === 'undefined') {
-            color2 = colorFunctions.rgba(255, 255, 255, 1.0);
+        if (typeof dark === 'undefined') {
+            dark = colorFunctions.rgba(0, 0, 0, 1.0);
         }
-        var contrast1, contrast2;
-        var luma = color.luma();
-        var luma1 = color1.luma();
-        var luma2 = color2.luma();
-        // Calculate contrast ratios for each color
-        if (luma > luma1) {
-            contrast1 = (luma + 0.05) / (luma1 + 0.05);
-        } else {
-            contrast1 = (luma1 + 0.05) / (luma + 0.05);
+        // Figure out which is actually light and dark:
+        if (dark.luma() > light.luma()) {
+            var t = light;
+            light = dark;
+            dark = t;
         }
-        if (luma > luma2) {
-            contrast2 = (luma + 0.05) / (luma2 + 0.05);
+        if (typeof threshold === 'undefined') {
+            threshold = 0.43;
         } else {
-            contrast2 = (luma2 + 0.05) / (luma + 0.05);
+            threshold = number(threshold);
         }
-        if (contrast1 > contrast2) {
-            return color1;
+        if (color.luma() < threshold) {
+            return light;
         } else {
-            return color2;
+            return dark;
         }
     },
+    // Changes made in 2.7.0 - Reverted in 3.0.0
+    // contrast: function (color, color1, color2, threshold) {
+    //     // Return which of `color1` and `color2` has the greatest contrast with `color`
+    //     // according to the standard WCAG contrast ratio calculation.
+    //     // http://www.w3.org/TR/WCAG20/#contrast-ratiodef
+    //     // The threshold param is no longer used, in line with SASS.
+    //     // filter: contrast(3.2);
+    //     // should be kept as is, so check for color
+    //     if (!color.rgb) {
+    //         return null;
+    //     }
+    //     if (typeof color1 === 'undefined') {
+    //         color1 = colorFunctions.rgba(0, 0, 0, 1.0);
+    //     }
+    //     if (typeof color2 === 'undefined') {
+    //         color2 = colorFunctions.rgba(255, 255, 255, 1.0);
+    //     }
+    //     var contrast1, contrast2;
+    //     var luma = color.luma();
+    //     var luma1 = color1.luma();
+    //     var luma2 = color2.luma();
+    //     // Calculate contrast ratios for each color
+    //     if (luma > luma1) {
+    //         contrast1 = (luma + 0.05) / (luma1 + 0.05);
+    //     } else {
+    //         contrast1 = (luma1 + 0.05) / (luma + 0.05);
+    //     }
+    //     if (luma > luma2) {
+    //         contrast2 = (luma + 0.05) / (luma2 + 0.05);
+    //     } else {
+    //         contrast2 = (luma2 + 0.05) / (luma + 0.05);
+    //     }
+    //     if (contrast1 > contrast2) {
+    //         return color1;
+    //     } else {
+    //         return color2;
+    //     }
+    // },
     argb: function (color) {
         return new Anonymous(color.toARGB());
     },

package/lib/less/functions/data-uri.js

@@ -1,6 +1,7 @@
 module.exports = function(environment) {
     var Quoted = require("../tree/quoted"),
         URL = require("../tree/url"),
+        utils = require('../utils'),
         functionRegistry = require("./function-registry"),
         fallback = function(functionThis, node) {
             return new URL(node, functionThis.index, functionThis.currentFileInfo).eval(functionThis.context);
@@ -26,8 +27,10 @@ module.exports = function(environment) {
             fragment = filePath.slice(fragmentStart);
             filePath = filePath.slice(0, fragmentStart);
         }
+        var context = utils.clone(this.context);
+        context.rawBuffer = true;
 
-        var fileManager = environment.getFileManager(filePath, currentDirectory, this.context, environment, true);
+        var fileManager = environment.getFileManager(filePath, currentDirectory, context, environment, true);
 
         if (!fileManager) {
             return fallback(this, filePathNode);
@@ -53,7 +56,7 @@ module.exports = function(environment) {
             useBase64 = /;base64$/.test(mimetype);
         }
 
-        var fileSync = fileManager.loadFileSync(filePath, currentDirectory, this.context, environment);
+        var fileSync = fileManager.loadFileSync(filePath, currentDirectory, context, environment);
         if (!fileSync.contents) {
             logger.warn("Skipped data-uri embedding of " + filePath + " because file not found");
             return fallback(this, filePathNode || mimetypeNode);

package/lib/less/functions/function-registry.js

@@ -7,7 +7,7 @@ function makeRegistry( base ) {
             name = name.toLowerCase();
 
             if (this._data.hasOwnProperty(name)) {
-                //TODO warn
+                // TODO warn
             }
             this._data[name] = func;
         },

package/lib/less/functions/index.js

@@ -4,7 +4,8 @@ module.exports = function(environment) {
         functionCaller: require("./function-caller")
     };
 
-    //register functions
+    // register functions
+    require("./boolean");
     require("./default");
     require("./color");
     require("./color-blending");

package/lib/less/functions/number.js

@@ -5,7 +5,7 @@ var Dimension = require("../tree/dimension"),
 
 var minMax = function (isMin, args) {
     args = Array.prototype.slice.call(args);
-    switch(args.length) {
+    switch (args.length) {
         case 0: throw { type: "Argument", message: "one or more arguments required" };
     }
     var i, j, current, currentUnified, referenceUnified, unit, unitStatic, unitClone,
@@ -27,7 +27,7 @@ var minMax = function (isMin, args) {
         j = values[""] !== undefined && unit !== "" && unit === unitStatic ? values[""] : values[unit];
         if (j === undefined) {
             if (unitStatic !== undefined && unit !== unitStatic) {
-                throw{ type: "Argument", message: "incompatible types" };
+                throw { type: "Argument", message: "incompatible types" };
             }
             values[unit] = order.length;
             order.push(current);

package/lib/less/functions/string.js

@@ -19,12 +19,12 @@ functionRegistry.addMultiple({
         result = result.replace(new RegExp(pattern.value, flags ? flags.value : ''), replacement);
         return new Quoted(string.quote || '', result, string.escaped);
     },
-    '%': function (string /* arg, arg, ...*/) {
+    '%': function (string /* arg, arg, ... */) {
         var args = Array.prototype.slice.call(arguments, 1),
             result = string.value;
 
         for (var i = 0; i < args.length; i++) {
-            /*jshint loopfunc:true */
+            /* jshint loopfunc:true */
             result = result.replace(/%[sda]/i, function(token) {
                 var value = ((args[i].type === "Quoted") &&
                     token.match(/s/i)) ? args[i].value : args[i].toCSS();

package/lib/less/functions/svg.js

@@ -15,12 +15,12 @@ module.exports = function(environment) {
             renderEnv = {compress: false},
             returner,
             directionValue = direction.toCSS(renderEnv),
-			i, color, position, positionValue, alpha;
+            i, color, position, positionValue, alpha;
 
         function throwArgumentDescriptor() {
             throw { type: "Argument",
-					message: "svg-gradient expects direction, start_color [start_position], [color position,]...," +
-							" end_color [end_position] or direction, color list" };
+                message: "svg-gradient expects direction, start_color [start_position], [color position,]...," +
+                            " end_color [end_position] or direction, color list" };
         }
 
         if (arguments.length == 2) {
@@ -61,7 +61,7 @@ module.exports = function(environment) {
             '<svg xmlns="http://www.w3.org/2000/svg" version="1.1" width="100%" height="100%" viewBox="0 0 1 1" preserveAspectRatio="none">' +
             '<' + gradientType + 'Gradient id="gradient" gradientUnits="userSpaceOnUse" ' + gradientDirectionSvg + '>';
 
-        for (i = 0; i < stops.length; i+= 1) {
+        for (i = 0; i < stops.length; i += 1) {
             if (stops[i] instanceof Expression) {
                 color = stops[i].value[0];
                 position = stops[i].value[1];