less 2.3.3 → 2.4.0

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

@@ -0,0 +1,22 @@
+(function (tree) {
+
+tree.Negative = function (node) {
+    this.value = node;
+};
+tree.Negative.prototype = {
+    type: "Negative",
+    accept: function (visitor) {
+        this.value = visitor.visit(this.value);
+    },
+    toCSS: function (env) {
+        return '-' + this.value.toCSS(env);
+    },
+    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,31 +1,46 @@
 (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),
+            temp;
 
-    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) {
+                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" };
+                }
+            }
+            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);
         }
+    },
+    toCSS: function (env) {
+        var separator = this.isSpaced ? " " : "";
+        return this.operands[0].toCSS() + separator + this.op + separator + this.operands[1].toCSS();
     }
-    if (!a.operate) {
-        throw { name: "OperationError",
-                message: "Operation on an invalid type" };
-    }
-
-    return a.operate(this.op, b);
 };
 
-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,8 +5,12 @@ tree.Paren = function (node) {
     this.value = node;
 };
 tree.Paren.prototype = {
+    type: "Paren",
+    accept: function (visitor) {
+        this.value = visitor.visit(this.value);
+    },
     toCSS: function (env) {
-        return '(' + this.value.toCSS(env) + ')';
+        return '(' + this.value.toCSS(env).trim() + ')';
     },
     eval: function (env) {
         return new(tree.Paren)(this.value.eval(env));

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

@@ -1,12 +1,14 @@
 (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 = {
+    type: "Quoted",
     toCSS: function () {
         if (this.escaped) {
             return this.value;
@@ -19,7 +21,7 @@ tree.Quoted.prototype = {
         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);
+            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);

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

@@ -1,49 +1,62 @@
 (function (tree) {
 
-tree.Rule = function (name, value, important, index, inline) {
+tree.Rule = function (name, value, important, index, currentFileInfo, inline) {
     this.name = name;
     this.value = (value instanceof tree.Value) ? value : new(tree.Value)([value]);
     this.important = important ? ' ' + important.trim() : '';
     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 ? "" : ";");
-    }
-};
-
-tree.Rule.prototype.eval = function (context) {
-    return new(tree.Rule)(this.name,
-                          this.value.eval(context),
-                          this.important,
-                          this.index, this.inline);
-};
-
-tree.Rule.prototype.makeImportant = function () {
-    return new(tree.Rule)(this.name,
-                          this.value,
-                          "!important",
-                          this.index, this.inline);
-};
 
-tree.Shorthand = function (a, b) {
-    this.a = a;
-    this.b = b;
-};
-
-tree.Shorthand.prototype = {
+tree.Rule.prototype = {
+    type: "Rule",
+    accept: function (visitor) {
+        this.value = visitor.visit(this.value);
+    },
     toCSS: function (env) {
-        return this.a.toCSS(env) + "/" + this.b.toCSS(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;
+            }
+        }
     },
-    eval: function () { return this }
+    eval: function (env) {
+        var strictMathBypass = false;
+        if (this.name === "font" && !env.strictMath) {
+            strictMathBypass = true;
+            env.strictMath = true;
+        }
+        try {
+            return new(tree.Rule)(this.name,
+                              this.value.eval(env),
+                              this.important,
+                              this.index, this.currentFileInfo, this.inline);
+        }
+        finally {
+            if (strictMathBypass) {
+                env.strictMath = false;
+            }
+        }
+    },
+    makeImportant: function () {
+        return new(tree.Rule)(this.name,
+                              this.value,
+                              "!important",
+                              this.index, this.currentFileInfo, this.inline);
+    }
 };
 
 })(require('../tree'));

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

@@ -7,6 +7,11 @@ tree.Ruleset = function (selectors, rules, strictImports) {
     this.strictImports = strictImports;
 };
 tree.Ruleset.prototype = {
+    type: "Ruleset",
+    accept: function (visitor) {
+        this.selectors = visitor.visit(this.selectors);
+        this.rules = visitor.visit(this.rules);
+    },
     eval: function (env) {
         var selectors = this.selectors && this.selectors.map(function (s) { return s.eval(env) });
         var ruleset = new(tree.Ruleset)(selectors, this.rules.slice(0), this.strictImports);
@@ -14,6 +19,7 @@ tree.Ruleset.prototype = {
         
         ruleset.originalRuleset = this;
         ruleset.root = this.root;
+        ruleset.firstRoot = this.firstRoot;
         ruleset.allowImports = this.allowImports;
 
         if(this.debugInfo) {
@@ -23,6 +29,12 @@ tree.Ruleset.prototype = {
         // push the current ruleset to the frames stack
         env.frames.unshift(ruleset);
 
+        // currrent selectors
+        if (!env.selectors) {
+            env.selectors = [];
+        }
+        env.selectors.unshift(this.selectors);
+
         // Evaluate imports
         if (ruleset.root || ruleset.allowImports || !ruleset.strictImports) {
             ruleset.evalImports(env);
@@ -41,13 +53,21 @@ tree.Ruleset.prototype = {
         // Evaluate mixin calls.
         for (var i = 0; i < ruleset.rules.length; i++) {
             if (ruleset.rules[i] instanceof tree.mixin.Call) {
-                rules = ruleset.rules[i].eval(env);
+                rules = ruleset.rules[i].eval(env).filter(function(r) {
+                    if ((r instanceof tree.Rule) && r.variable) {
+                        // do not pollute the scope if the variable is
+                        // already there. consider returning false here
+                        // but we need a way to "return" variable from mixins
+                        return !(ruleset.variable(r.name));
+                    }
+                    return true;
+                });
                 ruleset.rules.splice.apply(ruleset.rules, [i, 1].concat(rules));
                 i += rules.length-1;
                 ruleset.resetCache();
             }
         }
-
+        
         // Evaluate everything else
         for (var i = 0, rule; i < ruleset.rules.length; i++) {
             rule = ruleset.rules[i];
@@ -59,6 +79,7 @@ tree.Ruleset.prototype = {
 
         // Pop the stack
         env.frames.shift();
+        env.selectors.shift();
         
         if (env.mediaBlocks) {
             for(var i = mediaBlockCount; i < env.mediaBlocks.length; i++) {
@@ -115,12 +136,9 @@ tree.Ruleset.prototype = {
         return this.variables()[name];
     },
     rulesets: function () {
-        if (this._rulesets) { return this._rulesets }
-        else {
-            return this._rulesets = this.rules.filter(function (r) {
-                return (r instanceof tree.Ruleset) || (r instanceof tree.mixin.Definition);
-            });
-        }
+        return this.rules.filter(function (r) {
+            return (r instanceof tree.Ruleset) || (r instanceof tree.mixin.Definition);
+        });
     },
     find: function (selector, self) {
         self = self || this;
@@ -151,28 +169,23 @@ tree.Ruleset.prototype = {
     //
     //     `context` holds an array of arrays.
     //
-    toCSS: function (context, env) {
+    toCSS: function (env) {
         var css = [],      // The CSS output
             rules = [],    // node.Rule instances
            _rules = [],    //
             rulesets = [], // node.Ruleset instances
-            paths = [],    // Current selectors
             selector,      // The fully rendered selector
             debugInfo,     // Line number debugging
             rule;
 
-        if (! this.root) {
-            this.joinSelectors(paths, context, this.selectors);
-        }
-
         // Compile rules and rulesets
         for (var i = 0; i < this.rules.length; i++) {
             rule = this.rules[i];
 
             if (rule.rules || (rule instanceof tree.Media)) {
-                rulesets.push(rule.toCSS(paths, env));
+                rulesets.push(rule.toCSS(env));
             } else if (rule instanceof tree.Directive) {
-                var cssValue = rule.toCSS(paths, env);
+                var cssValue = rule.toCSS(env);
                 // Output only the first @charset definition as such - convert the others
                 // to comments in case debug is enabled
                 if (rule.name === "@charset") {
@@ -199,6 +212,10 @@ tree.Ruleset.prototype = {
                 }
             } else {
                 if (rule.toCSS && !rule.variable) {
+                    if (this.firstRoot && rule instanceof tree.Rule) {
+                        throw { message: "properties must be inside selector blocks, they cannot be in the root.",
+                            index: rule.index, filename: rule.currentFileInfo ? rule.currentFileInfo.filename : null};
+                    }
                     rules.push(rule.toCSS(env));
                 } else if (rule.value && !rule.variable) {
                     rules.push(rule.value.toString());
@@ -206,6 +223,14 @@ tree.Ruleset.prototype = {
             }
         } 
 
+        // Remove last semicolon
+        if (env.compress && rules.length) {
+            rule = rules[rules.length - 1];
+            if (rule.charAt(rule.length - 1) === ';') {
+                rules[rules.length - 1] = rule.substring(0, rule.length - 1);
+            }
+        }
+
         rulesets = rulesets.join('');
 
         // If this is the root node, we don't render
@@ -216,7 +241,7 @@ tree.Ruleset.prototype = {
         } else {
             if (rules.length > 0) {
                 debugInfo = tree.debugInfo(env, this);
-                selector = paths.map(function (p) {
+                selector = this.paths.map(function (p) {
                     return p.map(function (s) {
                         return s.toCSS(env);
                     }).join('').trim();
@@ -224,7 +249,7 @@ tree.Ruleset.prototype = {
 
                 // Remove duplicates
                 for (var i = rules.length - 1; i >= 0; i--) {
-                    if (_rules.indexOf(rules[i]) === -1) {
+                    if (rules[i].slice(0, 2) === "/*" ||  _rules.indexOf(rules[i]) === -1) {
                         _rules.unshift(rules[i]);
                     }
                 }
@@ -339,11 +364,11 @@ tree.Ruleset.prototype = {
                             if (sel.length > 0) {
                                 newSelectorPath = sel.slice(0);
                                 lastSelector = newSelectorPath.pop();
-                                newJoinedSelector = new(tree.Selector)(lastSelector.elements.slice(0));
+                                newJoinedSelector = new(tree.Selector)(lastSelector.elements.slice(0), selector.extendList);
                                 newJoinedSelectorEmpty = false;
                             }
                             else {
-                                newJoinedSelector = new(tree.Selector)([]);
+                                newJoinedSelector = new(tree.Selector)([], selector.extendList);
                             }
 
                             //put together the parent selectors after the join
@@ -386,12 +411,14 @@ tree.Ruleset.prototype = {
         }
 
         for(i = 0; i < newSelectors.length; i++) {
-            paths.push(newSelectors[i]);
+            if (newSelectors[i].length > 0) {
+                paths.push(newSelectors[i]);
+            }
         }
     },
     
     mergeElementsOnToSelectors: function(elements, selectors) {
-        var i, sel;
+        var i, sel, extendList;
 
         if (selectors.length == 0) {
             selectors.push([ new(tree.Selector)(elements) ]);
@@ -403,7 +430,7 @@ tree.Ruleset.prototype = {
 
             // if the previous thing in sel is a parent this needs to join on to it
             if (sel.length > 0) {
-                sel[sel.length - 1] = new(tree.Selector)(sel[sel.length - 1].elements.concat(elements));
+                sel[sel.length - 1] = new(tree.Selector)(sel[sel.length - 1].elements.concat(elements), sel[sel.length - 1].extendList);
             }
             else {
                 sel.push(new(tree.Selector)(elements));

data/lib/less/js/lib/less/tree/selector.js

@@ -1,52 +1,62 @@
 (function (tree) {
 
-tree.Selector = function (elements) {
+tree.Selector = function (elements, extendList) {
     this.elements = elements;
+    this.extendList = extendList || [];
 };
-tree.Selector.prototype.match = function (other) {
-    var elements = this.elements,
-        len = elements.length,
-        oelements, olen, max, i;
+tree.Selector.prototype = {
+    type: "Selector",
+    accept: function (visitor) {
+        this.elements = visitor.visit(this.elements);
+        this.extendList = visitor.visit(this.extendList)
+    },
+    match: function (other) {
+        var elements = this.elements,
+            len = elements.length,
+            oelements, olen, max, i;
 
-    oelements = other.elements.slice(
-        (other.elements.length && other.elements[0].value === "&") ? 1 : 0);
-    olen = oelements.length;
-    max = Math.min(len, olen)
+        oelements = other.elements.slice(
+            (other.elements.length && other.elements[0].value === "&") ? 1 : 0);
+        olen = oelements.length;
+        max = Math.min(len, olen);
 
-    if (olen === 0 || len < olen) {
-        return false;
-    } else {
-        for (i = 0; i < max; i++) {
-            if (elements[i].value !== oelements[i].value) {
-                return false;
+        if (olen === 0 || len < olen) {
+            return false;
+        } else {
+            for (i = 0; i < max; i++) {
+                if (elements[i].value !== oelements[i].value) {
+                    return false;
+                }
             }
         }
-    }
-    return true;
-};
-tree.Selector.prototype.eval = function (env) {
-    return new(tree.Selector)(this.elements.map(function (e) {
-        return e.eval(env);
-    }));
-};
-tree.Selector.prototype.toCSS = function (env) {
-    if (this._css) { return this._css }
-    
-    if (this.elements[0].combinator.value === "") {
-        this._css = ' ';
-    } else {
-        this._css = '';
-    }
-    
-    this._css += this.elements.map(function (e) {
-        if (typeof(e) === 'string') {
-            return ' ' + e.trim();
+        return true;
+    },
+    eval: function (env) {
+        return new(tree.Selector)(this.elements.map(function (e) {
+            return e.eval(env);
+        }), this.extendList.map(function(extend) {
+            return extend.eval(env);
+        }));
+    },
+    toCSS: function (env) {
+        if (this._css) { return this._css }
+
+        if (this.elements[0].combinator.value === "") {
+            this._css = ' ';
         } else {
-            return e.toCSS(env);
+            this._css = '';
         }
-    }).join('');
-    
-    return this._css;
+
+        this._css += this.elements.map(function (e) {
+            if (typeof(e) === 'string') {
+                return ' ' + e.trim();
+            } else {
+                return e.toCSS(env);
+            }
+        }).join('');
+
+        return this._css;
+    }
 };
 
 })(require('../tree'));