less 2.2.2 → 2.6.0

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

@@ -1,53 +1,158 @@
 (function (tree) {
 
 tree.mixin = {};
-tree.mixin.Call = function (elements, args, index, filename, important) {
+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.filename = filename;
+    this.currentFileInfo = currentFileInfo;
     this.important = important;
 };
 tree.mixin.Call.prototype = {
+    type: "MixinCall",
+    accept: function (visitor) {
+        if (this.selector) {
+            this.selector = visitor.visit(this.selector);
+        }
+        if (this.arguments) {
+            this.arguments = visitor.visitArray(this.arguments);
+        }
+    },
     eval: function (env) {
-        var mixins, args, rules = [], match = false;
+        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; 
 
-        for (var i = 0; i < env.frames.length; i++) {
+        args = this.arguments && this.arguments.map(function (a) {
+            return { name: a.name, value: a.value.eval(env) };
+        });
+
+        for (i = 0; i < env.frames.length; i++) {
             if ((mixins = env.frames[i].find(this.selector)).length > 0) {
-                args = this.arguments && this.arguments.map(function (a) { return a.eval(env) });
-                for (var m = 0; m < mixins.length; m++) {
-                    if (mixins[m].match(args, env)) {
+                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;
+                    for(f = 0; f < env.frames.length; f++) {
+                        if ((!(mixin instanceof tree.mixin.Definition)) && mixin === (env.frames[f].originalRuleset || env.frames[f])) {
+                            isRecursive = true;
+                            break;
+                        }
+                    }
+                    if (isRecursive) {
+                        continue;
+                    }
+                    
+                    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, mixins[m].eval(env, this.arguments, this.important).rules);
-                            match = true;
+                                  rules, mixin.evalCall(env, args, this.important).rules);
                         } catch (e) {
-                            throw { message: e.message, index: this.index, filename: this.filename, stack: e.stack };
+                            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;
-                } else {
-                    throw { type:    'Runtime',
-                            message: 'No matching definition was found for `' +
-                                      this.selector.toCSS().trim() + '('      +
-                                      this.arguments.map(function (a) {
-                                          return a.toCSS();
-                                      }).join(', ') + ")`",
-                            index:   this.index, filename: this.filename };
                 }
             }
         }
-        throw { type: 'Name',
-                message: this.selector.toCSS().trim() + " is undefined",
-                index: this.index, filename: this.filename };
+        if (isOneFound) {
+            throw { type:    'Runtime',
+                    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 };
+        }
+    },
+    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) {
+tree.mixin.Definition = function (name, params, rules, condition, variadic, frames) {
     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;
@@ -55,75 +160,150 @@ 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 = [];
+    this.frames = frames;
 };
 tree.mixin.Definition.prototype = {
-    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, args) {
-        var frame = new(tree.Ruleset)(null, []), varargs;
-
-        for (var i = 0, val, name; i < this.params.length; i++) {
-            if (name = this.params[i].name) {
-                if (this.params[i].variadic && args) {
+    type: "MixinDefinition",
+    accept: function (visitor) {
+        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);
+        }
+    },
+    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) {
+        /*jshint boss:true */
+        var frame = new(tree.Ruleset)(null, null),
+            varargs, arg,
+            params = this.params.slice(0),
+            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 < argsLength; i++) {
+                arg = args[i];
+                if (name = (arg && arg.name)) {
+                    isNamedFound = false;
+                    for(j = 0; j < params.length; j++) {
+                        if (!evaldArguments[j] && name === params[j].name) {
+                            evaldArguments[j] = arg.value.eval(env);
+                            frame.prependRule(new(tree.Rule)(name, arg.value.eval(env)));
+                            isNamedFound = true;
+                            break;
+                        }
+                    }
+                    if (isNamedFound) {
+                        args.splice(i, 1);
+                        i--;
+                        continue;
+                    } else {
+                        throw { type: 'Runtime', message: "Named argument for " + this.name +
+                            ' ' + args[i].name + ' not found' };
+                    }
+                }
+            }
+        }
+        argIndex = 0;
+        for (i = 0; i < params.length; i++) {
+            if (evaldArguments[i]) { continue; }
+
+            arg = args && args[argIndex];
+
+            if (name = params[i].name) {
+                if (params[i].variadic) {
                     varargs = [];
-                    for (var j = i; j < args.length; j++) {
-                        varargs.push(args[j].eval(env));
+                    for (j = argIndex; j < argsLength; j++) {
+                        varargs.push(args[j].value.eval(env));
                     }
-                    frame.rules.unshift(new(tree.Rule)(name, new(tree.Expression)(varargs).eval(env)));
-                } else if (val = (args && args[i]) || this.params[i].value) {
-                    frame.rules.unshift(new(tree.Rule)(name, val.eval(env)));
+                    frame.prependRule(new(tree.Rule)(name, new(tree.Expression)(varargs).eval(env)));
                 } else {
-                    throw { type: 'Runtime', message: "wrong number of arguments for " + this.name +
-                            ' (' + args.length + ' for ' + this.arity + ')' };
+                    val = arg && arg.value;
+                    if (val) {
+                        val = val.eval(env);
+                    } else if (params[i].value) {
+                        val = params[i].value.eval(mixinEnv);
+                        frame.resetCache();
+                    } else {
+                        throw { type: 'Runtime', message: "wrong number of arguments for " + this.name +
+                            ' (' + argsLength + ' for ' + this.arity + ')' };
+                    }
+                    
+                    frame.prependRule(new(tree.Rule)(name, val));
+                    evaldArguments[i] = val;
+                }
+            }
+
+            if (params[i].variadic && args) {
+                for (j = argIndex; j < argsLength; j++) {
+                    evaldArguments[j] = args[j].value.eval(env);
                 }
             }
+            argIndex++;
         }
+
         return frame;
     },
-    eval: function (env, args, important) {
-        var frame = this.evalParams(env, args), context, _arguments = [], rules, start;
+    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 ? this.frames.concat(env.frames) : env.frames,
+            frame = this.evalParams(env, new(tree.evalEnv)(env, mixinFrames), args, _arguments),
+            rules, ruleset;
 
-        for (var i = 0; i < Math.max(this.params.length, args && args.length); i++) {
-            _arguments.push(args[i] || this.params[i].value);
-        }
-        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.rules.map(function (r) {
-                return new(tree.Rule)(r.name, r.value, '!important', r.index);
-            }) : this.rules.slice(0);
+        rules = this.rules.slice(0);
 
-        return new(tree.Ruleset)(null, rules).eval({
-            frames: [this, frame].concat(this.frames, env.frames)
-        });
+        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;
     },
-    match: function (args, env) {
-        var argsLength = (args && args.length) || 0, len, frame;
+    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, [])] // 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;
 
         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; }
         }
 
