less 2.5.1 → 2.6.0

data/lib/less/js/lib/less/to-css-visitor.js

@@ -202,14 +202,36 @@
             }
 
             Object.keys(groups).map(function (k) {
+
+                function toExpression(values) {
+                    return new (tree.Expression)(values.map(function (p) {
+                        return p.value;
+                    }));
+                }
+
+                function toValue(values) {
+                    return new (tree.Value)(values.map(function (p) {
+                        return p;
+                    }));
+                }
+
                 parts = groups[k];
 
                 if (parts.length > 1) {
                     rule = parts[0];
-
-                    rule.value = new (tree.Value)(parts.map(function (p) {
-                        return p.value;
-                    }));
+                    var spacedGroups = [];
+                    var lastSpacedGroup = [];
+                    parts.map(function (p) {
+                    if (p.merge==="+") {
+                        if (lastSpacedGroup.length > 0) {
+                                spacedGroups.push(toExpression(lastSpacedGroup));
+                            }
+                            lastSpacedGroup = [];
+                        }
+                        lastSpacedGroup.push(p);
+                    });
+                    spacedGroups.push(toExpression(lastSpacedGroup));
+                    rule.value = toValue(spacedGroups);
                 }
             });
         }

data/lib/less/js/lib/less/tree/color.js

