less 2.4.0 → 2.5.0

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

@@ -3,7 +3,7 @@
 tree.mixin = {};
 tree.mixin.Call = function (elements, args, index, currentFileInfo, important) {
     this.selector = new(tree.Selector)(elements);
-    this.arguments = args;
+    this.arguments = (args && args.length) ? args : null;
     this.index = index;
     this.currentFileInfo = currentFileInfo;
     this.important = important;
@@ -11,11 +11,17 @@ tree.mixin.Call = function (elements, args, index, currentFileInfo, important) {
 tree.mixin.Call.prototype = {
     type: "MixinCall",
     accept: function (visitor) {
-        this.selector = visitor.visit(this.selector);
-        this.arguments = visitor.visit(this.arguments);
+        if (this.selector) {
+            this.selector = visitor.visit(this.selector);
+        }
+        if (this.arguments) {
+            this.arguments = visitor.visitArray(this.arguments);
+        }
     },
     eval: function (env) {
-        var mixins, mixin, args, rules = [], match = false, i, m, f, isRecursive, isOneFound;
+        var mixins, mixin, args, rules = [], match = false, i, m, f, isRecursive, isOneFound, rule,
+            candidates = [], candidate, conditionResult = [], defaultFunc = tree.defaultFunc,
+            defaultResult, defNone = 0, defTrue = 1, defFalse = 2, count; 
 
         args = this.arguments && this.arguments.map(function (a) {
             return { name: a.name, value: a.value.eval(env) };
@@ -24,6 +30,12 @@ tree.mixin.Call.prototype = {
         for (i = 0; i < env.frames.length; i++) {
             if ((mixins = env.frames[i].find(this.selector)).length > 0) {
                 isOneFound = true;
+                
+                // To make `default()` function independent of definition order we have two "subpasses" here.
+                // At first we evaluate each guard *twice* (with `default() == true` and `default() == false`),
+                // and build candidate list with corresponding flags. Then, when we know all possible matches,
+                // we make a final decision.
+                
                 for (m = 0; m < mixins.length; m++) {
                     mixin = mixins[m];
                     isRecursive = false;
@@ -36,51 +48,111 @@ tree.mixin.Call.prototype = {
                     if (isRecursive) {
                         continue;
                     }
-                    if (mixin.matchArgs(args, env)) {
-                        if (!mixin.matchCondition || mixin.matchCondition(args, env)) {
-                            try {
-                                Array.prototype.push.apply(
-                                      rules, mixin.eval(env, args, this.important).rules);
-                            } catch (e) {
-                                throw { message: e.message, index: this.index, filename: this.currentFileInfo.filename, stack: e.stack };
+                    
+                    if (mixin.matchArgs(args, env)) {  
+                        candidate = {mixin: mixin, group: defNone};
+                        
+                        if (mixin.matchCondition) { 
+                            for (f = 0; f < 2; f++) {
+                                defaultFunc.value(f);
+                                conditionResult[f] = mixin.matchCondition(args, env);
                             }
+                            if (conditionResult[0] || conditionResult[1]) {
+                                if (conditionResult[0] != conditionResult[1]) {
+                                    candidate.group = conditionResult[1] ?
+                                        defTrue : defFalse;
+                                }
+
+                                candidates.push(candidate);
+                            }   
                         }
+                        else {
+                            candidates.push(candidate);
+                        }
+                        
                         match = true;
                     }
                 }
+                
+                defaultFunc.reset();
+
+                count = [0, 0, 0];
+                for (m = 0; m < candidates.length; m++) {
+                    count[candidates[m].group]++;
+                }
+
+                if (count[defNone] > 0) {
+                    defaultResult = defFalse;
+                } else {
+                    defaultResult = defTrue;
+                    if ((count[defTrue] + count[defFalse]) > 1) {
+                        throw { type: 'Runtime',
+                            message: 'Ambiguous use of `default()` found when matching for `'
+                                + this.format(args) + '`',
+                            index: this.index, filename: this.currentFileInfo.filename };
+                    }
+                }
+                
+                for (m = 0; m < candidates.length; m++) {
+                    candidate = candidates[m].group;
+                    if ((candidate === defNone) || (candidate === defaultResult)) {
+                        try {
+                            mixin = candidates[m].mixin;
+                            if (!(mixin instanceof tree.mixin.Definition)) {
+                                mixin = new tree.mixin.Definition("", [], mixin.rules, null, false);
+                                mixin.originalRuleset = mixins[m].originalRuleset || mixins[m];
+                            }
+                            Array.prototype.push.apply(
+                                  rules, mixin.eval(env, args, this.important).rules);
+                        } catch (e) {
+                            throw { message: e.message, index: this.index, filename: this.currentFileInfo.filename, stack: e.stack };
+                        }
+                    }
+                }
+                
                 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;
                 }
             }
         }
         if (isOneFound) {
             throw { type:    'Runtime',
-                    message: 'No matching definition was found for `' +
-                              this.selector.toCSS().trim() + '('      +
-                              (args ? args.map(function (a) {
-                                  var argValue = "";
-                                  if (a.name) {
-                                      argValue += a.name + ":";
-                                  }
-                                  if (a.value.toCSS) {
-                                      argValue += a.value.toCSS();
-                                  } else {
-                                      argValue += "???";
-                                  }
-                                  return argValue;
-                              }).join(', ') : "") + ")`",
+                    message: 'No matching definition was found for `' + this.format(args) + '`',
                     index:   this.index, filename: this.currentFileInfo.filename };
         } else {
-            throw { type: 'Name',
-                message: this.selector.toCSS().trim() + " is undefined",
-                index: this.index, filename: this.currentFileInfo.filename };
+            throw { type:    'Name',
+                    message: this.selector.toCSS().trim() + " is undefined",
+                    index:   this.index, filename: this.currentFileInfo.filename };
         }
+    },
+    format: function (args) {
+        return this.selector.toCSS().trim() + '(' +
+            (args ? args.map(function (a) {
+                var argValue = "";
+                if (a.name) {
+                    argValue += a.name + ":";
+                }
+                if (a.value.toCSS) {
+                    argValue += a.value.toCSS();
+                } else {
+                    argValue += "???";
+                }
+                return argValue;
+            }).join(', ') : "") + ")";
     }
 };
 
 tree.mixin.Definition = function (name, params, rules, condition, variadic) {
     this.name = name;
-    this.selectors = [new(tree.Selector)([new(tree.Element)(null, name)])];
+    this.selectors = [new(tree.Selector)([new(tree.Element)(null, name, this.index, this.currentFileInfo)])];
     this.params = params;
     this.condition = condition;
     this.variadic = variadic;
@@ -88,8 +160,8 @@ tree.mixin.Definition = function (name, params, rules, condition, variadic) {
     this.rules = rules;
     this._lookups = {};
     this.required = params.reduce(function (count, p) {
-        if (!p.name || (p.name && !p.value)) { return count + 1 }
-        else                                 { return count }
+        if (!p.name || (p.name && !p.value)) { return count + 1; }
+        else                                 { return count; }
     }, 0);
     this.parent = tree.Ruleset.prototype;
     this.frames = [];
@@ -97,24 +169,28 @@ tree.mixin.Definition = function (name, params, rules, condition, variadic) {
 tree.mixin.Definition.prototype = {
     type: "MixinDefinition",
     accept: function (visitor) {
-        this.params = visitor.visit(this.params);
-        this.rules = visitor.visit(this.rules);
-        this.condition = visitor.visit(this.condition);
+        if (this.params && this.params.length) {
+            this.params = visitor.visitArray(this.params);
+        }
+        this.rules = visitor.visitArray(this.rules);
+        if (this.condition) {
+            this.condition = visitor.visit(this.condition);
+        }
     },
-    toCSS:     function ()     { return ""; },
     variable:  function (name) { return this.parent.variable.call(this, name); },
     variables: function ()     { return this.parent.variables.call(this); },
     find:      function ()     { return this.parent.find.apply(this, arguments); },
     rulesets:  function ()     { return this.parent.rulesets.apply(this); },
 
     evalParams: function (env, mixinEnv, args, evaldArguments) {
-        var frame = new(tree.Ruleset)(null, []),
+        /*jshint boss:true */
+        var frame = new(tree.Ruleset)(null, null),
             varargs, arg,
             params = this.params.slice(0),
             i, j, val, name, isNamedFound, argIndex;
 
         mixinEnv = new tree.evalEnv(mixinEnv, [frame].concat(mixinEnv.frames));
-        
+
         if (args) {
             args = args.slice(0);
 
@@ -125,7 +201,7 @@ tree.mixin.Definition.prototype = {
                     for(j = 0; j < params.length; j++) {
                         if (!evaldArguments[j] && name === params[j].name) {
                             evaldArguments[j] = arg.value.eval(env);
-                            frame.rules.unshift(new(tree.Rule)(name, arg.value.eval(env)));
+                            frame.prependRule(new(tree.Rule)(name, arg.value.eval(env)));
                             isNamedFound = true;
                             break;
                         }
@@ -143,8 +219,8 @@ tree.mixin.Definition.prototype = {
         }
         argIndex = 0;
         for (i = 0; i < params.length; i++) {
-            if (evaldArguments[i]) continue;
-            
+            if (evaldArguments[i]) { continue; }
+
             arg = args && args[argIndex];
 
             if (name = params[i].name) {
@@ -153,7 +229,7 @@ tree.mixin.Definition.prototype = {
                     for (j = argIndex; j < args.length; j++) {
                         varargs.push(args[j].value.eval(env));
                     }
-                    frame.rules.unshift(new(tree.Rule)(name, new(tree.Expression)(varargs).eval(env)));
+                    frame.prependRule(new(tree.Rule)(name, new(tree.Expression)(varargs).eval(env)));
                 } else {
                     val = arg && arg.value;
                     if (val) {
@@ -166,11 +242,11 @@ tree.mixin.Definition.prototype = {
                             ' (' + args.length + ' for ' + this.arity + ')' };
                     }
                     
-                    frame.rules.unshift(new(tree.Rule)(name, val));
+                    frame.prependRule(new(tree.Rule)(name, val));
                     evaldArguments[i] = val;
                 }
             }
-            
+
             if (params[i].variadic && args) {
                 for (j = argIndex; j < args.length; j++) {
                     evaldArguments[j] = args[j].value.eval(env);
@@ -185,35 +261,38 @@ tree.mixin.Definition.prototype = {
         var _arguments = [],
             mixinFrames = this.frames.concat(env.frames),
             frame = this.evalParams(env, new(tree.evalEnv)(env, mixinFrames), args, _arguments),
-            context, rules, start, ruleset;
+            rules, ruleset;
 
-        frame.rules.unshift(new(tree.Rule)('@arguments', new(tree.Expression)(_arguments).eval(env)));
+        frame.prependRule(new(tree.Rule)('@arguments', new(tree.Expression)(_arguments).eval(env)));
 
-        rules = important ?
-            this.parent.makeImportant.apply(this).rules : this.rules.slice(0);
+        rules = this.rules.slice(0);
 
-        ruleset = new(tree.Ruleset)(null, rules).eval(new(tree.evalEnv)(env,
-                                                    [this, frame].concat(mixinFrames)));
+        ruleset = new(tree.Ruleset)(null, rules);
         ruleset.originalRuleset = this;
+        ruleset = ruleset.eval(new(tree.evalEnv)(env, [this, frame].concat(mixinFrames)));
+        if (important) {
+            ruleset = this.parent.makeImportant.apply(ruleset);
+        }
         return ruleset;
     },
     matchCondition: function (args, env) {
-
         if (this.condition && !this.condition.eval(
             new(tree.evalEnv)(env,
-                [this.evalParams(env, new(tree.evalEnv)(env, this.frames.concat(env.frames)), args, [])]
-                    .concat(env.frames)))) {
+                [this.evalParams(env, new(tree.evalEnv)(env, this.frames.concat(env.frames)), args, [])] // the parameter variables
+                    .concat(this.frames) // the parent namespace/mixin frames
+                    .concat(env.frames)))) { // the current environment frames
             return false;
         }
         return true;
     },
     matchArgs: function (args, env) {
-        var argsLength = (args && args.length) || 0, len, frame;
+        var argsLength = (args && args.length) || 0, len;
 
         if (! this.variadic) {
-            if (argsLength < this.required)                               { return false }
-            if (argsLength > this.params.length)                          { return false }
-            if ((this.required > 0) && (argsLength > this.params.length)) { return false }
+            if (argsLength < this.required)                               { return false; }
+            if (argsLength > this.params.length)                          { return false; }
+        } else {
+            if (argsLength < (this.required - 1))                         { return false; }
         }
 
         len = Math.min(argsLength, this.arity);

data/lib/less/js/lib/less/tree/negative.js

@@ -8,9 +8,11 @@ tree.Negative.prototype = {
     accept: function (visitor) {
         this.value = visitor.visit(this.value);
     },
-    toCSS: function (env) {
-        return '-' + this.value.toCSS(env);
+    genCSS: function (env, output) {
+        output.add('-');
+        this.value.genCSS(env, output);
     },
+    toCSS: tree.toCSS,
     eval: function (env) {
         if (env.isMathOn()) {
             return (new(tree.Operation)('*', [new(tree.Dimension)(-1), this.value])).eval(env);

data/lib/less/js/lib/less/tree/operation.js

@@ -12,17 +12,14 @@ tree.Operation.prototype = {
     },
     eval: function (env) {
         var a = this.operands[0].eval(env),
-            b = this.operands[1].eval(env),
-            temp;
+            b = this.operands[1].eval(env);
 
         if (env.isMathOn()) {
             if (a instanceof tree.Dimension && b instanceof tree.Color) {
-                if (this.op === '*' || this.op === '+') {
-                    temp = b, b = a, a = temp;
-                } else {
-                    throw { type: "Operation",
-                            message: "Can't substract or divide a color from a number" };
-                }
+                a = a.toColor();
+            }
+            if (b instanceof tree.Dimension && a instanceof tree.Color) {
+                b = b.toColor();
             }
             if (!a.operate) {
                 throw { type: "Operation",
@@ -34,10 +31,18 @@ tree.Operation.prototype = {
             return new(tree.Operation)(this.op, [a, b], this.isSpaced);
         }
     },
-    toCSS: function (env) {
-        var separator = this.isSpaced ? " " : "";
-        return this.operands[0].toCSS() + separator + this.op + separator + this.operands[1].toCSS();
-    }
+    genCSS: function (env, output) {
+        this.operands[0].genCSS(env, output);
+        if (this.isSpaced) {
+            output.add(" ");
+        }
+        output.add(this.op);
+        if (this.isSpaced) {
+            output.add(" ");
+        }
+        this.operands[1].genCSS(env, output);
+    },
+    toCSS: tree.toCSS
 };
 
 tree.operate = function (env, op, a, b) {

data/lib/less/js/lib/less/tree/paren.js

@@ -9,9 +9,12 @@ tree.Paren.prototype = {
     accept: function (visitor) {
         this.value = visitor.visit(this.value);
     },
-    toCSS: function (env) {
-        return '(' + this.value.toCSS(env).trim() + ')';
+    genCSS: function (env, output) {
+        output.add('(');
+        this.value.genCSS(env, output);
+        output.add(')');
     },
+    toCSS: tree.toCSS,
     eval: function (env) {
         return new(tree.Paren)(this.value.eval(env));
     }

data/lib/less/js/lib/less/tree/quoted.js

@@ -9,13 +9,16 @@ tree.Quoted = function (str, content, escaped, index, currentFileInfo) {
 };
 tree.Quoted.prototype = {
     type: "Quoted",
-    toCSS: function () {
-        if (this.escaped) {
-            return this.value;
-        } else {
-            return this.quote + this.value + this.quote;
+    genCSS: function (env, output) {
+        if (!this.escaped) {
+            output.add(this.quote, this.currentFileInfo, this.index);
+        }
+        output.add(this.value);
+        if (!this.escaped) {
+            output.add(this.quote);
         }
     },
+    toCSS: tree.toCSS,
     eval: function (env) {
         var that = this;
         var value = this.value.replace(/`([^`]+)`/g, function (_, exp) {
@@ -24,7 +27,7 @@ tree.Quoted.prototype = {
             var v = new(tree.Variable)('@' + name, that.index, that.currentFileInfo).eval(env, true);
             return (v instanceof tree.Quoted) ? v.value : v.toCSS();
         });
-        return new(tree.Quoted)(this.quote + value + this.quote, value, this.escaped, this.index);
+        return new(tree.Quoted)(this.quote + value + this.quote, value, this.escaped, this.index, this.currentFileInfo);
     },
     compare: function (x) {
         if (!x.toCSS) {

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

@@ -1,16 +1,14 @@
 (function (tree) {
 
-tree.Rule = function (name, value, important, index, currentFileInfo, inline) {
+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.important = important ? ' ' + important.trim() : '';
+    this.merge = merge;
     this.index = index;
     this.currentFileInfo = currentFileInfo;
     this.inline = inline || false;
-
-    if (name.charAt(0) === '@') {
-        this.variable = true;
-    } else { this.variable = false }
+    this.variable = name.charAt && (name.charAt(0) === '@');
 };
 
 tree.Rule.prototype = {
@@ -18,33 +16,43 @@ tree.Rule.prototype = {
     accept: function (visitor) {
         this.value = visitor.visit(this.value);
     },
-    toCSS: function (env) {
-        if (this.variable) { return "" }
-        else {
-            try {
-                return this.name + (env.compress ? ':' : ': ') +
-                   this.value.toCSS(env) +
-                   this.important + (this.inline ? "" : ";");
-            }
-            catch(e) {
-                e.index = this.index;
-                e.filename = this.currentFileInfo.filename;
-                throw e;
-            }
+    genCSS: function (env, output) {
+        output.add(this.name + (env.compress ? ':' : ': '), this.currentFileInfo, this.index);
+        try {
+            this.value.genCSS(env, output);
+        }
+        catch(e) {
+            e.index = this.index;
+            e.filename = this.currentFileInfo.filename;
+            throw e;
         }
+        output.add(this.important + ((this.inline || (env.lastRule && env.compress)) ? "" : ";"), this.currentFileInfo, this.index);
     },
+    toCSS: tree.toCSS,
     eval: function (env) {
-        var strictMathBypass = false;
-        if (this.name === "font" && !env.strictMath) {
+        var strictMathBypass = false, name = this.name;    
+        if (typeof name !== "string") {
+            // expand 'primitive' name directly to get
+            // things faster (~10% for benchmark.less):
+            name = (name.length === 1) 
+                && (name[0] instanceof tree.Keyword)
+                    ? name[0].value : evalName(env, name);
+        }
+        if (name === "font" && !env.strictMath) {
             strictMathBypass = true;
             env.strictMath = true;
         }
         try {
-            return new(tree.Rule)(this.name,
+            return new(tree.Rule)(name,
                               this.value.eval(env),
                               this.important,
+                              this.merge,
                               this.index, this.currentFileInfo, this.inline);
         }
+        catch(e) {
+            e.index = e.index || this.index;
+            throw e;
+        }
         finally {
             if (strictMathBypass) {
                 env.strictMath = false;
@@ -55,8 +63,18 @@ tree.Rule.prototype = {
         return new(tree.Rule)(this.name,
                               this.value,
                               "!important",
+                              this.merge,
                               this.index, this.currentFileInfo, this.inline);
     }
 };
 
+function evalName(env, name) {
+    var value = "", i, n = name.length,
+        output = {add: function (s) {value += s;}};
+    for (i = 0; i < n; i++) {
+        name[i].eval(env).genCSS(env, output);
+    }
+    return value;
+}
+
 })(require('../tree'));