less 2.5.1 → 2.6.1

package/lib/less/visitors/to-css-visitor.js

@@ -1,9 +1,97 @@
 var tree = require("../tree"),
     Visitor = require("./visitor");
 
+var CSSVisitorUtils = function(context) {
+    this._visitor = new Visitor(this);
+    this._context = context;
+};
+
+CSSVisitorUtils.prototype = {
+    containsSilentNonBlockedChild: function(bodyRules) {
+        var rule;
+        if (bodyRules == null) {
+            return false;
+        }
+        for (var r = 0; r < bodyRules.length; r++) {
+            rule = bodyRules[r];
+            if (rule.isSilent && rule.isSilent(this._context) && !rule.blocksVisibility()) {
+                //the directive contains something that was referenced (likely by extend)
+                //therefore it needs to be shown in output too
+                return true;
+            }
+        }
+        return false;
+    },
+
+    keepOnlyVisibleChilds: function(owner) {
+        if (owner == null || owner.rules == null) {
+            return ;
+        }
+
+        owner.rules = owner.rules.filter(function(thing) {
+                return thing.isVisible();
+            }
+        );
+    },
+
+    isEmpty: function(owner) {
+        if (owner == null || owner.rules == null) {
+            return true;
+        }
+        return owner.rules.length === 0;
+    },
+
+    hasVisibleSelector: function(rulesetNode) {
+        if (rulesetNode == null || rulesetNode.paths == null) {
+            return false;
+        }
+        return rulesetNode.paths.length > 0;
+    },
+
+    resolveVisibility: function (node, originalRules) {
+        if (!node.blocksVisibility()) {
+            if (this.isEmpty(node) && !this.containsSilentNonBlockedChild(originalRules)) {
+                return ;
+            }
+
+            return node;
+        }
+
+        var compiledRulesBody = node.rules[0];
+        this.keepOnlyVisibleChilds(compiledRulesBody);
+
+        if (this.isEmpty(compiledRulesBody)) {
+            return ;
+        }
+
+        node.ensureVisibility();
+        node.removeVisibilityBlock();
+
+        return node;
+    },
+
+    isVisibleRuleset: function(rulesetNode) {
+        if (rulesetNode.firstRoot) {
+            return true;
+        }
+
+        if (this.isEmpty(rulesetNode)) {
+            return false;
+        }
+
+        if (!rulesetNode.root && !this.hasVisibleSelector(rulesetNode)) {
+            return false;
+        }
+
+        return true;
+    }
+
+};
+
 var ToCSSVisitor = function(context) {
     this._visitor = new Visitor(this);
     this._context = context;
+    this.utils = new CSSVisitorUtils(context);
 };
 
 ToCSSVisitor.prototype = {
@@ -13,7 +101,7 @@ ToCSSVisitor.prototype = {
     },
 
     visitRule: function (ruleNode, visitArgs) {
-        if (ruleNode.variable) {
+        if (ruleNode.blocksVisibility() || ruleNode.variable) {
             return;
         }
         return ruleNode;
@@ -29,34 +117,71 @@ ToCSSVisitor.prototype = {
     },
 
     visitComment: function (commentNode, visitArgs) {
-        if (commentNode.isSilent(this._context)) {
+        if (commentNode.blocksVisibility() || commentNode.isSilent(this._context)) {
             return;
         }
         return commentNode;
     },
 
     visitMedia: function(mediaNode, visitArgs) {
+        var originalRules = mediaNode.rules[0].rules;
         mediaNode.accept(this._visitor);
         visitArgs.visitDeeper = false;
 
-        if (!mediaNode.rules.length) {
-            return;
-        }
-        return mediaNode;
+        return this.utils.resolveVisibility(mediaNode, originalRules);
     },
 
     visitImport: function (importNode, visitArgs) {
-        if (importNode.path.currentFileInfo.reference !== undefined && importNode.css) {
-            return;
+        if (importNode.blocksVisibility()) {
+            return ;
         }
         return importNode;
     },
 
     visitDirective: function(directiveNode, visitArgs) {
-        if (directiveNode.name === "@charset") {
-            if (!directiveNode.getIsReferenced()) {
-                return;
+        if (directiveNode.rules && directiveNode.rules.length) {
+            return this.visitDirectiveWithBody(directiveNode, visitArgs);
+        } else {
+            return this.visitDirectiveWithoutBody(directiveNode, visitArgs);
+        }
+        return directiveNode;
+    },
+
+    visitDirectiveWithBody: function(directiveNode, visitArgs) {
+        //if there is only one nested ruleset and that one has no path, then it is
+        //just fake ruleset
+        function hasFakeRuleset(directiveNode) {
+            var bodyRules = directiveNode.rules;
+            return bodyRules.length === 1 && (!bodyRules[0].paths || bodyRules[0].paths.length === 0);
+        }
+        function getBodyRules(directiveNode) {
+            var nodeRules = directiveNode.rules;
+            if (hasFakeRuleset(directiveNode)) {
+                return nodeRules[0].rules;
             }
+
+            return nodeRules;
+        }
+        //it is still true that it is only one ruleset in array
+        //this is last such moment
+        //process childs
+        var originalRules = getBodyRules(directiveNode);
+        directiveNode.accept(this._visitor);
+        visitArgs.visitDeeper = false;
+
+        if (!this.utils.isEmpty(directiveNode)) {
+            this._mergeRules(directiveNode.rules[0].rules);
+        }
+
+        return this.utils.resolveVisibility(directiveNode, originalRules);
+    },
+
+    visitDirectiveWithoutBody: function(directiveNode, visitArgs) {
+        if (directiveNode.blocksVisibility()) {
+            return;
+        }
+
+        if (directiveNode.name === "@charset") {
             // Only output the debug info together with subsequent @charset definitions
             // a comment (or @media statement) before the actual @charset directive would
             // be considered illegal css as it has to be on the first line
@@ -70,59 +195,7 @@ ToCSSVisitor.prototype = {
             }
             this.charset = true;
         }
-        function hasVisibleChild(directiveNode) {
-            //prepare list of childs
-            var rule, bodyRules = directiveNode.rules;
-            //if there is only one nested ruleset and that one has no path, then it is
-            //just fake ruleset that got not replaced and we need to look inside it to
-            //get real childs
-            if (bodyRules.length === 1 && (!bodyRules[0].paths || bodyRules[0].paths.length === 0)) {
-                bodyRules = bodyRules[0].rules;
-            }
-            for (var r = 0; r < bodyRules.length; r++) {
-                rule = bodyRules[r];
-                if (rule.getIsReferenced && rule.getIsReferenced()) {
-                    //the directive contains something that was referenced (likely by extend)
-                    //therefore it needs to be shown in output too
-                    return true;
-                }
-            }
-            return false;
-        }
-
-        if (directiveNode.rules && directiveNode.rules.length) {
-            //it is still true that it is only one ruleset in array
-            //this is last such moment
-            this._mergeRules(directiveNode.rules[0].rules);
-            //process childs
-            directiveNode.accept(this._visitor);
-            visitArgs.visitDeeper = false;
-
-            // the directive was directly referenced and therefore needs to be shown in the output
-            if (directiveNode.getIsReferenced()) {
-                return directiveNode;
-            }
-
-            if (!directiveNode.rules || !directiveNode.rules.length) {
-                return ;
-            }
-
-            //the directive was not directly referenced - we need to check whether some of its childs
-            //was referenced
-            if (hasVisibleChild(directiveNode)) {
-                //marking as referenced in case the directive is stored inside another directive
-                directiveNode.markReferenced();
-                return directiveNode;
-            }
 
-            //The directive was not directly referenced and does not contain anything that
-            //was referenced. Therefore it must not be shown in output.
-            return ;
-        } else {
-            if (!directiveNode.getIsReferenced()) {
-                return;
-            }
-        }
         return directiveNode;
     },
 
@@ -138,28 +211,16 @@ ToCSSVisitor.prototype = {
     },
 
     visitRuleset: function (rulesetNode, visitArgs) {
+        //at this point rulesets are nested into each other
         var rule, rulesets = [];
         if (rulesetNode.firstRoot) {
             this.checkPropertiesInRoot(rulesetNode.rules);
         }
         if (! rulesetNode.root) {
-            if (rulesetNode.paths) {
-                rulesetNode.paths = rulesetNode.paths
-                    .filter(function(p) {
-                        var i;
-                        if (p[0].elements[0].combinator.value === ' ') {
-                            p[0].elements[0].combinator = new(tree.Combinator)('');
-                        }
-                        for (i = 0; i < p.length; i++) {
-                            if (p[i].getIsReferenced() && p[i].getIsOutput()) {
-                                return true;
-                            }
-                        }
-                        return false;
-                    });
-            }
+            //remove invisible paths
+            this._compileRulesetPaths(rulesetNode);
 
-            // Compile rules and rulesets
+            // remove rulesets from this ruleset body and compile them separately
             var nodeRules = rulesetNode.rules, nodeRuleCnt = nodeRules ? nodeRules.length : 0;
             for (var i = 0; i < nodeRuleCnt; ) {
                 rule = nodeRules[i];
@@ -173,7 +234,8 @@ ToCSSVisitor.prototype = {
                 i++;
             }
             // accept the visitor to remove rules and refactor itself
-            // then we can decide now whether we want it or not
+            // then we can decide nogw whether we want it or not
+            // compile body
             if (nodeRuleCnt > 0) {
                 rulesetNode.accept(this._visitor);
             } else {
@@ -181,33 +243,46 @@ ToCSSVisitor.prototype = {
             }
             visitArgs.visitDeeper = false;
 
-            nodeRules = rulesetNode.rules;
-            if (nodeRules) {
-                this._mergeRules(nodeRules);
-                nodeRules = rulesetNode.rules;
-            }
-            if (nodeRules) {
-                this._removeDuplicateRules(nodeRules);
-                nodeRules = rulesetNode.rules;
-            }
-
-            // now decide whether we keep the ruleset
-            if (nodeRules && nodeRules.length > 0 && rulesetNode.paths.length > 0) {
-                rulesets.splice(0, 0, rulesetNode);
-            }
-        } else {
+        } else { //if (! rulesetNode.root) {
             rulesetNode.accept(this._visitor);
             visitArgs.visitDeeper = false;
-            if (rulesetNode.firstRoot || (rulesetNode.rules && rulesetNode.rules.length > 0)) {
-                rulesets.splice(0, 0, rulesetNode);
-            }
         }
+
+        if (rulesetNode.rules) {
+            this._mergeRules(rulesetNode.rules);
+            this._removeDuplicateRules(rulesetNode.rules);
+        }
+
+        //now decide whether we keep the ruleset
+        if (this.utils.isVisibleRuleset(rulesetNode)) {
+            rulesetNode.ensureVisibility();
+            rulesets.splice(0, 0, rulesetNode);
+        }
+
         if (rulesets.length === 1) {
             return rulesets[0];
         }
         return rulesets;
     },
 
+    _compileRulesetPaths: function(rulesetNode) {
+        if (rulesetNode.paths) {
+            rulesetNode.paths = rulesetNode.paths
+                .filter(function(p) {
+                    var i;
+                    if (p[0].elements[0].combinator.value === ' ') {
+                        p[0].elements[0].combinator = new(tree.Combinator)('');
+                    }
+                    for (i = 0; i < p.length; i++) {
+                        if (p[i].isVisible() && p[i].getIsOutput()) {
+                            return true;
+                        }
+                    }
+                    return false;
+                });
+        }
+    },
+
     _removeDuplicateRules: function(rules) {
         if (!rules) { return; }
 
@@ -294,6 +369,14 @@ ToCSSVisitor.prototype = {
                 rule.value = toValue(spacedGroups);
             }
         });
+    },
+
+    visitAnonymous: function(anonymousNode, visitArgs) {
+        if (anonymousNode.blocksVisibility()) {
+            return ;
+        }
+        anonymousNode.accept(this._visitor);
+        return anonymousNode;
     }
 };
 

package/lib/less-browser/bootstrap.js

@@ -3,7 +3,7 @@
  * used in the browser distributed version of less
  * to kick-start less using the browser api
  */
-/*global window */
+/*global window, document */
 
 // shim Promise if required
 require('promise/polyfill.js');
@@ -15,11 +15,37 @@ var less = module.exports = require("./index")(window, options);
 
 window.less = less;
 
+var css, head, style;
+
+// Always restore page visibility
+function resolveOrReject(data) {
+    if (data.filename) {
+        console.warn(data);
+    }
+    if (!options.async) {
+        head.removeChild(style);
+    }
+}
+
 if (options.onReady) {
     if (/!watch/.test(window.location.hash)) {
         less.watch();
     }
+    // Simulate synchronous stylesheet loading by blocking page rendering
+    if (!options.async) {
+        css = 'body { display: none !important }';
+        head = document.head || document.getElementsByTagName('head')[0];
+        style = document.createElement('style');
+
+        style.type = 'text/css';
+        if (style.styleSheet) {
+            style.styleSheet.cssText = css;
+        } else {
+            style.appendChild(document.createTextNode(css));
+        }
 
+        head.appendChild(style);
+    }
     less.registerStylesheetsImmediately();
-    less.pageLoadFinished = less.refresh(less.env === 'development');
+    less.pageLoadFinished = less.refresh(less.env === 'development').then(resolveOrReject, resolveOrReject);
 }

package/lib/less-browser/cache.js

@@ -8,25 +8,32 @@ module.exports = function(window, options, logger) {
         } catch (_) {}
     }
     return {
-        setCSS: function(path, lastModified, styles) {
+        setCSS: function(path, lastModified, modifyVars, styles) {
             if (cache) {
                 logger.info('saving ' + path + ' to cache.');
                 try {
                     cache.setItem(path, styles);
                     cache.setItem(path + ':timestamp', lastModified);
+                    if (modifyVars) {
+                        cache.setItem(path + ':vars', JSON.stringify(modifyVars));
+                    }
                 } catch(e) {
                     //TODO - could do with adding more robust error handling
                     logger.error('failed to save "' + path + '" to local storage for caching.');
                 }
             }
         },
-        getCSS: function(path, webInfo) {
+        getCSS: function(path, webInfo, modifyVars) {
             var css       = cache && cache.getItem(path),
-                timestamp = cache && cache.getItem(path + ':timestamp');
+                timestamp = cache && cache.getItem(path + ':timestamp'),
+                vars      = cache && cache.getItem(path + ':vars');
+
+            modifyVars = modifyVars || {};
 
             if (timestamp && webInfo.lastModified &&
                 (new Date(webInfo.lastModified).valueOf() ===
-                    new Date(timestamp).valueOf())) {
+                    new Date(timestamp).valueOf()) &&
+                (!modifyVars && !vars || JSON.stringify(modifyVars) === vars)) {
                 // Use local copy
                 return css;
             }

package/lib/less-browser/error-reporting.js

@@ -104,16 +104,6 @@ module.exports = function(window, less, options) {
         }
     }
 
-    function error(e, rootHref) {
-        if (!options.errorReporting || options.errorReporting === "html") {
-            errorHTML(e, rootHref);
-        } else if (options.errorReporting === "console") {
-            errorConsole(e, rootHref);
-        } else if (typeof options.errorReporting === 'function') {
-            options.errorReporting("add", e, rootHref);
-        }
-    }
-
     function removeErrorHTML(path) {
         var node = window.document.getElementById('less-error-message:' + utils.extractId(path));
         if (node) {
@@ -163,6 +153,16 @@ module.exports = function(window, less, options) {
         less.logger.error(content);
     }
 
+    function error(e, rootHref) {
+        if (!options.errorReporting || options.errorReporting === "html") {
+            errorHTML(e, rootHref);
+        } else if (options.errorReporting === "console") {
+            errorConsole(e, rootHref);
+        } else if (typeof options.errorReporting === 'function') {
+            options.errorReporting("add", e, rootHref);
+        }
+    }
+
     return {
         add: error,
         remove: removeError

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

@@ -39,7 +39,7 @@ module.exports = function(options, logger) {
     FileManager.prototype.doXHR = function doXHR(url, type, callback, errback) {
 
         var xhr = getXMLHttpRequest();
-        var async = options.isFileProtocol ? options.fileAsync : options.async;
+        var async = options.isFileProtocol ? options.fileAsync : true;
 
         if (typeof xhr.overrideMimeType === 'function') {
             xhr.overrideMimeType('text/css');

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

@@ -0,0 +1,28 @@
+module.exports = function() {
+
+    var functionRegistry = require("./../less/functions/function-registry");
+
+    function imageSize() {
+        throw {
+            type: "Runtime",
+            message: "Image size functions are not supported in browser version of less"
+        };
+    }
+
+    var imageFunctions = {
+        "image-size": function(filePathNode) {
+            imageSize(this, filePathNode);
+            return -1;
+        },
+        "image-width": function(filePathNode) {
+            imageSize(this, filePathNode);
+            return -1;
+        },
+        "image-height": function(filePathNode) {
+            imageSize(this, filePathNode);
+            return -1;
+        }
+    };
+
+    functionRegistry.addMultiple(imageFunctions);
+};

package/lib/less-browser/index.js

@@ -8,6 +8,7 @@ var addDataAttr = require("./utils").addDataAttr,
 module.exports = function(window, options) {
     var document = window.document;
     var less = require('../less')();
+
     //module.exports = less;
     less.options = options;
     var environment = less.environment,
@@ -19,6 +20,7 @@ module.exports = function(window, options) {
     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);
+    require('./image-size')(less.environment);
 
     //Setup user functions
     if (options.functions) {
@@ -112,14 +114,13 @@ module.exports = function(window, options) {
             if (webInfo) {
                 webInfo.remaining = remaining;
 
-                if (!instanceOptions.modifyVars) {
-                    var css = cache.getCSS(path, webInfo);
-                    if (!reload && css) {
-                        webInfo.local = true;
-                        callback(null, css, data, sheet, webInfo, path);
-                        return;
-                    }
+                var css = cache.getCSS(path, webInfo, instanceOptions.modifyVars);
+                if (!reload && css) {
+                    webInfo.local = true;
+                    callback(null, css, data, sheet, webInfo, path);
+                    return;
                 }
+
             }
 
             //TODO add tests around how this behaves when reloading
@@ -132,9 +133,7 @@ module.exports = function(window, options) {
                     callback(e);
                 } else {
                     result.css = postProcessCSS(result.css);
-                    if (!instanceOptions.modifyVars) {
-                        cache.setCSS(sheet.href, webInfo.lastModified, result.css);
-                    }
+                    cache.setCSS(sheet.href, webInfo.lastModified, instanceOptions.modifyVars, result.css);
                     callback(null, result.css, data, sheet, webInfo, path);
                 }
             });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "less",
-  "version": "2.5.1",
+  "version": "2.6.1",
   "description": "Leaner CSS",
   "homepage": "http://lesscss.org",
   "author": {
@@ -37,26 +37,26 @@
   },
   "optionalDependencies": {
     "errno": "^0.1.1",
-    "graceful-fs": "^3.0.5",
-    "image-size": "~0.3.5",
+    "graceful-fs": "^4.1.2",
+    "image-size": "~0.4.0",
     "mime": "^1.2.11",
     "mkdirp": "^0.5.0",
-    "promise": "^6.0.1",
+    "promise": "^7.1.1",
     "request": "^2.51.0",
-    "source-map": "^0.4.2"
+    "source-map": "^0.5.3"
   },
   "devDependencies": {
-    "diff": "^1.0",
+    "diff": "^2.2.1",
     "grunt": "^0.4.5",
-    "grunt-contrib-clean": "^0.6.0",
-    "grunt-contrib-concat": "^0.5.0",
-    "grunt-contrib-connect": "^0.9.0",
-    "grunt-contrib-jasmine": "^0.8.2",
-    "grunt-contrib-jshint": "^0.11.0",
-    "grunt-contrib-uglify": "^0.8.0",
-    "grunt-jscs": "^1.6.0",
+    "grunt-contrib-clean": "^1.0.0",
+    "grunt-contrib-concat": "^1.0.0",
+    "grunt-contrib-connect": "^0.11.2",
+    "grunt-contrib-jasmine": "^1.0.0",
+    "grunt-contrib-jshint": "^1.0.0",
+    "grunt-contrib-uglify": "^0.11.0",
+    "grunt-jscs": "^2.7.0",
     "grunt-shell": "^1.1.1",
-    "grunt-browserify": "~3.5.0",
+    "grunt-browserify": "~4.0.1",
     "jit-grunt": "^0.9.1",
     "time-grunt": "^1.0.0",
     "grunt-saucelabs": "^8.3.2"

package/test/browser/less/errors/image-height-error.less

@@ -0,0 +1,3 @@
+.test-height{
+  height: image-height("../data/image.jpg")
+}

package/test/browser/less/errors/image-height-error.txt

@@ -0,0 +1,4 @@
+RuntimeError: error evaluating function `image-height`: Image size functions are not supported in browser version of less in image-height-error.less on line 2, column 11:
+1 .test-height{
+2   height: image-height("../data/image.jpg")
+3 }

package/test/browser/less/errors/image-size-error.less

@@ -0,0 +1,3 @@
+.test-size{
+  size: image-size("../data/image.jpg")
+}

package/test/browser/less/errors/image-size-error.txt

@@ -0,0 +1,4 @@
+RuntimeError: error evaluating function `image-size`: Image size functions are not supported in browser version of less in image-size-error.less on line 2, column 9:
+1 .test-size{
+2   size: image-size("../data/image.jpg")
+3 }

package/test/browser/less/errors/image-width-error.less

@@ -0,0 +1,3 @@
+.test-width{
+  width: image-width("../data/image.jpg")
+}

package/test/browser/less/errors/image-width-error.txt

@@ -0,0 +1,4 @@
+RuntimeError: error evaluating function `image-width`: Image size functions are not supported in browser version of less in image-width-error.less on line 2, column 10:
+1 .test-width{
+2   width: image-width("../data/image.jpg")
+3 }