less 3.0.0-pre.2 → 3.0.1

package/lib/less/tree/quoted.js

@@ -1,6 +1,6 @@
 var Node = require("./node"),
-    JsEvalNode = require("./js-eval-node"),
-    Variable = require("./variable");
+    Variable = require("./variable"),
+    Property = require("./property");
 
 var Quoted = function (str, content, escaped, index, currentFileInfo) {
     this.escaped = (escaped == null) ? true : escaped;
@@ -9,7 +9,7 @@ var Quoted = function (str, content, escaped, index, currentFileInfo) {
     this._index = index;
     this._fileInfo = currentFileInfo;
 };
-Quoted.prototype = new JsEvalNode();
+Quoted.prototype = new Node();
 Quoted.prototype.type = "Quoted";
 Quoted.prototype.genCSS = function (context, output) {
     if (!this.escaped) {
@@ -21,17 +21,18 @@ Quoted.prototype.genCSS = function (context, output) {
     }
 };
 Quoted.prototype.containsVariables = function() {
-    return this.value.match(/(`([^`]+)`)|@\{([\w-]+)\}/);
+    return this.value.match(/@\{([\w-]+)\}/);
 };
 Quoted.prototype.eval = function (context) {
     var that = this, value = this.value;
-    var javascriptReplacement = function (_, exp) {
-        return String(that.evaluateJavaScript(exp, context));
-    };
-    var interpolationReplacement = function (_, name) {
+    var variableReplacement = function (_, name) {
         var v = new Variable('@' + name, that.getIndex(), that.fileInfo()).eval(context, true);
         return (v instanceof Quoted) ? v.value : v.toCSS();
     };
+    var propertyReplacement = function (_, name) {
+        var v = new Property('$' + name, that.getIndex(), that.fileInfo()).eval(context, true);
+        return (v instanceof Quoted) ? v.value : v.toCSS();
+    };
     function iterativeReplace(value, regexp, replacementFnc) {
         var evaluatedValue = value;
         do {
@@ -40,8 +41,8 @@ Quoted.prototype.eval = function (context) {
         } while (value !== evaluatedValue);
         return evaluatedValue;
     }
-    value = iterativeReplace(value, /`([^`]+)`/g, javascriptReplacement);
-    value = iterativeReplace(value, /@\{([\w-]+)\}/g, interpolationReplacement);
+    value = iterativeReplace(value, /@\{([\w-]+)\}/g, variableReplacement);
+    value = iterativeReplace(value, /\$\{([\w-]+)\}/g, propertyReplacement);
     return new Quoted(this.quote + value + this.quote, value, this.escaped, this.getIndex(), this.fileInfo());
 };
 Quoted.prototype.compare = function (other) {

package/lib/less/tree/ruleset.js

@@ -1,8 +1,11 @@
 var Node = require("./node"),
     Declaration = require("./declaration"),
+    Keyword = require("./keyword"),
+    Comment = require("./comment"),
+    Paren = require("./paren"),
     Selector = require("./selector"),
     Element = require("./element"),
-    Paren = require("./paren"),
+    Anonymous = require("./anonymous"),
     contexts = require("../contexts"),
     globalFunctionRegistry = require("../functions/function-registry"),
     defaultFunc = require("../functions/default"),
@@ -13,9 +16,12 @@ var Ruleset = function (selectors, rules, strictImports, visibilityInfo) {
     this.selectors = selectors;
     this.rules = rules;
     this._lookups = {};
+    this._variables = null;
+    this._properties = null;
     this.strictImports = strictImports;
     this.copyVisibilityInfo(visibilityInfo);
     this.allowRoot = true;
+
     this.setParent(this.selectors, this);
     this.setParent(this.rules, this);
 
@@ -23,7 +29,7 @@ var Ruleset = function (selectors, rules, strictImports, visibilityInfo) {
 Ruleset.prototype = new Node();
 Ruleset.prototype.type = "Ruleset";
 Ruleset.prototype.isRuleset = true;
-Ruleset.prototype.isRulesetLike = true;
+Ruleset.prototype.isRulesetLike = function() { return true; };
 Ruleset.prototype.accept = function (visitor) {
     if (this.paths) {
         this.paths = visitor.visitArray(this.paths, true);
@@ -104,20 +110,20 @@ Ruleset.prototype.eval = function (context) {
 
     // Store the frames around mixin definitions,
     // 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].evalFirst) {
-            rsRules[i] = rsRules[i].eval(context);
+    var rsRules = ruleset.rules;
+    for (i = 0; (rule = rsRules[i]); i++) {
+        if (rule.evalFirst) {
+            rsRules[i] = rule.eval(context);
         }
     }
 
     var mediaBlockCount = (context.mediaBlocks && context.mediaBlocks.length) || 0;
 
     // Evaluate mixin calls.
-    for (i = 0; i < rsRuleCnt; i++) {
-        if (rsRules[i].type === "MixinCall") {
-            /*jshint loopfunc:true */
-            rules = rsRules[i].eval(context).filter(function(r) {
+    for (i = 0; (rule = rsRules[i]); i++) {
+        if (rule.type === "MixinCall") {
+            /* jshint loopfunc:true */
+            rules = rule.eval(context).filter(function(r) {
                 if ((r instanceof Declaration) && r.variable) {
                     // do not pollute the scope if the variable is
                     // already there. consider returning false here
@@ -127,12 +133,11 @@ Ruleset.prototype.eval = function (context) {
                 return true;
             });
             rsRules.splice.apply(rsRules, [i, 1].concat(rules));
-            rsRuleCnt += rules.length - 1;
             i += rules.length - 1;
             ruleset.resetCache();
-        } else if (rsRules[i].type === "RulesetCall") {
-            /*jshint loopfunc:true */
-            rules = rsRules[i].eval(context).rules.filter(function(r) {
+        } else if (rule.type ===  "VariableCall") {
+            /* jshint loopfunc:true */
+            rules = rule.eval(context).rules.filter(function(r) {
                 if ((r instanceof Declaration) && r.variable) {
                     // do not pollute the scope at all
                     return false;
@@ -140,31 +145,27 @@ Ruleset.prototype.eval = function (context) {
                 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];
+    for (i = 0; (rule = rsRules[i]); i++) {
         if (!rule.evalFirst) {
             rsRules[i] = rule = rule.eval ? rule.eval(context) : rule;
         }
     }
 
     // Evaluate everything else
-    for (i = 0; i < rsRules.length; i++) {
-        rule = rsRules[i];
+    for (i = 0; (rule = rsRules[i]); i++) {
         // for rulesets, check if it is a css guard and can be removed
         if (rule instanceof 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];
+                for (var j = 0; (subRule = rule.rules[j]); j++) {
                     if (subRule instanceof Node) {
                         subRule.copyVisibilityInfo(rule.visibilityInfo());
                         if (!(subRule instanceof Declaration) || !subRule.variable) {
@@ -197,7 +198,7 @@ Ruleset.prototype.evalImports = function(context) {
             importRules = rules[i].eval(context);
             if (importRules && (importRules.length || importRules.length === 0)) {
                 rules.splice.apply(rules, [i, 1].concat(importRules));
-                i+= importRules.length - 1;
+                i += importRules.length - 1;
             } else {
                 rules.splice(i, 1, importRules);
             }
@@ -236,6 +237,7 @@ Ruleset.prototype.matchCondition = function (args, context) {
 Ruleset.prototype.resetCache = function () {
     this._rulesets = null;
     this._variables = null;
+    this._properties = null;
     this._lookups = {};
 };
 Ruleset.prototype.variables = function () {
@@ -260,17 +262,81 @@ Ruleset.prototype.variables = function () {
     }
     return this._variables;
 };
+Ruleset.prototype.properties = function () {
+    if (!this._properties) {
+        this._properties = !this.rules ? {} : this.rules.reduce(function (hash, r) {
+            if (r instanceof Declaration && r.variable !== true) {
+                var name = (r.name.length === 1) && (r.name[0] instanceof Keyword) ?
+                    r.name[0].value : r.name;
+                // Properties don't overwrite as they can merge
+                if (!hash['$' + name]) {
+                    hash['$' + name] = [ r ];
+                }
+                else {
+                    hash['$' + name].push(r);
+                }
+            }
+            return hash;
+        }, {});
+    }
+    return this._properties;
+};
 Ruleset.prototype.variable = function (name) {
-    return this.variables()[name];
+    var decl = this.variables()[name];
+    if (decl) {
+        return this.parseValue(decl);
+    }
+};
+Ruleset.prototype.property = function (name) {
+    var decl = this.properties()[name];
+    if (decl) {
+        return this.parseValue(decl);
+    }
+};
+Ruleset.prototype.parseValue = function(toParse) {
+    var self = this;
+    function transformDeclaration(decl) {
+        if (decl.value instanceof Anonymous && !decl.parsed) {
+            this.parse.parseNode(
+                decl.value.value, 
+                ["value", "important"], 
+                decl.value.getIndex(), 
+                decl.fileInfo(), 
+                function(err, result) {
+                    if (err) {
+                        decl.parsed = true;
+                    }
+                    if (result) {
+                        decl.value = result[0];
+                        decl.important = result[1] || '';
+                        decl.parsed = true;
+                    }
+                });
+
+            return decl;
+        }
+        else {
+            return decl;
+        }
+    }
+    if (!Array.isArray(toParse)) {
+        return transformDeclaration.call(self, toParse);
+    }
+    else {
+        var nodes = [];
+        toParse.forEach(function(n) {
+            nodes.push(transformDeclaration.call(self, n));
+        });
+        return nodes;
+    }
 };
 Ruleset.prototype.rulesets = function () {
     if (!this.rules) { return []; }
 
-    var filtRules = [], rules = this.rules, cnt = rules.length,
+    var filtRules = [], rules = this.rules,
         i, rule;
 
-    for (i = 0; i < cnt; i++) {
-        rule = rules[i];
+    for (i = 0; (rule = rules[i]); i++) {
         if (rule.isRuleset) {
             filtRules.push(rule);
         }
@@ -336,41 +402,23 @@ Ruleset.prototype.genCSS = function (context, output) {
         tabSetStr = context.compress ? '' : Array(context.tabLevel).join("  "),
         sep;
 
-    function isRulesetLikeNode(rule) {
-        // if it has nested rules, then it should be treated like a ruleset
-        // medias and comments do not have nested rules, but should be treated like rulesets anyway
-        // some atrules and anonymous nodes are ruleset like, others are not
-        if (typeof rule.isRulesetLike === "boolean") {
-            return rule.isRulesetLike;
-        } else if (typeof rule.isRulesetLike === "function") {
-            return rule.isRulesetLike();
-        }
-
-        //anything else is assumed to be a rule
-        return false;
-    }
-
     var charsetNodeIndex = 0;
     var importNodeIndex = 0;
-    for (i = 0; i < this.rules.length; i++) {
-        rule = this.rules[i];
-        // Plugins may return something other than Nodes
-        if (rule instanceof Node) {
-            if (rule.type === "Comment") {
-                if (importNodeIndex === i) {
-                    importNodeIndex++;
-                }
-                ruleNodes.push(rule);
-            } else if (rule.isCharset && rule.isCharset()) {
-                ruleNodes.splice(charsetNodeIndex, 0, rule);
-                charsetNodeIndex++;
+    for (i = 0; (rule = this.rules[i]); i++) {
+        if (rule instanceof Comment) {
+            if (importNodeIndex === i) {
                 importNodeIndex++;
-            } else if (rule.type === "Import") {
-                ruleNodes.splice(importNodeIndex, 0, rule);
-                importNodeIndex++;
-            } else {
-                ruleNodes.push(rule);
             }
+            ruleNodes.push(rule);
+        } else if (rule.isCharset && rule.isCharset()) {
+            ruleNodes.splice(charsetNodeIndex, 0, rule);
+            charsetNodeIndex++;
+            importNodeIndex++;
+        } else if (rule.type === "Import") {
+            ruleNodes.splice(importNodeIndex, 0, rule);
+            importNodeIndex++;
+        } else {
+            ruleNodes.push(rule);
         }
     }
     ruleNodes = charsetRuleNodes.concat(ruleNodes);
@@ -408,15 +456,14 @@ Ruleset.prototype.genCSS = function (context, output) {
     }
 
     // Compile rules and rulesets
-    for (i = 0; i < ruleNodes.length; i++) {
-        rule = ruleNodes[i];
+    for (i = 0; (rule = ruleNodes[i]); i++) {
 
         if (i + 1 === ruleNodes.length) {
             context.lastRule = true;
         }
 
         var currentLastRule = context.lastRule;
-        if (isRulesetLikeNode(rule)) {
+        if (rule.isRulesetLike(rule)) {
             context.lastRule = false;
         }
 
@@ -428,7 +475,7 @@ Ruleset.prototype.genCSS = function (context, output) {
 
         context.lastRule = currentLastRule;
 
-        if (!context.lastRule) {
+        if (!context.lastRule && rule.isVisible()) {
             output.add(context.compress ? '' : ('\n' + tabRuleStr));
         } else {
             context.lastRule = false;
@@ -482,7 +529,7 @@ Ruleset.prototype.joinSelector = function (paths, context, selector) {
         // our new selector path
         newSelectorPath = [];
 
-        //construct the joined selector - if & is the first thing this will be empty,
+        // construct the joined selector - if & is the first thing this will be empty,
         // if not newJoinedSelector will be the last set of elements in the selector
         if (beginningPath.length > 0) {
             newSelectorPath = utils.copyArray(beginningPath);
@@ -512,7 +559,7 @@ Ruleset.prototype.joinSelector = function (paths, context, selector) {
             newSelectorPath.push(newJoinedSelector);
         }
 
-        //put together the parent selectors after the join (e.g. the rest of the parent)
+        // put together the parent selectors after the join (e.g. the rest of the parent)
         if (addPath.length > 1) {
             var restOfPath = addPath.slice(1);
             restOfPath = restOfPath.map(function (selector) {
@@ -546,9 +593,7 @@ Ruleset.prototype.joinSelector = function (paths, context, selector) {
             return;
         }
 
-        for (i = 0; i < selectors.length; i++) {
-            sel = selectors[i];
-
+        for (i = 0; (sel = selectors[i]); i++) {
             // if the previous thing in sel is a parent this needs to join on to it
             if (sel.length > 0) {
                 sel[sel.length - 1] = sel[sel.length - 1].createDerived(sel[sel.length - 1].elements.concat(elements));
@@ -576,12 +621,12 @@ Ruleset.prototype.joinSelector = function (paths, context, selector) {
         var i, j, k, currentElements, newSelectors, selectorsMultiplied, sel, el, hadParentSelector = false, length, lastSelector;
         function findNestedSelector(element) {
             var maybeSelector;
-            if (element.value.type !== 'Paren') {
+            if (!(element.value instanceof Paren)) {
                 return null;
             }
 
             maybeSelector = element.value.value;
-            if (maybeSelector.type !== 'Selector') {
+            if (!(maybeSelector instanceof Selector)) {
                 return null;
             }
 
@@ -597,8 +642,7 @@ Ruleset.prototype.joinSelector = function (paths, context, selector) {
             []
         ];
 
-        for (i = 0; i < inSelector.elements.length; i++) {
-            el = inSelector.elements[i];
+        for (i = 0; (el = inSelector.elements[i]); i++) {
             // non parent reference elements just get added
             if (el.value !== "&") {
                 var nestedSelector = findNestedSelector(el);
@@ -610,7 +654,7 @@ Ruleset.prototype.joinSelector = function (paths, context, selector) {
                     var nestedPaths = [], replaced, replacedNewSelectors = [];
                     replaced = replaceParentSelector(nestedPaths, context, nestedSelector);
                     hadParentSelector = hadParentSelector || replaced;
-                    //the nestedPaths array should have only one member - replaceParentSelector does not multiply selectors
+                    // the nestedPaths array should have only one member - replaceParentSelector does not multiply selectors
                     for (k = 0; k < nestedPaths.length; k++) {
                         var replacementSelector = createSelector(createParenthesis(nestedPaths[k], el), el);
                         addAllReplacementsIntoPath(newSelectors, [replacementSelector], el, inSelector, replacedNewSelectors);

package/lib/less/tree/selector.js

@@ -1,15 +1,15 @@
 var Node = require("./node"),
-    Element = require("./element");
+    Element = require("./element"),
+    LessError = require("../less-error");
 
 var Selector = function (elements, extendList, condition, index, currentFileInfo, visibilityInfo) {
-    this.elements = elements;
     this.extendList = extendList;
     this.condition = condition;
+    this.evaldCondition = !condition;
     this._index = index;
     this._fileInfo = currentFileInfo;
-    if (!condition) {
-        this.evaldCondition = true;
-    }
+    this.elements = this.getElements(elements);
+    this.mixinElements_ = undefined;
     this.copyVisibilityInfo(visibilityInfo);
     this.setParent(this.elements, this);
 };
@@ -27,13 +27,32 @@ Selector.prototype.accept = function (visitor) {
     }
 };
 Selector.prototype.createDerived = function(elements, extendList, evaldCondition) {
-    var info = this.visibilityInfo();
-    evaldCondition = (evaldCondition != null) ? evaldCondition : this.evaldCondition;
-    var newSelector = new Selector(elements, extendList || this.extendList, null, this.getIndex(), this.fileInfo(), info);
-    newSelector.evaldCondition = evaldCondition;
+    elements = this.getElements(elements);
+    var newSelector = new Selector(elements, extendList || this.extendList,
+        null, this.getIndex(), this.fileInfo(), this.visibilityInfo());
+    newSelector.evaldCondition = (evaldCondition != null) ? evaldCondition : this.evaldCondition;
     newSelector.mediaEmpty = this.mediaEmpty;
     return newSelector;
 };
+Selector.prototype.getElements = function(els) {
+    if (typeof els === "string") {
+        this.parse.parseNode(
+            els, 
+            ["selector"],
+            this._index, 
+            this._fileInfo, 
+            function(err, result) {
+                if (err) {
+                    throw new LessError({
+                        index: err.index,
+                        message: err.message
+                    }, this.parse.imports, this._fileInfo.filename);
+                }
+                els = result[0].elements;
+            });
+    }
+    return els;
+};
 Selector.prototype.createEmptySelectors = function() {
     var el = new Element('', '&', this._index, this._fileInfo),
         sels = [new Selector([el], null, null, this._index, this._fileInfo)];
@@ -45,14 +64,13 @@ Selector.prototype.match = function (other) {
         len = elements.length,
         olen, i;
 
-    other.CacheElements();
-
-    olen = other._elements.length;
+    other = other.mixinElements();
+    olen = other.length;
     if (olen === 0 || len < olen) {
         return 0;
     } else {
         for (i = 0; i < olen; i++) {
-            if (elements[i].value !== other._elements[i]) {
+            if (elements[i].value !== other[i]) {
                 return 0;
             }
         }
@@ -60,9 +78,9 @@ Selector.prototype.match = function (other) {
 
     return olen; // return number of matched elements
 };
-Selector.prototype.CacheElements = function() {
-    if (this._elements) {
-        return;
+Selector.prototype.mixinElements = function() {
+    if (this.mixinElements_) {
+        return this.mixinElements_;
     }
 
     var elements = this.elements.map( function(v) {
@@ -77,7 +95,7 @@ Selector.prototype.CacheElements = function() {
         elements = [];
     }
 
-    this._elements = elements;
+    return (this.mixinElements_ = elements);
 };
 Selector.prototype.isJustParentSelector = function() {
     return !this.mediaEmpty &&
@@ -99,12 +117,9 @@ Selector.prototype.genCSS = function (context, output) {
     if ((!context || !context.firstSelector) && this.elements[0].combinator.value === "") {
         output.add(' ', this.fileInfo(), this.getIndex());
     }
-    if (!this._css) {
-        //TODO caching? speed comparison?
-        for (i = 0; i < this.elements.length; i++) {
-            element = this.elements[i];
-            element.genCSS(context, output);
-        }
+    for (i = 0; i < this.elements.length; i++) {
+        element = this.elements[i];
+        element.genCSS(context, output);
     }
 };
 Selector.prototype.getIsOutput = function() {

package/lib/less/tree/unit.js

@@ -65,7 +65,7 @@ Unit.prototype.usedUnits = function() {
     var group, result = {}, mapUnit, groupName;
 
     mapUnit = function (atomicUnit) {
-        /*jshint loopfunc:true */
+        /* jshint loopfunc:true */
         if (group.hasOwnProperty(atomicUnit) && !result[groupName]) {
             result[groupName] = atomicUnit;
         }

package/lib/less/tree/value.js

@@ -1,10 +1,15 @@
 var Node = require("./node");
 
 var Value = function (value) {
-    this.value = value;
     if (!value) {
         throw new Error("Value requires an array argument");
     }
+    if (!Array.isArray(value)) {
+        this.value = [ value ];
+    }
+    else {
+        this.value = value;
+    }
 };
 Value.prototype = new Node();
 Value.prototype.type = "Value";

package/lib/less/tree/{ruleset-call.js → variable-call.js}

@@ -1,14 +1,14 @@
 var Node = require("./node"),
     Variable = require("./variable");
 
-var RulesetCall = function (variable) {
+var VariableCall = function (variable) {
     this.variable = variable;
     this.allowRoot = true;
 };
-RulesetCall.prototype = new Node();
-RulesetCall.prototype.type = "RulesetCall";
-RulesetCall.prototype.eval = function (context) {
+VariableCall.prototype = new Node();
+VariableCall.prototype.type = "VariableCall";
+VariableCall.prototype.eval = function (context) {
     var detachedRuleset = new Variable(this.variable).eval(context);
     return detachedRuleset.callEval(context);
 };
-module.exports = RulesetCall;
+module.exports = VariableCall;

package/lib/less/tree/variable.js

@@ -16,9 +16,9 @@ Variable.prototype.eval = function (context) {
 
     if (this.evaluating) {
         throw { type: 'Name',
-                message: "Recursive variable definition for " + name,
-                filename: this.fileInfo().filename,
-                index: this.getIndex() };
+            message: "Recursive variable definition for " + name,
+            filename: this.fileInfo().filename,
+            index: this.getIndex() };
     }
 
     this.evaluating = true;
@@ -38,9 +38,9 @@ Variable.prototype.eval = function (context) {
         return variable;
     } else {
         throw { type: 'Name',
-                message: "variable " + name + " is undefined",
-                filename: this.fileInfo().filename,
-                index: this.getIndex() };
+            message: "variable " + name + " is undefined",
+            filename: this.fileInfo().filename,
+            index: this.getIndex() };
     }
 };
 Variable.prototype.find = function (obj, fun) {

package/lib/less/utils.js

@@ -1,3 +1,4 @@
+/* jshint proto: true */
 module.exports = {
     getLocation: function(index, inputStream) {
         var n = index + 1,
@@ -25,5 +26,44 @@ module.exports = {
             copy[i] = arr[i];
         }
         return copy;
+    },
+    clone: function (obj) {
+        var cloned = {};
+        for (var prop in obj) {
+            if (obj.hasOwnProperty(prop)) {
+                cloned[prop] = obj[prop];
+            }
+        }
+        return cloned;
+    },
+    defaults: function(obj1, obj2) {
+        if (!obj2._defaults || obj2._defaults !== obj1) {
+            for (var prop in obj1) {
+                if (obj1.hasOwnProperty(prop)) {
+                    if (!obj2.hasOwnProperty(prop)) {
+                        obj2[prop] = obj1[prop];
+                    }
+                    else if (Array.isArray(obj1[prop])
+                        && Array.isArray(obj2[prop])) {
+
+                        obj1[prop].forEach(function(p) {
+                            if (obj2[prop].indexOf(p) === -1) {
+                                obj2[prop].push(p);
+                            }
+                        });
+                    }
+                }
+            }
+        }
+        obj2._defaults = obj1;
+        return obj2;
+    },
+    merge: function(obj1, obj2) {
+        for (var prop in obj2) {
+            if (obj2.hasOwnProperty(prop)) {
+                obj1[prop] = obj2[prop];
+            }
+        }
+        return obj1;
     }
 };