-        if (this.condition && !this.condition.eval({
-            frames: [this.evalParams(env, args)].concat(env.frames)
-        }))                                                           { return false }
-
         len = Math.min(argsLength, this.arity);
 
         for (var i = 0; i < len; i++) {
-            if (!this.params[i].name) {
-                if (args[i].eval(env).toCSS() != this.params[i].value.eval(env).toCSS()) {
+            if (!this.params[i].name && !this.params[i].variadic) {
+                if (args[i].value.eval(env).toCSS() != this.params[i].value.eval(env).toCSS()) {
                     return false;
                 }
             }

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

@@ -0,0 +1,24 @@
+(function (tree) {
+
+tree.Negative = function (node) {
+    this.value = node;
+};
+tree.Negative.prototype = {
+    type: "Negative",
+    accept: function (visitor) {
+        this.value = visitor.visit(this.value);
+    },
+    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);
+        }
+        return new(tree.Negative)(this.value.eval(env));
+    }
+};
+
+})(require('../tree'));

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

@@ -1,26 +1,51 @@
 (function (tree) {
 
-tree.Operation = function (op, operands) {
+tree.Operation = function (op, operands, isSpaced) {
     this.op = op.trim();
     this.operands = operands;
+    this.isSpaced = isSpaced;
 };
-tree.Operation.prototype.eval = function (env) {
-    var a = this.operands[0].eval(env),
-        b = this.operands[1].eval(env),
-        temp;
+tree.Operation.prototype = {
+    type: "Operation",
+    accept: function (visitor) {
+        this.operands = visitor.visit(this.operands);
+    },
+    eval: function (env) {
+        var a = this.operands[0].eval(env),
+            b = this.operands[1].eval(env);
 
-    if (a instanceof tree.Dimension && b instanceof tree.Color) {
-        if (this.op === '*' || this.op === '+') {
-            temp = b, b = a, a = temp;
+        if (env.isMathOn()) {
+            if (a instanceof tree.Dimension && b instanceof tree.Color) {
+                a = a.toColor();
+            }
+            if (b instanceof tree.Dimension && a instanceof tree.Color) {
+                b = b.toColor();
+            }
+            if (!a.operate) {
+                throw { type: "Operation",
+                        message: "Operation on an invalid type" };
+            }
+
+            return a.operate(env, this.op, b);
         } else {
-            throw { name: "OperationError",
-                    message: "Can't substract or divide a color from a number" };
+            return new(tree.Operation)(this.op, [a, b], this.isSpaced);
         }
-    }
-    return a.operate(this.op, b);
+    },
+    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 (op, a, b) {
+tree.operate = function (env, op, a, b) {
     switch (op) {
         case '+': return a + b;
         case '-': return a - b;

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

@@ -5,9 +5,16 @@ tree.Paren = function (node) {
     this.value = node;
 };
 tree.Paren.prototype = {
-    toCSS: function (env) {
-        return '(' + this.value.toCSS(env) + ')';
+    type: "Paren",
+    accept: function (visitor) {
+        this.value = visitor.visit(this.value);
     },
+    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

@@ -1,28 +1,47 @@
 (function (tree) {
 
-tree.Quoted = function (str, content, escaped, i) {
+tree.Quoted = function (str, content, escaped, index, currentFileInfo) {
     this.escaped = escaped;
     this.value = content || '';
     this.quote = str.charAt(0);
-    this.index = i;
+    this.index = index;
+    this.currentFileInfo = currentFileInfo;
 };
 tree.Quoted.prototype = {
-    toCSS: function () {
-        if (this.escaped) {
-            return this.value;
-        } else {
-            return this.quote + this.value + this.quote;
+    type: "Quoted",
+    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) {
             return new(tree.JavaScript)(exp, that.index, true).eval(env).value;
         }).replace(/@\{([\w-]+)\}/g, function (_, name) {
-            var v = new(tree.Variable)('@' + name, that.index).eval(env);
-            return ('value' in v) ? v.value : v.toCSS();
+            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) {
+            return -1;
+        }
+        
+        var left = this.toCSS(),
+            right = x.toCSS();
+        
+        if (left === right) {
+            return 0;
+        }
+        
+        return left < right ? -1 : 1;
     }
 };
 

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

@@ -1,42 +1,90 @@
 (function (tree) {
 
-tree.Rule = function (name, value, important, index, 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.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;
+    this.currentFileInfo = currentFileInfo;
     this.inline = inline || false;
-
-    if (name.charAt(0) === '@') {
-        this.variable = true;
-    } else { this.variable = false }
-};
-tree.Rule.prototype.toCSS = function (env) {
-    if (this.variable) { return "" }
-    else {
-        return this.name + (env.compress ? ':' : ': ') +
-               this.value.toCSS(env) +
-               this.important + (this.inline ? "" : ";");
-    }
+    this.variable = name.charAt && (name.charAt(0) === '@');
 };
 
-tree.Rule.prototype.eval = function (context) {
-    return new(tree.Rule)(this.name,
-                          this.value.eval(context),
-                          this.important,
-                          this.index, this.inline);
-};
-
-tree.Shorthand = function (a, b) {
-    this.a = a;
-    this.b = b;
-};
+tree.Rule.prototype = {
+    type: "Rule",
+    accept: function (visitor) {
+        this.value = visitor.visit(this.value);
+    },
+    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, name = this.name, evaldValue;
+        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 {
+            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 };
+            }
 
-tree.Shorthand.prototype = {
-    toCSS: function (env) {
-        return this.a.toCSS(env) + "/" + this.b.toCSS(env);
+            return new(tree.Rule)(name,
+                              evaldValue,
+                              this.important,
+                              this.merge,
+                              this.index, this.currentFileInfo, this.inline);
+        }
+        catch(e) {
+            if (typeof e.index !== 'number') {
+                e.index = this.index;
+                e.filename = this.currentFileInfo.filename;
+            }
+            throw e;
+        }
+        finally {
+            if (strictMathBypass) {
+                env.strictMath = false;
+            }
+        }
     },
-    eval: function () { return this }
+    makeImportant: function () {
+        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'));