less 2.5.1 → 2.6.1

package/lib/less/tree/ruleset.js

@@ -8,11 +8,12 @@ var Node = require("./node"),
     defaultFunc = require("../functions/default"),
     getDebugInfo = require("./debug-info");
 
-var Ruleset = function (selectors, rules, strictImports) {
+var Ruleset = function (selectors, rules, strictImports, visibilityInfo) {
     this.selectors = selectors;
     this.rules = rules;
     this._lookups = {};
     this.strictImports = strictImports;
+    this.copyVisibilityInfo(visibilityInfo);
 };
 Ruleset.prototype = new Node();
 Ruleset.prototype.type = "Ruleset";
@@ -20,7 +21,7 @@ Ruleset.prototype.isRuleset = true;
 Ruleset.prototype.isRulesetLike = true;
 Ruleset.prototype.accept = function (visitor) {
     if (this.paths) {
-        visitor.visitArray(this.paths, true);
+        this.paths = visitor.visitArray(this.paths, true);
     } else if (this.selectors) {
         this.selectors = visitor.visitArray(this.selectors);
     }
@@ -51,7 +52,7 @@ Ruleset.prototype.eval = function (context) {
     }
 
     var rules = this.rules ? this.rules.slice(0) : null,
-        ruleset = new Ruleset(selectors, rules, this.strictImports),
+        ruleset = new Ruleset(selectors, rules, this.strictImports, this.visibilityInfo()),
         rule, subRule;
 
     ruleset.originalRuleset = this;
@@ -159,6 +160,7 @@ Ruleset.prototype.eval = function (context) {
 
                 for (var j = 0; j < rule.rules.length; j++) {
                     subRule = rule.rules[j];
+                    subRule.copyVisibilityInfo(rule.visibilityInfo());
                     if (!(subRule instanceof Rule) || !subRule.variable) {
                         rsRules.splice(++i, 0, subRule);
                     }
@@ -186,7 +188,7 @@ Ruleset.prototype.evalImports = function(context) {
     for (i = 0; i < rules.length; i++) {
         if (rules[i].type === "Import") {
             importRules = rules[i].eval(context);
-            if (importRules && importRules.length) {
+            if (importRules && (importRules.length || importRules.length === 0)) {
                 rules.splice.apply(rules, [i, 1].concat(importRules));
                 i+= importRules.length - 1;
             } else {
@@ -203,7 +205,7 @@ Ruleset.prototype.makeImportant = function() {
         } else {
             return r;
         }
-    }), this.strictImports);
+    }), this.strictImports, this.visibilityInfo());
 
     return result;
 };
@@ -431,46 +433,6 @@ Ruleset.prototype.genCSS = function (context, output) {
         output.add('\n');
     }
 };
-Ruleset.prototype.markReferenced = function () {
-    var s;
-    if (this.selectors) {
-        for (s = 0; s < this.selectors.length; s++) {
-            this.selectors[s].markReferenced();
-        }
-    }
-
-    if (this.rules) {
-        for (s = 0; s < this.rules.length; s++) {
-            if (this.rules[s].markReferenced) {
-                this.rules[s].markReferenced();
-            }
-        }
-    }
-};
-Ruleset.prototype.getIsReferenced = function() {
-    var i, j, path, selector;
-
-    if (this.paths) {
-        for (i = 0; i < this.paths.length; i++) {
-            path = this.paths[i];
-            for (j = 0; j < path.length; j++) {
-                if (path[j].getIsReferenced && path[j].getIsReferenced()) {
-                    return true;
-                }
-            }
-        }
-    }
-
-    if (this.selectors) {
-        for (i = 0; i < this.selectors.length; i++) {
-            selector = this.selectors[i];
-            if (selector.getIsReferenced && selector.getIsReferenced()) {
-                return true;
-            }
-        }
-    }
-    return false;
-};
 
 Ruleset.prototype.joinSelectors = function (paths, context, selectors) {
     for (var s = 0; s < selectors.length; s++) {
@@ -501,6 +463,91 @@ Ruleset.prototype.joinSelector = function (paths, context, selector) {
         return selector;
     }
 
+    // joins selector path from `beginningPath` with selector path in `addPath`
+    // `replacedElement` contains element that is being replaced by `addPath`
+    // returns concatenated path
+    function addReplacementIntoPath(beginningPath, addPath, replacedElement, originalSelector) {
+        var newSelectorPath, lastSelector, newJoinedSelector;
+        // our new selector path
+        newSelectorPath = [];
+
+        //construct the joined selector - if & is the first thing this will be empty,
+        // if not newJoinedSelector will be the last set of elements in the selector
+        if (beginningPath.length > 0) {
+            newSelectorPath = beginningPath.slice(0);
+            lastSelector = newSelectorPath.pop();
+            newJoinedSelector = originalSelector.createDerived(lastSelector.elements.slice(0));
+        }
+        else {
+            newJoinedSelector = originalSelector.createDerived([]);
+        }
+
+        if (addPath.length > 0) {
+            // /deep/ is a combinator that is valid without anything in front of it
+            // so if the & does not have a combinator that is "" or " " then
+            // and there is a combinator on the parent, then grab that.
+            // this also allows + a { & .b { .a & { ... though not sure why you would want to do that
+            var combinator = replacedElement.combinator, parentEl = addPath[0].elements[0];
+            if (combinator.emptyOrWhitespace && !parentEl.combinator.emptyOrWhitespace) {
+                combinator = parentEl.combinator;
+            }
+            // join the elements so far with the first part of the parent
+            newJoinedSelector.elements.push(new Element(combinator, parentEl.value, replacedElement.index, replacedElement.currentFileInfo));
+            newJoinedSelector.elements = newJoinedSelector.elements.concat(addPath[0].elements.slice(1));
+        }
+
+        // now add the joined selector - but only if it is not empty
+        if (newJoinedSelector.elements.length !== 0) {
+            newSelectorPath.push(newJoinedSelector);
+        }
+
+        //put together the parent selectors after the join (e.g. the rest of the parent)
+        if (addPath.length > 1) {
+            var restOfPath = addPath.slice(1);
+            restOfPath = restOfPath.map(function (selector) {
+                return selector.createDerived(selector.elements, []);
+            });
+            newSelectorPath = newSelectorPath.concat(restOfPath);
+        }
+        return newSelectorPath;
+    }
+
+    // joins selector path from `beginningPath` with every selector path in `addPaths` array
+    // `replacedElement` contains element that is being replaced by `addPath`
+    // returns array with all concatenated paths
+    function addAllReplacementsIntoPath( beginningPath, addPaths, replacedElement, originalSelector, result) {
+        var j;
+        for (j = 0; j < beginningPath.length; j++) {
+            var newSelectorPath = addReplacementIntoPath(beginningPath[j], addPaths, replacedElement, originalSelector);
+            result.push(newSelectorPath);
+        }
+        return result;
+    }
+
+    function mergeElementsOnToSelectors(elements, selectors) {
+        var i, sel;
+
+        if (elements.length === 0) {
+            return ;
+        }
+        if (selectors.length === 0) {
+            selectors.push([ new Selector(elements) ]);
+            return;
+        }
+
+        for (i = 0; i < selectors.length; i++) {
+            sel = selectors[i];
+
+            // if the previous thing in sel is a parent this needs to join on to it
+            if (sel.length > 0) {
+                sel[sel.length - 1] = sel[sel.length - 1].createDerived(sel[sel.length - 1].elements.concat(elements));
+            }
+            else {
+                sel.push(new Selector(elements));
+            }
+        }
+    }
+
     // replace all parent selectors inside `inSelector` by content of `context` array
     // resulting selectors are returned inside `paths` array
     // returns true if `inSelector` contained at least one parent selector
@@ -614,91 +661,17 @@ Ruleset.prototype.joinSelector = function (paths, context, selector) {
                 paths.push(newSelectors[i]);
                 lastSelector = newSelectors[i][length - 1];
                 newSelectors[i][length - 1] = lastSelector.createDerived(lastSelector.elements, inSelector.extendList);
+                //newSelectors[i][length - 1].copyVisibilityInfo(inSelector.visibilityInfo());
             }
         }
 
         return hadParentSelector;
     }
 
-    // joins selector path from `beginningPath` with selector path in `addPath`
-    // `replacedElement` contains element that is being replaced by `addPath`
-    // returns concatenated path
-    function addReplacementIntoPath(beginningPath, addPath, replacedElement, originalSelector) {
-        var newSelectorPath, lastSelector, newJoinedSelector;
-        // our new selector path
-        newSelectorPath = [];
-
-        //construct the joined selector - if & is the first thing this will be empty,
-        // if not newJoinedSelector will be the last set of elements in the selector
-        if (beginningPath.length > 0) {
-            newSelectorPath = beginningPath.slice(0);
-            lastSelector = newSelectorPath.pop();
-            newJoinedSelector = originalSelector.createDerived(lastSelector.elements.slice(0));
-        }
-        else {
-            newJoinedSelector = originalSelector.createDerived([]);
-        }
-
-        if (addPath.length > 0) {
-            // /deep/ is a combinator that is valid without anything in front of it
-            // so if the & does not have a combinator that is "" or " " then
-            // and there is a combinator on the parent, then grab that.
-            // this also allows + a { & .b { .a & { ... though not sure why you would want to do that
-            var combinator = replacedElement.combinator, parentEl = addPath[0].elements[0];
-            if (combinator.emptyOrWhitespace && !parentEl.combinator.emptyOrWhitespace) {
-                combinator = parentEl.combinator;
-            }
-            // join the elements so far with the first part of the parent
-            newJoinedSelector.elements.push(new Element(combinator, parentEl.value, replacedElement.index, replacedElement.currentFileInfo));
-            newJoinedSelector.elements = newJoinedSelector.elements.concat(addPath[0].elements.slice(1));
-        }
-
-        // now add the joined selector - but only if it is not empty
-        if (newJoinedSelector.elements.length !== 0) {
-            newSelectorPath.push(newJoinedSelector);
-        }
-
-        //put together the parent selectors after the join (e.g. the rest of the parent)
-        if (addPath.length > 1) {
-            newSelectorPath = newSelectorPath.concat(addPath.slice(1));
-        }
-        return newSelectorPath;
-    }
-
-    // joins selector path from `beginningPath` with every selector path in `addPaths` array
-    // `replacedElement` contains element that is being replaced by `addPath`
-    // returns array with all concatenated paths
-    function addAllReplacementsIntoPath( beginningPath, addPaths, replacedElement, originalSelector, result) {
-        var j;
-        for (j = 0; j < beginningPath.length; j++) {
-            var newSelectorPath = addReplacementIntoPath(beginningPath[j], addPaths, replacedElement, originalSelector);
-            result.push(newSelectorPath);
-        }
-        return result;
-    }
-
-    function mergeElementsOnToSelectors(elements, selectors) {
-        var i, sel;
-
-        if (elements.length === 0) {
-            return ;
-        }
-        if (selectors.length === 0) {
-            selectors.push([ new Selector(elements) ]);
-            return;
-        }
-
-        for (i = 0; i < selectors.length; i++) {
-            sel = selectors[i];
-
-            // if the previous thing in sel is a parent this needs to join on to it
-            if (sel.length > 0) {
-                sel[sel.length - 1] = sel[sel.length - 1].createDerived(sel[sel.length - 1].elements.concat(elements));
-            }
-            else {
-                sel.push(new Selector(elements));
-            }
-        }
+    function deriveSelector(visibilityInfo, deriveFrom) {
+        var newSelector = deriveFrom.createDerived(deriveFrom.elements, deriveFrom.extendList, deriveFrom.evaldCondition);
+        newSelector.copyVisibilityInfo(visibilityInfo);
+        return newSelector;
     }
 
     // joinSelector code follows
@@ -711,7 +684,16 @@ Ruleset.prototype.joinSelector = function (paths, context, selector) {
         if (context.length > 0) {
             newPaths = [];
             for (i = 0; i < context.length; i++) {
-                newPaths.push(context[i].concat(selector));
+                //var concatenated = [];
+                //context[i].forEach(function(entry) {
+                //    var newEntry = entry.createDerived(entry.elements, entry.extendList, entry.evaldCondition);
+                //    newEntry.copyVisibilityInfo(selector.visibilityInfo());
+                //    concatenated.push(newEntry);
+                //}, this);
+                var concatenated = context[i].map(deriveSelector.bind(this, selector.visibilityInfo()));
+
+                concatenated.push(selector);
+                newPaths.push(concatenated);
             }
         }
         else {

package/lib/less/tree/selector.js

@@ -1,15 +1,15 @@
 var Node = require("./node"),
     Element = require("./element");
 
-var Selector = function (elements, extendList, condition, index, currentFileInfo, isReferenced) {
+var Selector = function (elements, extendList, condition, index, currentFileInfo, visibilityInfo) {
     this.elements = elements;
     this.extendList = extendList;
     this.condition = condition;
     this.currentFileInfo = currentFileInfo || {};
-    this.isReferenced = isReferenced;
     if (!condition) {
         this.evaldCondition = true;
     }
+    this.copyVisibilityInfo(visibilityInfo);
 };
 Selector.prototype = new Node();
 Selector.prototype.type = "Selector";
@@ -25,8 +25,9 @@ Selector.prototype.accept = function (visitor) {
     }
 };
 Selector.prototype.createDerived = function(elements, extendList, evaldCondition) {
+    var info = this.visibilityInfo();
     evaldCondition = (evaldCondition != null) ? evaldCondition : this.evaldCondition;
-    var newSelector = new Selector(elements, extendList || this.extendList, null, this.index, this.currentFileInfo, this.isReferenced);
+    var newSelector = new Selector(elements, extendList || this.extendList, null, this.index, this.currentFileInfo, info);
     newSelector.evaldCondition = evaldCondition;
     newSelector.mediaEmpty = this.mediaEmpty;
     return newSelector;
@@ -104,12 +105,6 @@ Selector.prototype.genCSS = function (context, output) {
         }
     }
 };
-Selector.prototype.markReferenced = function () {
-    this.isReferenced = true;
-};
-Selector.prototype.getIsReferenced = function() {
-    return !this.currentFileInfo.reference || this.isReferenced;
-};
 Selector.prototype.getIsOutput = function() {
     return this.evaldCondition;
 };

package/lib/less/tree/unit.js

@@ -61,7 +61,7 @@ Unit.prototype.map = function(callback) {
     }
 };
 Unit.prototype.usedUnits = function() {
-    var group, result = {}, mapUnit;
+    var group, result = {}, mapUnit, groupName;
 
     mapUnit = function (atomicUnit) {
         /*jshint loopfunc:true */
@@ -72,7 +72,7 @@ Unit.prototype.usedUnits = function() {
         return atomicUnit;
     };
 
-    for (var groupName in unitConversions) {
+    for (groupName in unitConversions) {
         if (unitConversions.hasOwnProperty(groupName)) {
             group = unitConversions[groupName];
 

package/lib/less/visitors/extend-visitor.js

@@ -156,17 +156,17 @@ ProcessExtendsVisitor.prototype = {
                 matches = extendVisitor.findMatch(extend, selectorPath);
 
                 if (matches.length) {
-
                     extend.hasFoundMatches = true;
 
                     // we found a match, so for each self selector..
                     extend.selfSelectors.forEach(function(selfSelector) {
+                        var info = targetExtend.visibilityInfo();
 
                         // process the extend as usual
-                        newSelector = extendVisitor.extendSelector(matches, selectorPath, selfSelector);
+                        newSelector = extendVisitor.extendSelector(matches, selectorPath, selfSelector, extend.isVisible());
 
                         // but now we create a new extend from it
-                        newExtend = new(tree.Extend)(targetExtend.selector, targetExtend.option, 0);
+                        newExtend = new(tree.Extend)(targetExtend.selector, targetExtend.option, 0, targetExtend.currentFileInfo, info);
                         newExtend.selfSelectors = newSelector;
 
                         // add the extend onto the list of extends for that selector
@@ -247,7 +247,9 @@ ProcessExtendsVisitor.prototype = {
                     allExtends[extendIndex].hasFoundMatches = true;
 
                     allExtends[extendIndex].selfSelectors.forEach(function(selfSelector) {
-                        selectorsToAdd.push(extendVisitor.extendSelector(matches, selectorPath, selfSelector));
+                        var extendedSelectors;
+                        extendedSelectors = extendVisitor.extendSelector(matches, selectorPath, selfSelector, allExtends[extendIndex].isVisible());
+                        selectorsToAdd.push(extendedSelectors);
                     });
                 }
             }
@@ -363,7 +365,7 @@ ProcessExtendsVisitor.prototype = {
         }
         return false;
     },
-    extendSelector:function (matches, selectorPath, replacementSelector) {
+    extendSelector:function (matches, selectorPath, replacementSelector, isVisible) {
 
         //for a set of matches, replace each match with the replacement selector
 
@@ -423,11 +425,18 @@ ProcessExtendsVisitor.prototype = {
         }
 
         path = path.concat(selectorPath.slice(currentSelectorPathIndex, selectorPath.length));
-
+        path = path.map(function (currentValue) {
+            // we can re-use elements here, because the visibility property matters only for selectors
+            var derived = currentValue.createDerived(currentValue.elements);
+            if (isVisible) {
+                derived.ensureVisibility();
+            } else {
+                derived.ensureInvisibility();
+            }
+            return derived;
+        });
         return path;
     },
-    visitRulesetOut: function (rulesetNode) {
-    },
     visitMedia: function (mediaNode, visitArgs) {
         var newAllExtends = mediaNode.allExtends.concat(this.allExtendsStack[this.allExtendsStack.length - 1]);
         newAllExtends = newAllExtends.concat(this.doExtendChaining(newAllExtends, mediaNode.allExtends));

package/lib/less/visitors/import-visitor.js

@@ -104,6 +104,7 @@ ImportVisitor.prototype = {
         var importVisitor = this,
             inlineCSS = importNode.options.inline,
             isPlugin = importNode.options.plugin,
+            isOptional = importNode.options.optional,
             duplicateImport = importedAtRoot || fullPath in importVisitor.recursionDetector;
 
         if (!context.importMultiple) {
@@ -120,6 +121,10 @@ ImportVisitor.prototype = {
             }
         }
 
+        if (!fullPath && isOptional) {
+            importNode.skip = true;
+        }
+
         if (root) {
             importNode.root = root;
             importNode.importedFilename = fullPath;

package/lib/less/visitors/index.js

@@ -1,6 +1,7 @@
 var visitors = {
     Visitor: require("./visitor"),
     ImportVisitor: require('./import-visitor'),
+    MarkVisibleSelectorsVisitor: require("./set-tree-visibility-visitor"),
     ExtendVisitor: require('./extend-visitor'),
     JoinSelectorVisitor: require('./join-selector-visitor'),
     ToCSSVisitor: require('./to-css-visitor')

package/lib/less/visitors/set-tree-visibility-visitor.js

@@ -0,0 +1,38 @@
+var SetTreeVisibilityVisitor = function(visible) {
+    this.visible = visible;
+};
+SetTreeVisibilityVisitor.prototype.run = function(root) {
+    this.visit(root);
+};
+SetTreeVisibilityVisitor.prototype.visitArray = function(nodes) {
+    if (!nodes) {
+        return nodes;
+    }
+
+    var cnt = nodes.length, i;
+    for (i = 0; i < cnt; i++) {
+        this.visit(nodes[i]);
+    }
+    return nodes;
+};
+SetTreeVisibilityVisitor.prototype.visit = function(node) {
+    if (!node) {
+        return node;
+    }
+    if (node.constructor === Array) {
+        return this.visitArray(node);
+    }
+
+    if (!node.blocksVisibility || node.blocksVisibility()) {
+        return node;
+    }
+    if (this.visible) {
+        node.ensureVisibility();
+    } else {
+        node.ensureInvisibility();
+    }
+
+    node.accept(this);
+    return node;
+};
+module.exports = SetTreeVisibilityVisitor;