@@ -28,7 +28,17 @@ var transparentKeyword = "transparent";
 tree.Color.prototype = {
     type: "Color",
     eval: function () { return this; },
-    luma: function () { return (0.2126 * this.rgb[0] / 255) + (0.7152 * this.rgb[1] / 255) + (0.0722 * this.rgb[2] / 255); },
+    luma: function () {
+        var r = this.rgb[0] / 255,
+            g = this.rgb[1] / 255,
+            b = this.rgb[2] / 255;
+
+        r = (r <= 0.03928) ? r / 12.92 : Math.pow(((r + 0.055) / 1.055), 2.4);
+        g = (g <= 0.03928) ? g / 12.92 : Math.pow(((g + 0.055) / 1.055), 2.4);
+        b = (b <= 0.03928) ? b / 12.92 : Math.pow(((b + 0.055) / 1.055), 2.4);
+
+        return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+    },
 
     genCSS: function (env, output) {
         output.add(this.toCSS(env));

data/lib/less/js/lib/less/tree/detached-ruleset.js

@@ -0,0 +1,20 @@
+(function (tree) {
+
+tree.DetachedRuleset = function (ruleset, frames) {
+    this.ruleset = ruleset;
+    this.frames = frames;
+};
+tree.DetachedRuleset.prototype = {
+    type: "DetachedRuleset",
+    accept: function (visitor) {
+        this.ruleset = visitor.visit(this.ruleset);
+    },
+    eval: function (env) {
+        var frames = this.frames || env.frames.slice(0);
+        return new tree.DetachedRuleset(this.ruleset, frames);
+    },
+    callEval: function (env) {
+        return this.ruleset.eval(this.frames ? new(tree.evalEnv)(env, this.frames.concat(env.frames)) : env);
+    }
+};
+})(require('../tree'));

data/lib/less/js/lib/less/tree/dimension.js

@@ -89,17 +89,27 @@ tree.Dimension.prototype = {
 
     compare: function (other) {
         if (other instanceof tree.Dimension) {
-            var a = this.unify(), b = other.unify(),
-                aValue = a.value, bValue = b.value;
+            var a, b,
+                aValue, bValue;
+            
+            if (this.unit.isEmpty() || other.unit.isEmpty()) {
+                a = this;
+                b = other;
+            } else {
+                a = this.unify();
+                b = other.unify();
+                if (a.unit.compare(b.unit) !== 0) {
+                    return -1;
+                }                
+            }
+            aValue = a.value;
+            bValue = b.value;
 
             if (bValue > aValue) {
                 return -1;
             } else if (bValue < aValue) {
                 return 1;
             } else {
-                if (!b.unit.isEmpty() && a.unit.compare(b.unit) !== 0) {
-                    return -1;
-                }
                 return 0;
             }
         } else {
@@ -108,7 +118,7 @@ tree.Dimension.prototype = {
     },
 
     unify: function () {
-        return this.convertTo({ length: 'm', duration: 's', angle: 'rad' });
+        return this.convertTo({ length: 'px', duration: 's', angle: 'rad' });
     },
 
     convertTo: function (conversions) {
@@ -161,6 +171,7 @@ tree.UnitConversions = {
         'cm': 0.01,
         'mm': 0.001,
         'in': 0.0254,
+        'px': 0.0254 / 96,
         'pt': 0.0254 / 72,
         'pc': 0.0254 / 72 * 12
     },

data/lib/less/js/lib/less/tree/directive.js

@@ -1,58 +1,62 @@
 (function (tree) {
 
-tree.Directive = function (name, value, index, currentFileInfo) {
-    this.name = name;
-
-    if (Array.isArray(value)) {
-        this.rules = [new(tree.Ruleset)(null, value)];
-        this.rules[0].allowImports = true;
-    } else {
-        this.value = value;
+tree.Directive = function (name, value, rules, index, currentFileInfo, debugInfo) {
+    this.name  = name;
+    this.value = value;
+    if (rules) {
+        this.rules = rules;
+        this.rules.allowImports = true;
     }
     this.index = index;
     this.currentFileInfo = currentFileInfo;
-
+    this.debugInfo = debugInfo;
 };
+
 tree.Directive.prototype = {
     type: "Directive",
     accept: function (visitor) {
-        if (this.rules) {
-            this.rules = visitor.visitArray(this.rules);
+        var value = this.value, rules = this.rules;
+        if (rules) {
+            rules = visitor.visit(rules);
         }
-        if (this.value) {
-            this.value = visitor.visit(this.value);
+        if (value) {
+            value = visitor.visit(value);
         }
     },
     genCSS: function (env, output) {
+        var value = this.value, rules = this.rules;
         output.add(this.name, this.currentFileInfo, this.index);
-        if (this.rules) {
-            tree.outputRuleset(env, output, this.rules);
-        } else {
+        if (value) {
             output.add(' ');
-            this.value.genCSS(env, output);
+            value.genCSS(env, output);
+        }
+        if (rules) {
+            tree.outputRuleset(env, output, [rules]);
+        } else {
             output.add(';');
         }
     },
     toCSS: tree.toCSS,
     eval: function (env) {
-        var evaldDirective = this;
-        if (this.rules) {
-            env.frames.unshift(this);
-            evaldDirective = new(tree.Directive)(this.name, null, this.index, this.currentFileInfo);
-            evaldDirective.rules = [this.rules[0].eval(env)];
-            evaldDirective.rules[0].root = true;
-            env.frames.shift();
+        var value = this.value, rules = this.rules;
+        if (value) {
+            value = value.eval(env);
+        }
+        if (rules) {
+            rules = rules.eval(env);
+            rules.root = true;
         }
-        return evaldDirective;
+        return new(tree.Directive)(this.name, value, rules,
+            this.index, this.currentFileInfo, this.debugInfo);
     },
-    variable: function (name) { return tree.Ruleset.prototype.variable.call(this.rules[0], name); },
-    find: function () { return tree.Ruleset.prototype.find.apply(this.rules[0], arguments); },
-    rulesets: function () { return tree.Ruleset.prototype.rulesets.apply(this.rules[0]); },
+    variable: function (name) { if (this.rules) return tree.Ruleset.prototype.variable.call(this.rules, name); },
+    find: function () { if (this.rules) return tree.Ruleset.prototype.find.apply(this.rules, arguments); },
+    rulesets: function () { if (this.rules) return tree.Ruleset.prototype.rulesets.apply(this.rules); },
     markReferenced: function () {
         var i, rules;
         this.isReferenced = true;
         if (this.rules) {
-            rules = this.rules[0].rules;
+            rules = this.rules.rules;
             for (i = 0; i < rules.length; i++) {
                 if (rules[i].markReferenced) {
                     rules[i].markReferenced();

data/lib/less/js/lib/less/tree/import.js

@@ -92,7 +92,14 @@ tree.Import.prototype = {
     eval: function (env) {
         var ruleset, features = this.features && this.features.eval(env);
 
-        if (this.skip) { return []; }
+        if (this.skip) {
+            if (typeof this.skip === "function") {
+                this.skip = this.skip();
+            }
+            if (this.skip) {
+                return []; 
+            }
+        }
          
         if (this.options.inline) {
             //todo needs to reference css file not import

data/lib/less/js/lib/less/tree/keyword.js

@@ -5,6 +5,7 @@ tree.Keyword.prototype = {
     type: "Keyword",
     eval: function () { return this; },
     genCSS: function (env, output) {
+        if (this.value === '%') { throw { type: "Syntax", message: "Invalid % without number" }; }
         output.add(this.value);
     },
     toCSS: tree.toCSS,

data/lib/less/js/lib/less/tree/media.js

@@ -74,6 +74,7 @@ tree.Media.prototype = {
     },
     markReferenced: function () {
         var i, rules = this.rules[0].rules;
+        this.rules[0].markReferenced();
         this.isReferenced = true;
         for (i = 0; i < rules.length; i++) {
             if (rules[i].markReferenced) {
@@ -147,6 +148,8 @@ tree.Media.prototype = {
       }
     },
     bubbleSelectors: function (selectors) {
+      if (!selectors)
+        return;
       this.rules = [new(tree.Ruleset)(selectors.slice(0), [this.rules[0]])];
     }
 };

data/lib/less/js/lib/less/tree/mixin.js

@@ -103,7 +103,7 @@ tree.mixin.Call.prototype = {
                                 mixin.originalRuleset = mixins[m].originalRuleset || mixins[m];
                             }
                             Array.prototype.push.apply(
-                                  rules, mixin.eval(env, args, this.important).rules);
+                                  rules, mixin.evalCall(env, args, this.important).rules);
                         } catch (e) {
                             throw { message: e.message, index: this.index, filename: this.currentFileInfo.filename, stack: e.stack };
                         }
@@ -150,7 +150,7 @@ tree.mixin.Call.prototype = {
     }
 };
 
-tree.mixin.Definition = function (name, params, rules, condition, variadic) {
+tree.mixin.Definition = function (name, params, rules, condition, variadic, frames) {
     this.name = name;
     this.selectors = [new(tree.Selector)([new(tree.Element)(null, name, this.index, this.currentFileInfo)])];
     this.params = params;
@@ -164,7 +164,7 @@ tree.mixin.Definition = function (name, params, rules, condition, variadic) {
         else                                 { return count; }
     }, 0);
     this.parent = tree.Ruleset.prototype;
-    this.frames = [];
+    this.frames = frames;
 };
 tree.mixin.Definition.prototype = {
     type: "MixinDefinition",
@@ -187,14 +187,15 @@ tree.mixin.Definition.prototype = {
         var frame = new(tree.Ruleset)(null, null),
             varargs, arg,
             params = this.params.slice(0),
-            i, j, val, name, isNamedFound, argIndex;
+            i, j, val, name, isNamedFound, argIndex, argsLength = 0;
 
         mixinEnv = new tree.evalEnv(mixinEnv, [frame].concat(mixinEnv.frames));
 
         if (args) {
             args = args.slice(0);
+            argsLength = args.length;
 
-            for(i = 0; i < args.length; i++) {
+            for(i = 0; i < argsLength; i++) {
                 arg = args[i];
                 if (name = (arg && arg.name)) {
                     isNamedFound = false;
@@ -224,9 +225,9 @@ tree.mixin.Definition.prototype = {
             arg = args && args[argIndex];
 
             if (name = params[i].name) {
-                if (params[i].variadic && args) {
+                if (params[i].variadic) {
                     varargs = [];
-                    for (j = argIndex; j < args.length; j++) {
+                    for (j = argIndex; j < argsLength; j++) {
                         varargs.push(args[j].value.eval(env));
                     }
                     frame.prependRule(new(tree.Rule)(name, new(tree.Expression)(varargs).eval(env)));
@@ -239,7 +240,7 @@ tree.mixin.Definition.prototype = {
                         frame.resetCache();
                     } else {
                         throw { type: 'Runtime', message: "wrong number of arguments for " + this.name +
-                            ' (' + args.length + ' for ' + this.arity + ')' };
+                            ' (' + argsLength + ' for ' + this.arity + ')' };
                     }
                     
                     frame.prependRule(new(tree.Rule)(name, val));
@@ -248,7 +249,7 @@ tree.mixin.Definition.prototype = {
             }
 
             if (params[i].variadic && args) {
-                for (j = argIndex; j < args.length; j++) {
+                for (j = argIndex; j < argsLength; j++) {
                     evaldArguments[j] = args[j].value.eval(env);
                 }
             }
@@ -257,9 +258,12 @@ tree.mixin.Definition.prototype = {
 
         return frame;
     },
-    eval: function (env, args, important) {
+    eval: function (env) {
+        return new tree.mixin.Definition(this.name, this.params, this.rules, this.condition, this.variadic, this.frames || env.frames.slice(0));
+    },
+    evalCall: function (env, args, important) {
         var _arguments = [],
-            mixinFrames = this.frames.concat(env.frames),
+            mixinFrames = this.frames ? this.frames.concat(env.frames) : env.frames,
             frame = this.evalParams(env, new(tree.evalEnv)(env, mixinFrames), args, _arguments),
             rules, ruleset;
 

data/lib/less/js/lib/less/tree/rule.js

@@ -2,7 +2,7 @@
 
 tree.Rule = function (name, value, important, merge, index, currentFileInfo, inline) {
     this.name = name;
-    this.value = (value instanceof tree.Value) ? value : new(tree.Value)([value]);
+    this.value = (value instanceof tree.Value || value instanceof tree.Ruleset) ? value : new(tree.Value)([value]);
     this.important = important ? ' ' + important.trim() : '';
     this.merge = merge;
     this.index = index;
@@ -30,7 +30,7 @@ tree.Rule.prototype = {
     },
     toCSS: tree.toCSS,
     eval: function (env) {
-        var strictMathBypass = false, name = this.name;    
+        var strictMathBypass = false, name = this.name, evaldValue;
         if (typeof name !== "string") {
             // expand 'primitive' name directly to get
             // things faster (~10% for benchmark.less):
@@ -43,14 +43,24 @@ tree.Rule.prototype = {
             env.strictMath = true;
         }
         try {
+            evaldValue = this.value.eval(env);
+            
+            if (!this.variable && evaldValue.type === "DetachedRuleset") {
+                throw { message: "Rulesets cannot be evaluated on a property.",
+                        index: this.index, filename: this.currentFileInfo.filename };
+            }
+
             return new(tree.Rule)(name,
-                              this.value.eval(env),
+                              evaldValue,
                               this.important,
                               this.merge,
                               this.index, this.currentFileInfo, this.inline);
         }
         catch(e) {
-            e.index = e.index || this.index;
+            if (typeof e.index !== 'number') {
+                e.index = this.index;
+                e.filename = this.currentFileInfo.filename;
+            }
             throw e;
         }
         finally {

data/lib/less/js/lib/less/tree/ruleset-call.js

@@ -0,0 +1,16 @@
+(function (tree) {
+
+tree.RulesetCall = function (variable) {
+    this.variable = variable;
+};
+tree.RulesetCall.prototype = {
+    type: "RulesetCall",
+    accept: function (visitor) {
+    },
+    eval: function (env) {
+        var detachedRuleset = new(tree.Variable)(this.variable).eval(env);
+        return detachedRuleset.callEval(env);
+    }
+};
+
+})(require('../tree'));

data/lib/less/js/lib/less/tree/ruleset.js

@@ -20,7 +20,8 @@ tree.Ruleset.prototype = {
     },
     eval: function (env) {
         var thisSelectors = this.selectors, selectors, 
-            selCnt, i, defaultFunc = tree.defaultFunc;
+            selCnt, selector, i, defaultFunc = tree.defaultFunc, hasOnePassingSelector = false;
+
         if (thisSelectors && (selCnt = thisSelectors.length)) {
             selectors = [];
             defaultFunc.error({
@@ -28,9 +29,15 @@ tree.Ruleset.prototype = {
                 message: "it is currently only allowed in parametric mixin guards," 
             });
             for (i = 0; i < selCnt; i++) {
-                selectors.push(thisSelectors[i].eval(env));
+                selector = thisSelectors[i].eval(env);
+                selectors.push(selector);
+                if (selector.evaldCondition) {
+                    hasOnePassingSelector = true;
+                }
             }
             defaultFunc.reset();  
+        } else {
+            hasOnePassingSelector = true;
         }
 
         var rules = this.rules ? this.rules.slice(0) : null,
@@ -45,6 +52,10 @@ tree.Ruleset.prototype = {
         if(this.debugInfo) {
             ruleset.debugInfo = this.debugInfo;
         }
+        
+        if (!hasOnePassingSelector) {
+            rules.length = 0;
+        }
 
         // push the current ruleset to the frames stack
         var envFrames = env.frames;
@@ -66,8 +77,8 @@ tree.Ruleset.prototype = {
         // so they can be evaluated like closures when the time comes.
         var rsRules = ruleset.rules, rsRuleCnt = rsRules ? rsRules.length : 0;
         for (i = 0; i < rsRuleCnt; i++) {
-            if (rsRules[i] instanceof tree.mixin.Definition) {
-                rsRules[i].frames = envFrames.slice(0);
+            if (rsRules[i] instanceof tree.mixin.Definition || rsRules[i] instanceof tree.DetachedRuleset) {
+                rsRules[i] = rsRules[i].eval(env);
             }
         }
 
@@ -90,28 +101,43 @@ tree.Ruleset.prototype = {
                 rsRuleCnt += rules.length - 1;
                 i += rules.length-1;
                 ruleset.resetCache();
+            } else if (rsRules[i] instanceof tree.RulesetCall) {
+                /*jshint loopfunc:true */
+                rules = rsRules[i].eval(env).rules.filter(function(r) {
+                    if ((r instanceof tree.Rule) && r.variable) {
+                        // do not pollute the scope at all
+                        return false;
+                    }
+                    return true;
+                });
+                rsRules.splice.apply(rsRules, [i, 1].concat(rules));
+                rsRuleCnt += rules.length - 1;
+                i += rules.length-1;
+                ruleset.resetCache();
             }
         }
 
         // Evaluate everything else
         for (i = 0; i < rsRules.length; i++) {
             rule = rsRules[i];
-            if (! (rule instanceof tree.mixin.Definition)) {
+            if (! (rule instanceof tree.mixin.Definition || rule instanceof tree.DetachedRuleset)) {
                 rsRules[i] = rule = rule.eval ? rule.eval(env) : rule;
-                // for rulesets, check if it is a css guard and can be removed
-                if (rule instanceof tree.Ruleset && rule.selectors && rule.selectors.length === 1) {
-                    // check if it can be folded in (e.g. & where)
-                    if (rule.selectors[0].isJustParentSelector()) {
-                        rsRules.splice(i--, 1);
-                        // cannot call if there is no selector, so we can just continue
-                        if (!rule.selectors[0].evaldCondition) {
-                            continue;
-                        }
-                        for(var j = 0; j < rule.rules.length; j++) {
-                            subRule = rule.rules[j];
-                            if (!(subRule instanceof tree.Rule) || !subRule.variable) {
-                                rsRules.splice(++i, 0, subRule);
-                            }
+            }
+        }
+        
+        // Evaluate everything else
+        for (i = 0; i < rsRules.length; i++) {
+            rule = rsRules[i];
+            // for rulesets, check if it is a css guard and can be removed
+            if (rule instanceof tree.Ruleset && rule.selectors && rule.selectors.length === 1) {
+                // check if it can be folded in (e.g. & where)
+                if (rule.selectors[0].isJustParentSelector()) {
+                    rsRules.splice(i--, 1);
+
+                    for(var j = 0; j < rule.rules.length; j++) {
+                        subRule = rule.rules[j];
+                        if (!(subRule instanceof tree.Rule) || !subRule.variable) {
+                            rsRules.splice(++i, 0, subRule);
                         }
                     }
                 }
@@ -345,6 +371,9 @@ tree.Ruleset.prototype = {
     toCSS: tree.toCSS,
 
     markReferenced: function () {
+        if (!this.selectors) {
+            return;
+        }
         for (var s = 0; s < this.selectors.length; s++) {
             this.selectors[s].markReferenced();
         }