less 3.0.0-pre.2 → 3.0.1

package/lib/less/parser/parser.js

@@ -2,7 +2,8 @@ var LessError = require('../less-error'),
     tree = require("../tree"),
     visitors = require("../visitors"),
     getParserInput = require("./parser-input"),
-    utils = require("../utils");
+    utils = require("../utils"),
+    functionRegistry = require('../functions/function-registry');
 
 //
 // less.js - parser
@@ -35,8 +36,8 @@ var LessError = require('../less-error'),
 //    Token matching is done with the `$` function, which either takes
 //    a terminal string or regexp, or a non-terminal function to call.
 //    It also takes care of moving all the indices forwards.
-//`
 //
+
 var Parser = function Parser(context, imports, fileInfo) {
     var parsers,
         parserInput = getParserInput();
@@ -80,11 +81,61 @@ var Parser = function Parser(context, imports, fileInfo) {
         };
     }
 
+    /**
+     *  Used after initial parsing to create nodes on the fly
+     * 
+     *  @param {String} str          - string to parse 
+     *  @param {Array}  parseList    - array of parsers to run input through e.g. ["value", "important"]
+     *  @param {Number} currentIndex - start number to begin indexing
+     *  @param {Object} fileInfo     - fileInfo to attach to created nodes
+     */
+    function parseNode(str, parseList, currentIndex, fileInfo, callback) {
+        var result, returnNodes = [];
+        var parser = parserInput;
+
+        try {
+            parser.start(str, false, function fail(msg, index) {
+                callback({
+                    message: msg,
+                    index: index + currentIndex
+                });
+            });
+            for (var x = 0, p, i; (p = parseList[x]); x++) {
+                i = parser.i;
+                result = parsers[p]();
+                if (result) {
+                    result._index = i + currentIndex;
+                    result._fileInfo = fileInfo;
+                    returnNodes.push(result);
+                }
+                else {
+                    returnNodes.push(null);
+                }
+            }
+
+            var endInfo = parser.end();
+            if (endInfo.isFinished) {
+                callback(null, returnNodes);
+            }
+            else {
+                callback(true, null);
+            }
+        } catch (e) {
+            throw new LessError({
+                index: e.index + currentIndex,
+                message: e.message
+            }, imports, fileInfo.filename);
+        }
+    }
+    
     //
     // The Parser
     //
     return {
-
+        parserInput: parserInput,
+        imports: imports,
+        fileInfo: fileInfo,
+        parseNode: parseNode,
         //
         // Parse an input string into an abstract syntax tree,
         // @param str A string containing 'less' markup
@@ -130,9 +181,13 @@ var Parser = function Parser(context, imports, fileInfo) {
                     }, imports);
                 });
 
-                root = new(tree.Ruleset)(null, this.parsers.primary());
+                tree.Node.prototype.parse = this;
+                root = new tree.Ruleset(null, this.parsers.primary());
+                tree.Node.prototype.rootNode = root;
                 root.root = true;
                 root.firstRoot = true;
+                root.functionRegistry = functionRegistry.inherit();
+                
             } catch (e) {
                 return callback(new LessError(e, imports, fileInfo.filename));
             }
@@ -261,7 +316,7 @@ var Parser = function Parser(context, imports, fileInfo) {
                     }
 
                     node = mixin.definition() || this.declaration() || this.ruleset() ||
