less 2.5.1 → 2.6.1

package/lib/less/tree/anonymous.js

@@ -1,16 +1,18 @@
 var Node = require("./node");
 
-var Anonymous = function (value, index, currentFileInfo, mapLines, rulesetLike) {
+var Anonymous = function (value, index, currentFileInfo, mapLines, rulesetLike, visibilityInfo) {
     this.value = value;
     this.index = index;
     this.mapLines = mapLines;
     this.currentFileInfo = currentFileInfo;
     this.rulesetLike = (typeof rulesetLike === 'undefined') ? false : rulesetLike;
+
+    this.copyVisibilityInfo(visibilityInfo);
 };
 Anonymous.prototype = new Node();
 Anonymous.prototype.type = "Anonymous";
 Anonymous.prototype.eval = function () {
-    return new Anonymous(this.value, this.index, this.currentFileInfo, this.mapLines, this.rulesetLike);
+    return new Anonymous(this.value, this.index, this.currentFileInfo, this.mapLines, this.rulesetLike, this.visibilityInfo());
 };
 Anonymous.prototype.compare = function (other) {
     return other.toCSS && this.toCSS() === other.toCSS() ? 0 : undefined;

package/lib/less/tree/color.js

@@ -4,7 +4,7 @@ var Node = require("./node"),
 //
 // RGB Colors - #ff0014, #eee
 //
-var Color = function (rgb, a) {
+var Color = function (rgb, a, originalForm) {
     //
     // The end goal here, is to parse the arguments
     // into an integer triplet, such as `128, 255, 0`
@@ -23,6 +23,9 @@ var Color = function (rgb, a) {
         });
     }
     this.alpha = typeof a === 'number' ? a : 1;
+    if (typeof originalForm !== 'undefined') {
+        this.value = originalForm;
+    }
 };
 
 Color.prototype = new Node();

package/lib/less/tree/comment.js

@@ -15,11 +15,7 @@ Comment.prototype.genCSS = function (context, output) {
     output.add(this.value);
 };
 Comment.prototype.isSilent = function(context) {
-    var isReference = (this.currentFileInfo && this.currentFileInfo.reference && !this.isReferenced),
-        isCompressed = context.compress && this.value[2] !== "!";
-    return this.isLineComment || isReference || isCompressed;
-};
-Comment.prototype.markReferenced = function () {
-    this.isReferenced = true;
+    var isCompressed = context.compress && this.value[2] !== "!";
+    return this.isLineComment || isCompressed;
 };
 module.exports = Comment;

package/lib/less/tree/directive.js

@@ -2,7 +2,7 @@ var Node = require("./node"),
     Selector = require("./selector"),
     Ruleset = require("./ruleset");
 
-var Directive = function (name, value, rules, index, currentFileInfo, debugInfo, isReferenced, isRooted) {
+var Directive = function (name, value, rules, index, currentFileInfo, debugInfo, isRooted, visibilityInfo) {
     var i;
 
     this.name  = name;
@@ -21,8 +21,8 @@ var Directive = function (name, value, rules, index, currentFileInfo, debugInfo,
     this.index = index;
     this.currentFileInfo = currentFileInfo;
     this.debugInfo = debugInfo;
-    this.isReferenced = isReferenced;
     this.isRooted = isRooted || false;
+    this.copyVisibilityInfo(visibilityInfo);
 };
 
 Directive.prototype = new Node();
@@ -79,7 +79,7 @@ Directive.prototype.eval = function (context) {
     context.mediaBlocks = mediaBlocksBackup;
 
     return new Directive(this.name, value, rules,
-        this.index, this.currentFileInfo, this.debugInfo, this.isReferenced, this.isRooted);
+        this.index, this.currentFileInfo, this.debugInfo, this.isRooted, this.visibilityInfo());
 };
 Directive.prototype.variable = function (name) {
     if (this.rules) {
@@ -99,21 +99,6 @@ Directive.prototype.rulesets = function () {
         return Ruleset.prototype.rulesets.apply(this.rules[0]);
     }
 };
-Directive.prototype.markReferenced = function () {
-    var i, rules;
-    this.isReferenced = true;
-    if (this.rules) {
-        rules = this.rules;
-        for (i = 0; i < rules.length; i++) {
-            if (rules[i].markReferenced) {
-                rules[i].markReferenced();
-            }
-        }
-    }
-};
-Directive.prototype.getIsReferenced = function () {
-    return !this.currentFileInfo || !this.currentFileInfo.reference || this.isReferenced;
-};
 Directive.prototype.outputRuleset = function (context, output, rules) {
     var ruleCnt = rules.length, i;
     context.tabLevel = (context.tabLevel | 0) + 1;

package/lib/less/tree/element.js

@@ -2,7 +2,7 @@ var Node = require("./node"),
     Paren = require("./paren"),
     Combinator = require("./combinator");
 
-var Element = function (combinator, value, index, currentFileInfo) {
+var Element = function (combinator, value, index, currentFileInfo, info) {
     this.combinator = combinator instanceof Combinator ?
                       combinator : new Combinator(combinator);
 
@@ -15,6 +15,7 @@ var Element = function (combinator, value, index, currentFileInfo) {
     }
     this.index = index;
     this.currentFileInfo = currentFileInfo;
+    this.copyVisibilityInfo(info);
 };
 Element.prototype = new Node();
 Element.prototype.type = "Element";
@@ -29,7 +30,13 @@ Element.prototype.eval = function (context) {
     return new Element(this.combinator,
                              this.value.eval ? this.value.eval(context) : this.value,
                              this.index,
-                             this.currentFileInfo);
+                             this.currentFileInfo, this.visibilityInfo());
+};
+Element.prototype.clone = function () {
+    return new Element(this.combinator,
+        this.value,
+        this.index,
+        this.currentFileInfo, this.visibilityInfo());
 };
 Element.prototype.genCSS = function (context, output) {
     output.add(this.toCSS(context), this.currentFileInfo, this.index);

package/lib/less/tree/extend.js

@@ -1,11 +1,14 @@
-var Node = require("./node");
+var Node = require("./node"),
+    Selector = require("./selector");
 
-var Extend = function Extend(selector, option, index) {
+var Extend = function Extend(selector, option, index, currentFileInfo, visibilityInfo) {
     this.selector = selector;
     this.option = option;
     this.index = index;
     this.object_id = Extend.next_id++;
     this.parent_ids = [this.object_id];
+    this.currentFileInfo = currentFileInfo || {};
+    this.copyVisibilityInfo(visibilityInfo);
 
     switch(option) {
         case "all":
@@ -26,11 +29,12 @@ Extend.prototype.accept = function (visitor) {
     this.selector = visitor.visit(this.selector);
 };
 Extend.prototype.eval = function (context) {
-    return new Extend(this.selector.eval(context), this.option, this.index);
+    return new Extend(this.selector.eval(context), this.option, this.index, this.currentFileInfo, this.visibilityInfo());
 };
 Extend.prototype.clone = function (context) {
-    return new Extend(this.selector, this.option, this.index);
+    return new Extend(this.selector, this.option, this.index, this.currentFileInfo, this.visibilityInfo());
 };
+//it concatenates (joins) all selectors in selector array
 Extend.prototype.findSelfSelectors = function (selectors) {
     var selfElements = [],
         i,
@@ -46,6 +50,7 @@ Extend.prototype.findSelfSelectors = function (selectors) {
         selfElements = selfElements.concat(selectors[i].elements);
     }
 
-    this.selfSelectors = [{ elements: selfElements }];
+    this.selfSelectors = [new Selector(selfElements)];
+    this.selfSelectors[0].copyVisibilityInfo(this.visibilityInfo());
 };
 module.exports = Extend;

package/lib/less/tree/import.js

@@ -17,7 +17,7 @@ var Node = require("./node"),
 // `import,push`, we also pass it a callback, which it'll call once
 // the file has been fetched, and parsed.
 //
-var Import = function (path, features, options, index, currentFileInfo) {
+var Import = function (path, features, options, index, currentFileInfo, visibilityInfo) {
     this.options = options;
     this.index = index;
     this.path = path;
@@ -32,6 +32,7 @@ var Import = function (path, features, options, index, currentFileInfo) {
             this.css = true;
         }
     }
+    this.copyVisibilityInfo(visibilityInfo);
 };
 
 //
@@ -87,7 +88,7 @@ Import.prototype.evalForImport = function (context) {
         path = path.value;
     }
 
-    return new Import(path.eval(context), this.features, this.options, this.index, this.currentFileInfo);
+    return new Import(path.eval(context), this.features, this.options, this.index, this.currentFileInfo, this.visibilityInfo());
 };
 Import.prototype.evalPath = function (context) {
     var path = this.path.eval(context);
@@ -107,6 +108,20 @@ Import.prototype.evalPath = function (context) {
     return path;
 };
 Import.prototype.eval = function (context) {
+    var result = this.doEval(context);
+    if (this.options.reference || this.blocksVisibility()) {
+        if (result.length || result.length === 0) {
+            result.forEach(function (node) {
+                    node.addVisibilityBlock();
+                }
+            );
+        } else {
+            result.addVisibilityBlock();
+        }
+    }
+    return result;
+};
+Import.prototype.doEval = function (context) {
     var ruleset, registry,
         features = this.features && this.features.eval(context);
 
@@ -126,9 +141,13 @@ Import.prototype.eval = function (context) {
             return [];
         }
     }
-
     if (this.options.inline) {
-        var contents = new Anonymous(this.root, 0, {filename: this.importedFilename}, true, true);
+        var contents = new Anonymous(this.root, 0,
+          {
+              filename: this.importedFilename,
+              reference: this.path.currentFileInfo && this.path.currentFileInfo.reference
+          }, true, true);
+
         return this.features ? new Media([contents], this.features.value) : [contents];
     } else if (this.css) {
         var newImport = new Import(this.evalPath(context), features, this.options, this.index);
@@ -138,7 +157,6 @@ Import.prototype.eval = function (context) {
         return newImport;
     } else {
         ruleset = new Ruleset(null, this.root.rules.slice(0));
-
         ruleset.evalImports(context);
 
         return this.features ? new Media(ruleset.rules, this.features.value) : ruleset.rules;

package/lib/less/tree/media.js

@@ -5,7 +5,7 @@ var Ruleset = require("./ruleset"),
     Expression = require("./expression"),
     Directive = require("./directive");
 
-var Media = function (value, features, index, currentFileInfo) {
+var Media = function (value, features, index, currentFileInfo, visibilityInfo) {
     this.index = index;
     this.currentFileInfo = currentFileInfo;
 
@@ -14,6 +14,7 @@ var Media = function (value, features, index, currentFileInfo) {
     this.features = new Value(features);
     this.rules = [new Ruleset(selectors, value)];
     this.rules[0].allowImports = true;
+    this.copyVisibilityInfo(visibilityInfo);
 };
 Media.prototype = new Directive();
 Media.prototype.type = "Media";
@@ -37,7 +38,7 @@ Media.prototype.eval = function (context) {
         context.mediaPath = [];
     }
 
-    var media = new Media(null, [], this.index, this.currentFileInfo);
+    var media = new Media(null, [], this.index, this.currentFileInfo, this.visibilityInfo());
     if (this.debugInfo) {
         this.rules[0].debugInfo = this.debugInfo;
         media.debugInfo = this.debugInfo;
@@ -77,6 +78,7 @@ Media.prototype.evalTop = function (context) {
         var selectors = (new Selector([], null, null, this.index, this.currentFileInfo)).createEmptySelectors();
         result = new Ruleset(selectors, context.mediaBlocks);
         result.multiMedia = true;
+        result.copyVisibilityInfo(this.visibilityInfo());
     }
 
     delete context.mediaBlocks;

package/lib/less/tree/mixin-call.js

@@ -5,7 +5,7 @@ var Node = require("./node"),
 
 var MixinCall = function (elements, args, index, currentFileInfo, important) {
     this.selector = new Selector(elements);
-    this.arguments = (args && args.length) ? args : null;
+    this.arguments = args || [];
     this.index = index;
     this.currentFileInfo = currentFileInfo;
     this.important = important;
@@ -16,17 +16,18 @@ MixinCall.prototype.accept = function (visitor) {
     if (this.selector) {
         this.selector = visitor.visit(this.selector);
     }
-    if (this.arguments) {
+    if (this.arguments.length) {
         this.arguments = visitor.visitArray(this.arguments);
     }
 };
 MixinCall.prototype.eval = function (context) {
-    var mixins, mixin, mixinPath, args, rules = [], match = false, i, m, f, isRecursive, isOneFound, rule,
+    var mixins, mixin, mixinPath, args = [], arg, argValue,
+        rules = [], match = false, i, m, f, isRecursive, isOneFound,
         candidates = [], candidate, conditionResult = [], defaultResult, defFalseEitherCase = -1,
         defNone = 0, defTrue = 1, defFalse = 2, count, originalRuleset, noArgumentsFilter;
 
     function calcDefGroup(mixin, mixinPath) {
-        var p, namespace;
+        var f, p, namespace;
 
         for (f = 0; f < 2; f++) {
             conditionResult[f] = true;
@@ -52,9 +53,18 @@ MixinCall.prototype.eval = function (context) {
         return defFalseEitherCase;
     }
 
-    args = this.arguments && this.arguments.map(function (a) {
-        return { name: a.name, value: a.value.eval(context) };
-    });
+    for (i = 0; i < this.arguments.length; i++) {
+        arg = this.arguments[i];
+        argValue = arg.value.eval(context);
+        if (arg.expand && Array.isArray(argValue.value)) {
+            argValue = argValue.value;
+            for (m = 0; m < argValue.length; m++) {
+                args.push({value: argValue[m]});
+            }
+        } else {
+            args.push({name: arg.name, value: argValue});
+        }
+    }
 
     noArgumentsFilter = function(rule) {return rule.matchArgs(null, context);};
 
@@ -117,11 +127,12 @@ MixinCall.prototype.eval = function (context) {
                         mixin = candidates[m].mixin;
                         if (!(mixin instanceof MixinDefinition)) {
                             originalRuleset = mixin.originalRuleset || mixin;
-                            mixin = new MixinDefinition("", [], mixin.rules, null, false);
+                            mixin = new MixinDefinition("", [], mixin.rules, null, false, null, originalRuleset.visibilityInfo());
                             mixin.originalRuleset = originalRuleset;
                         }
-                        Array.prototype.push.apply(
-                            rules, mixin.evalCall(context, args, this.important).rules);
+                        var newRules = mixin.evalCall(context, args, this.important).rules;
+                        this._setVisibilityToReplacement(newRules);
+                        Array.prototype.push.apply(rules, newRules);
                     } catch (e) {
                         throw { message: e.message, index: this.index, filename: this.currentFileInfo.filename, stack: e.stack };
                     }
@@ -129,14 +140,6 @@ MixinCall.prototype.eval = function (context) {
             }
 
             if (match) {
-                if (!this.currentFileInfo || !this.currentFileInfo.reference) {
-                    for (i = 0; i < rules.length; i++) {
-                        rule = rules[i];
-                        if (rule.markReferenced) {
-                            rule.markReferenced();
-                        }
-                    }
-                }
                 return rules;
             }
         }
@@ -151,6 +154,16 @@ MixinCall.prototype.eval = function (context) {
             index:   this.index, filename: this.currentFileInfo.filename };
     }
 };
+
+MixinCall.prototype._setVisibilityToReplacement = function (replacement) {
+    var i, rule;
+    if (this.blocksVisibility()) {
+        for (i = 0; i < replacement.length; i++) {
+            rule = replacement[i];
+            rule.addVisibilityBlock();
+        }
+    }
+};
 MixinCall.prototype.format = function (args) {
     return this.selector.toCSS().trim() + '(' +
         (args ? args.map(function (a) {

package/lib/less/tree/mixin-definition.js

@@ -5,7 +5,7 @@ var Selector = require("./selector"),
     Expression = require("./expression"),
     contexts = require("../contexts");
 
-var Definition = function (name, params, rules, condition, variadic, frames) {
+var Definition = function (name, params, rules, condition, variadic, frames, visibilityInfo) {
     this.name = name;
     this.selectors = [new Selector([new Element(null, name, this.index, this.currentFileInfo)])];
     this.params = params;
@@ -14,15 +14,19 @@ var Definition = function (name, params, rules, condition, variadic, frames) {
     this.arity = params.length;
     this.rules = rules;
     this._lookups = {};
+    var optionalParameters = [];
     this.required = params.reduce(function (count, p) {
         if (!p.name || (p.name && !p.value)) {
             return count + 1;
         }
         else {
+            optionalParameters.push(p.name);
             return count;
         }
     }, 0);
+    this.optionalParameters = optionalParameters;
     this.frames = frames;
+    this.copyVisibilityInfo(visibilityInfo);
 };
 Definition.prototype = new Ruleset();
 Definition.prototype.type = "MixinDefinition";
@@ -123,7 +127,7 @@ Definition.prototype.makeImportant = function() {
             return r;
         }
     });
-    var result = new Definition (this.name, this.params, rules, this.condition, this.variadic, this.frames);
+    var result = new Definition(this.name, this.params, rules, this.condition, this.variadic, this.frames);
     return result;
 };
 Definition.prototype.eval = function (context) {
@@ -159,22 +163,30 @@ Definition.prototype.matchCondition = function (args, context) {
     return true;
 };
 Definition.prototype.matchArgs = function (args, context) {
-    var argsLength = (args && args.length) || 0, len;
+    var allArgsCnt = (args && args.length) || 0, len, optionalParameters = this.optionalParameters;
+    var requiredArgsCnt = !args ? 0 : args.reduce(function (count, p) {
+        if (optionalParameters.indexOf(p.name) < 0) {
+            return count + 1;
+        } else {
+            return count;
+        }
+    }, 0);
 
     if (! this.variadic) {
-        if (argsLength < this.required) {
+        if (requiredArgsCnt < this.required) {
             return false;
         }
-        if (argsLength > this.params.length) {
+        if (allArgsCnt > this.params.length) {
             return false;
         }
     } else {
-        if (argsLength < (this.required - 1)) {
+        if (requiredArgsCnt < (this.required - 1)) {
             return false;
         }
     }
 
-    len = Math.min(argsLength, this.arity);
+    // check patterns
+    len = Math.min(requiredArgsCnt, this.arity);
 
     for (var i = 0; i < len; i++) {
         if (!this.params[i].name && !this.params[i].variadic) {

package/lib/less/tree/node.js

@@ -71,4 +71,53 @@ Node.numericCompare = function (a, b) {
         : a === b ?  0
         : a  >  b ?  1 : undefined;
 };
+// Returns true if this node represents root of ast imported by reference
+Node.prototype.blocksVisibility = function () {
+    if (this.visibilityBlocks == null) {
+        this.visibilityBlocks = 0;
+    }
+    return this.visibilityBlocks !== 0;
+};
+Node.prototype.addVisibilityBlock = function () {
+    if (this.visibilityBlocks == null) {
+        this.visibilityBlocks = 0;
+    }
+    this.visibilityBlocks = this.visibilityBlocks + 1;
+};
+Node.prototype.removeVisibilityBlock = function () {
+    if (this.visibilityBlocks == null) {
+        this.visibilityBlocks = 0;
+    }
+    this.visibilityBlocks = this.visibilityBlocks - 1;
+};
+//Turns on node visibility - if called node will be shown in output regardless
+//of whether it comes from import by reference or not
+Node.prototype.ensureVisibility = function () {
+    this.nodeVisible = true;
+};
+//Turns off node visibility - if called node will NOT be shown in output regardless
+//of whether it comes from import by reference or not
+Node.prototype.ensureInvisibility = function () {
+    this.nodeVisible = false;
+};
+// return values:
+// false - the node must not be visible
+// true - the node must be visible
+// undefined or null - the node has the same visibility as its parent
+Node.prototype.isVisible = function () {
+    return this.nodeVisible;
+};
+Node.prototype.visibilityInfo = function() {
+    return {
+        visibilityBlocks: this.visibilityBlocks,
+        nodeVisible: this.nodeVisible
+    };
+};
+Node.prototype.copyVisibilityInfo = function(info) {
+    if (!info) {
+        return;
+    }
+    this.visibilityBlocks = info.visibilityBlocks;
+    this.nodeVisible = info.nodeVisible;
+};
 module.exports = Node;

package/lib/less/tree/rule.js

@@ -92,4 +92,4 @@ Rule.prototype.makeImportant = function () {
                           this.index, this.currentFileInfo, this.inline);
 };
 
-module.exports = Rule;
+module.exports = Rule;