-                        mixin.call() || this.rulesetCall() || this.entities.call() || this.atrule();
+                        mixin.call() || this.variableCall() || this.entities.call() || this.atrule();
                     if (node) {
                         root.push(node);
                     } else {
@@ -319,7 +374,7 @@ var Parser = function Parser(context, imports, fileInfo) {
                 //     black border-collapse
                 //
                 keyword: function () {
-                    var k = parserInput.$char("%") || parserInput.$re(/^[_A-Za-z-][_A-Za-z0-9-]*/);
+                    var k = parserInput.$char("%") || parserInput.$re(/^\[?[_A-Za-z-][_A-Za-z0-9-]*\]?/);
                     if (k) {
                         return tree.Color.fromKeyword(k) || new(tree.Keyword)(k);
                     }
@@ -330,13 +385,10 @@ var Parser = function Parser(context, imports, fileInfo) {
                 //
                 //     rgb(255, 0, 255)
                 //
-                // We also try to catch IE's `alpha()`, but let the `alpha` parser
-                // deal with the details.
-                //
                 // The arguments are parsed with the `entities.arguments` parser.
                 //
                 call: function () {
-                    var name, nameLC, args, alpha, index = parserInput.i;
+                    var name, args, func, index = parserInput.i;
 
                     // http://jsperf.com/case-insensitive-regex-vs-strtolower-then-regex/18
                     if (parserInput.peek(/^url\(/i)) {
@@ -346,70 +398,98 @@ var Parser = function Parser(context, imports, fileInfo) {
                     parserInput.save();
 
                     name = parserInput.$re(/^([\w-]+|%|progid:[\w\.]+)\(/);
-                    if (!name) { parserInput.forget(); return; }
+                    if (!name) {
+                        parserInput.forget(); 
+                        return;
+                    }
 
                     name = name[1];
-                    nameLC = name.toLowerCase();
-
-                    if (nameLC === 'alpha') {
-                        alpha = parsers.alpha();
-                        if (alpha) {
+                    func = this.customFuncCall(name);
+                    if (func) {
+                        args = func.parse();
+                        if (args && func.stop) {
                             parserInput.forget();
-                            return alpha;
+                            return args;
                         }
                     }
 
-                    args = this.arguments();
+                    args = this.arguments(args);
 
-                    if (! parserInput.$char(')')) {
+                    if (!parserInput.$char(')')) {
                         parserInput.restore("Could not parse call arguments or missing ')'");
                         return;
                     }
 
                     parserInput.forget();
+                    
                     return new(tree.Call)(name, args, index, fileInfo);
                 },
-                arguments: function () {
-                    var argsSemiColon = [], argsComma = [],
-                        expressions = [],
-                        isSemiColonSeparated, value, arg;
-
-                    parserInput.save();
+                
+                //
+                // Parsing rules for functions with non-standard args, e.g.:
+                //
+                //     boolean(not(2 > 1))
+                //
+                //     This is a quick prototype, to be modified/improved when
+                //     more custom-parsed funcs come (e.g. `selector(...)`)
+                //
 
-                    while (true) {
+                customFuncCall: function (name) {
+                    /* Ideally the table is to be moved out of here for faster perf.,
+                       but it's quite tricky since it relies on all these `parsers`
+                       and `expect` available only here */
+                    return {
+                        alpha:   f(parsers.ieAlpha, true),
+                        boolean: f(condition),
+                        'if':    f(condition)
+                    }[name.toLowerCase()];
+
+                    function f(parse, stop) {
+                        return {
+                            parse: parse, // parsing function
+                            stop:  stop   // when true - stop after parse() and return its result, 
+                                          // otherwise continue for plain args
+                        };
+                    }
+                
+                    function condition() {
+                        return [expect(parsers.condition, 'expected condition')];
+                    }
+                },
 
-                        arg = parsers.detachedRuleset() || this.assignment() || parsers.expression();
+                arguments: function (prevArgs) {
+                    var argsComma = prevArgs || [],
+                        argsSemiColon = [],
+                        isSemiColonSeparated, value;
 
-                        if (!arg) {
-                            break;
-                        }
+                    parserInput.save();
 
-                        value = arg;
+                    while (true) {
+                        if (prevArgs) {
+                            prevArgs = false;
+                        } else {
+                            value = parsers.detachedRuleset() || this.assignment() || parsers.expression();
+                            if (!value) {
+                                break;
+                            }
 
-                        if (arg.value && arg.value.length == 1) {
-                            value = arg.value[0];
-                        }
+                            if (value.value && value.value.length == 1) {
+                                value = value.value[0];
+                            }
 
-                        if (value) {
-                            expressions.push(value);
+                            argsComma.push(value);
                         }
 
-                        argsComma.push(value);
-
                         if (parserInput.$char(',')) {
                             continue;
                         }
 
                         if (parserInput.$char(';') || isSemiColonSeparated) {
-
                             isSemiColonSeparated = true;
-
-                            if (expressions.length > 1) {
-                                value = new(tree.Value)(expressions);
-                            }
+                            value = (argsComma.length < 1) ? argsComma[0]
+                                : new tree.Value(argsComma);
                             argsSemiColon.push(value);
-
-                            expressions = [];
+                            argsComma = [];
                         }
                     }
 
@@ -467,15 +547,17 @@ var Parser = function Parser(context, imports, fileInfo) {
                         return;
                     }
 
-                    value = this.quoted() || this.variable() ||
+                    value = this.quoted() || this.variable() || this.property() ||
                             parserInput.$re(/^(?:(?:\\[\(\)'"])|[^\(\)'"])+/) || "";
 
                     parserInput.autoCommentAbsorb = true;
 
                     expectChar(')');
 
-                    return new(tree.URL)((value.value != null || value instanceof tree.Variable) ?
-                                        value : new(tree.Anonymous)(value), index, fileInfo);
+                    return new(tree.URL)((value.value != null || 
+                        value instanceof tree.Variable || 
+                        value instanceof tree.Property) ?
+                        value : new(tree.Anonymous)(value, index), index, fileInfo);
                 },
 
                 //
@@ -502,7 +584,27 @@ var Parser = function Parser(context, imports, fileInfo) {
                         return new(tree.Variable)("@" + curly[1], index, fileInfo);
                     }
                 },
+                //
+                // A Property accessor, such as `$color`, in
+                //
+                //     background-color: $color
+                //
+                property: function () {
+                    var name, index = parserInput.i;
+
+                    if (parserInput.currentChar() === '$' && (name = parserInput.$re(/^\$[\w-]+/))) {
+                        return new(tree.Property)(name, index, fileInfo);
+                    }
+                },
+
+                // A property entity useing the protective {} e.g. ${prop}
+                propertyCurly: function () {
+                    var curly, index = parserInput.i;
 
+                    if (parserInput.currentChar() === '$' && (curly = parserInput.$re(/^\$\{([\w-]+)\}/))) {
+                        return new(tree.Property)("$" + curly[1], index, fileInfo);
+                    }
+                },
                 //
                 // A Hexadecimal color
                 //
@@ -612,15 +714,17 @@ var Parser = function Parser(context, imports, fileInfo) {
             },
 
             //
-            // The variable part of a variable definition. Used in the `rule` parser
+            // Call a variable value
             //
-            //     @fink();
+            //     @fink()
             //
-            rulesetCall: function () {
+            variableCall: function () {
                 var name;
 
-                if (parserInput.currentChar() === '@' && (name = parserInput.$re(/^(@[\w-]+)\(\s*\)\s*;/))) {
-                    return new tree.RulesetCall(name[1]);
+                if (parserInput.currentChar() === '@'
+                    && (name = parserInput.$re(/^(@[\w-]+)\(\s*\)/))
+                    && parsers.end()) {
+                    return new tree.VariableCall(name[1]);
                 }
             },
 
@@ -637,7 +741,7 @@ var Parser = function Parser(context, imports, fileInfo) {
                 do {
                     option = null;
                     elements = null;
-                    while (! (option = parserInput.$re(/^(all)(?=\s*(\)|,))/))) {
+                    while (!(option = parserInput.$re(/^(all)(?=\s*(\)|,))/))) {
                         e = this.element();
                         if (!e) {
                             break;
@@ -756,7 +860,7 @@ var Parser = function Parser(context, imports, fileInfo) {
                                     .push({ variadic: true });
                                 break;
                             }
-                            arg = entities.variable() || entities.literal() || entities.keyword();
+                            arg = entities.variable() || entities.property() || entities.literal() || entities.keyword();
                         }
 
                         if (!arg) {
@@ -779,7 +883,7 @@ var Parser = function Parser(context, imports, fileInfo) {
                             val = arg;
                         }
 
-                        if (val && val instanceof tree.Variable) {
+                        if (val && (val instanceof tree.Variable || val instanceof tree.Property)) {
                             if (parserInput.$char(':')) {
                                 if (expressions.length > 0) {
                                     if (isSemiColonSeparated) {
@@ -925,7 +1029,7 @@ var Parser = function Parser(context, imports, fileInfo) {
                 var entities = this.entities;
 
                 return this.comment() || entities.literal() || entities.variable() || entities.url() ||
-                       entities.call()    || entities.keyword()  || entities.javascript();
+                       entities.property() || entities.call() || entities.keyword()  || entities.javascript();
             },
 
             //
@@ -942,17 +1046,18 @@ var Parser = function Parser(context, imports, fileInfo) {
             //
             //     alpha(opacity=88)
             //
-            alpha: function () {
+            ieAlpha: function () {
                 var value;
 
                 // http://jsperf.com/case-insensitive-regex-vs-strtolower-then-regex/18
-                if (! parserInput.$re(/^opacity=/i)) { return; }
+                if (!parserInput.$re(/^opacity=/i)) { return; }
                 value = parserInput.$re(/^\d+/);
                 if (!value) {
-                    value = expect(this.entities.variable, "Could not parse alpha");
+                    value = expect(parsers.entities.variable, "Could not parse alpha");
+                    value = '@{' + value.name.slice(1) + '}';
                 }
                 expectChar(')');
-                return new(tree.Alpha)(value);
+                return new tree.Quoted('', 'alpha(opacity=' + value + ')');
             },
 
             //
@@ -978,10 +1083,10 @@ var Parser = function Parser(context, imports, fileInfo) {
                     parserInput.$re(/^\([^&()@]+\)/) ||  parserInput.$re(/^[\.#:](?=@)/) ||
                     this.entities.variableCurly();
 
-                if (! e) {
+                if (!e) {
                     parserInput.save();
                     if (parserInput.$char('(')) {
-                        if ((v = this.selector()) && parserInput.$char(')')) {
+                        if ((v = this.selector(false)) && parserInput.$char(')')) {
                             e = new(tree.Paren)(v);
                             parserInput.forget();
                         } else {
@@ -1032,14 +1137,8 @@ var Parser = function Parser(context, imports, fileInfo) {
                 }
             },
             //
-            // A CSS selector (see selector below)
-            // with less extensions e.g. the ability to extend and guard
-            //
-            lessSelector: function () {
-                return this.selector(true);
-            },
-            //
             // A CSS Selector
+            // with less extensions e.g. the ability to extend and guard
             //
             //     .class > div + h1
             //     li a:hover
@@ -1048,7 +1147,7 @@ var Parser = function Parser(context, imports, fileInfo) {
             //
             selector: function (isLess) {
                 var index = parserInput.i, elements, extendList, c, e, allExtends, when, condition;
-
+                isLess = isLess !== false;
                 while ((isLess && (extendList = this.extend())) || (isLess && (when = parserInput.$str("when"))) || (e = this.element())) {
                     if (when) {
                         condition = expect(this.conditions, 'expected condition');
@@ -1079,7 +1178,7 @@ var Parser = function Parser(context, imports, fileInfo) {
                 if (allExtends) { error("Extend must be used to extend a selector, it cannot be used on its own"); }
             },
             attribute: function () {
-                if (! parserInput.$char('[')) { return; }
+                if (!parserInput.$char('[')) { return; }
 
                 var entities = this.entities,
                     key, val, op;
@@ -1138,7 +1237,7 @@ var Parser = function Parser(context, imports, fileInfo) {
                 }
 
                 while (true) {
-                    s = this.lessSelector();
+                    s = this.selector();
                     if (!s) {
                         break;
                     }
@@ -1151,7 +1250,7 @@ var Parser = function Parser(context, imports, fileInfo) {
                     if (s.condition && selectors.length > 1) {
                         error("Guards are only currently allowed on a single selector.");
                     }
-                    if (! parserInput.$char(',')) { break; }
+                    if (!parserInput.$char(',')) { break; }
                     if (s.condition) {
                         error("Guards are only currently allowed on a single selector.");
                     }
@@ -1169,7 +1268,7 @@ var Parser = function Parser(context, imports, fileInfo) {
                     parserInput.restore();
                 }
             },
-            declaration: function (tryAnonymous) {
+            declaration: function () {
                 var name, value, startOfRule = parserInput.i, c = parserInput.currentChar(), important, merge, isVariable;
 
                 if (c === '.' || c === '#' || c === '&' || c === ':') { return; }
@@ -1191,22 +1290,16 @@ var Parser = function Parser(context, imports, fileInfo) {
                         // where each item is a tree.Keyword or tree.Variable
                         merge = !isVariable && name.length > 1 && name.pop().value;
 
-                        // prefer to try to parse first if its a variable or we are compressing
-                        // but always fallback on the other one
-                        var tryValueFirst = !tryAnonymous && (context.compress || isVariable);
-
-                        if (tryValueFirst) {
-                            value = this.value();
+                        // Try to store values as anonymous
+                        // If we need the value later we'll re-parse it in ruleset.parseValue
+                        value = this.anonymousValue();
+                        if (value) {
+                            parserInput.forget();
+                            // anonymous values absorb the end ';' which is required for them to work
+                            return new (tree.Declaration)(name, value, false, merge, startOfRule, fileInfo);
                         }
+
                         if (!value) {
-                            value = this.anonymousValue();
-                            if (value) {
-                                parserInput.forget();
-                                // anonymous values absorb the end ';' which is required for them to work
-                                return new (tree.Declaration)(name, value, false, merge, startOfRule, fileInfo);
-                            }
-                        }
-                        if (!tryValueFirst && !value) {
                             value = this.value();
                         }
 
@@ -1216,20 +1309,19 @@ var Parser = function Parser(context, imports, fileInfo) {
                     if (value && this.end()) {
                         parserInput.forget();
                         return new (tree.Declaration)(name, value, important, merge, startOfRule, fileInfo);
-                    } else {
+                    }
+                    else {
                         parserInput.restore();
-                        if (value && !tryAnonymous) {
-                            return this.declaration(true);
-                        }
                     }
                 } else {
-                    parserInput.forget();
+                    parserInput.restore();
                 }
             },
             anonymousValue: function () {
-                var match = parserInput.$re(/^([^@+\/'"*`(;{}-]*);/);
+                var index = parserInput.i;
+                var match = parserInput.$re(/^([^@\$+\/'"*`(;{}-]*);/);
                 if (match) {
-                    return new(tree.Anonymous)(match[1]);
+                    return new(tree.Anonymous)(match[1], index);
                 }
             },
 
@@ -1272,13 +1364,13 @@ var Parser = function Parser(context, imports, fileInfo) {
                 var o, options = {}, optionName, value;
 
                 // list of options, surrounded by parens
-                if (! parserInput.$char('(')) { return null; }
+                if (!parserInput.$char('(')) { return null; }
                 do {
                     o = this.importOption();
                     if (o) {
                         optionName = o;
                         value = true;
-                        switch(optionName) {
+                        switch (optionName) {
                             case "css":
                                 optionName = "less";
                                 value = false;
@@ -1289,7 +1381,7 @@ var Parser = function Parser(context, imports, fileInfo) {
                                 break;
                         }
                         options[optionName] = value;
-                        if (! parserInput.$char(',')) { break; }
+                        if (!parserInput.$char(',')) { break; }
                     }
                 } while (o);
                 expectChar(')');
@@ -1339,12 +1431,12 @@ var Parser = function Parser(context, imports, fileInfo) {
                     e = this.mediaFeature();
                     if (e) {
                         features.push(e);
-                        if (! parserInput.$char(',')) { break; }
+                        if (!parserInput.$char(',')) { break; }
                     } else {
                         e = entities.variable();
                         if (e) {
                             features.push(e);
-                            if (! parserInput.$char(',')) { break; }
+                            if (!parserInput.$char(',')) { break; }
                         }
                     }
                 } while (e);
@@ -1425,7 +1517,7 @@ var Parser = function Parser(context, imports, fileInfo) {
             pluginArgs: function() {
                 // list of options, surrounded by parens
                 parserInput.save();
-                if (! parserInput.$char('(')) {
+                if (!parserInput.$char('(')) {
                     parserInput.restore();
                     return null;
                 }
@@ -1467,7 +1559,7 @@ var Parser = function Parser(context, imports, fileInfo) {
                     nonVendorSpecificName = "@" + name.slice(name.indexOf('-', 2) + 1);
                 }
 
-                switch(nonVendorSpecificName) {
+                switch (nonVendorSpecificName) {
                     case "@charset":
                         hasIdentifier = true;
                         hasBlock = false;
@@ -1534,18 +1626,18 @@ var Parser = function Parser(context, imports, fileInfo) {
             // and before the `;`.
             //
             value: function () {
-                var e, expressions = [];
+                var e, expressions = [], index = parserInput.i;
 
                 do {
                     e = this.expression();
                     if (e) {
                         expressions.push(e);
-                        if (! parserInput.$char(',')) { break; }
+                        if (!parserInput.$char(',')) { break; }
                     }
                 } while (e);
 
                 if (expressions.length > 0) {
-                    return new(tree.Value)(expressions);
+                    return new(tree.Value)(expressions, index);
                 }
             },
             important: function () {
@@ -1784,13 +1876,14 @@ var Parser = function Parser(context, imports, fileInfo) {
             operand: function () {
                 var entities = this.entities, negate;
 
-                if (parserInput.peek(/^-[@\(]/)) {
+                if (parserInput.peek(/^-[@\$\(]/)) {
                     negate = parserInput.$char('-');
                 }
 
                 var o = this.sub() || entities.dimension() ||
                         entities.color() || entities.variable() ||
-                        entities.call() || entities.colorKeyword();
+                        entities.property() || entities.call() ||
+                        entities.colorKeyword();
 
                 if (negate) {
                     o.parensInOp = true;
@@ -1808,7 +1901,7 @@ var Parser = function Parser(context, imports, fileInfo) {
             //     @var * 2
             //
             expression: function () {
-                var entities = [], e, delim;
+                var entities = [], e, delim, index = parserInput.i;
 
                 do {
                     e = this.comment();
@@ -1823,7 +1916,7 @@ var Parser = function Parser(context, imports, fileInfo) {
                         if (!parserInput.peek(/^\/[\/*]/)) {
                             delim = parserInput.$char('/');
                             if (delim) {
-                                entities.push(new(tree.Anonymous)(delim));
+                                entities.push(new(tree.Anonymous)(delim, index));
                             }
                         }
                     }
@@ -1861,7 +1954,7 @@ var Parser = function Parser(context, imports, fileInfo) {
 
                 match(/^(\*?)/);
                 while (true) {
-                    if (!match(/^((?:[\w-]+)|(?:@\{[\w-]+\}))/)) {
+                    if (!match(/^((?:[\w-]+)|(?:[@\$]\{[\w-]+\}))/)) {
                         break;
                     }
                 }
@@ -1877,10 +1970,11 @@ var Parser = function Parser(context, imports, fileInfo) {
                     }
                     for (k = 0; k < name.length; k++) {
                         s = name[k];
-                        name[k] = (s.charAt(0) !== '@') ?
+                        name[k] = (s.charAt(0) !== '@' && s.charAt(0) !== '$') ?
                             new(tree.Keyword)(s) :
-                            new(tree.Variable)('@' + s.slice(2, -1),
-                                index[k], fileInfo);
+                            (s.charAt(0) === '@' ?
+                                new(tree.Variable)('@' + s.slice(2, -1), index[k], fileInfo) :
+                                new(tree.Property)('$' + s.slice(2, -1), index[k], fileInfo));
                     }
                     return name;
                 }