less 2.2.2 → 2.6.0

data/lib/less/js/lib/less/tree/expression.js

@@ -1,22 +1,53 @@
 (function (tree) {
 
-tree.Expression = function (value) { this.value = value };
+tree.Expression = function (value) { this.value = value; };
 tree.Expression.prototype = {
+    type: "Expression",
+    accept: function (visitor) {
+        if (this.value) {
+            this.value = visitor.visitArray(this.value);
+        }
+    },
     eval: function (env) {
+        var returnValue,
+            inParenthesis = this.parens && !this.parensInOp,
+            doubleParen = false;
+        if (inParenthesis) {
+            env.inParenthesis();
+        }
         if (this.value.length > 1) {
-            return new(tree.Expression)(this.value.map(function (e) {
+            returnValue = new(tree.Expression)(this.value.map(function (e) {
                 return e.eval(env);
             }));
         } else if (this.value.length === 1) {
-            return this.value[0].eval(env);
+            if (this.value[0].parens && !this.value[0].parensInOp) {
+                doubleParen = true;
+            }
+            returnValue = this.value[0].eval(env);
         } else {
-            return this;
+            returnValue = this;
+        }
+        if (inParenthesis) {
+            env.outOfParenthesis();
+        }
+        if (this.parens && this.parensInOp && !(env.isMathOn()) && !doubleParen) {
+            returnValue = new(tree.Paren)(returnValue);
+        }
+        return returnValue;
+    },
+    genCSS: function (env, output) {
+        for(var i = 0; i < this.value.length; i++) {
+            this.value[i].genCSS(env, output);
+            if (i + 1 < this.value.length) {
+                output.add(" ");
+            }
         }
     },
-    toCSS: function (env) {
-        return this.value.map(function (e) {
-            return e.toCSS ? e.toCSS(env) : '';
-        }).join(' ');
+    toCSS: tree.toCSS,
+    throwAwayComments: function () {
+        this.value = this.value.filter(function(v) {
+            return !(v instanceof tree.Comment);
+        });
     }
 };
 

data/lib/less/js/lib/less/tree/extend.js

@@ -0,0 +1,53 @@
+(function (tree) {
+
+tree.Extend = function Extend(selector, option, index) {
+    this.selector = selector;
+    this.option = option;
+    this.index = index;
+    this.object_id = tree.Extend.next_id++;
+    this.parent_ids = [this.object_id];
+
+    switch(option) {
+        case "all":
+            this.allowBefore = true;
+            this.allowAfter = true;
+        break;
+        default:
+            this.allowBefore = false;
+            this.allowAfter = false;
+        break;
+    }
+};
+tree.Extend.next_id = 0;
+
+tree.Extend.prototype = {
+    type: "Extend",
+    accept: function (visitor) {
+        this.selector = visitor.visit(this.selector);
+    },
+    eval: function (env) {
+        return new(tree.Extend)(this.selector.eval(env), this.option, this.index);
+    },
+    clone: function (env) {
+        return new(tree.Extend)(this.selector, this.option, this.index);
+    },
+    findSelfSelectors: function (selectors) {
+        var selfElements = [],
+            i,
+            selectorElements;
+
+        for(i = 0; i < selectors.length; i++) {
+            selectorElements = selectors[i].elements;
+            // duplicate the logic in genCSS function inside the selector node.
+            // future TODO - move both logics into the selector joiner visitor
+            if (i > 0 && selectorElements.length && selectorElements[0].combinator.value === "") {
+                selectorElements[0].combinator.value = ' ';
+            }
+            selfElements = selfElements.concat(selectors[i].elements);
+        }
+
+        this.selfSelectors = [{ elements: selfElements }];
+    }
+};
+
+})(require('../tree'));

data/lib/less/js/lib/less/tree/import.js

@@ -11,28 +11,20 @@
 // `import,push`, we also pass it a callback, which it'll call once
 // the file has been fetched, and parsed.
 //
-tree.Import = function (path, imports, features, index) {
-    var that = this;
-
+tree.Import = function (path, features, options, index, currentFileInfo) {
+    this.options = options;
     this.index = index;
-    this._path = path;
-    this.features = features && new(tree.Value)(features);
+    this.path = path;
+    this.features = features;
+    this.currentFileInfo = currentFileInfo;
 
-    // The '.less' extension is optional
-    if (path instanceof tree.Quoted) {
-        this.path = /\.(le?|c)ss(\?.*)?$/.test(path.value) ? path.value : path.value + '.less';
+    if (this.options.less !== undefined || this.options.inline) {
+        this.css = !this.options.less || this.options.inline;
     } else {
-        this.path = path.value.value || path.value;
-    }
-
-    this.css = /css(\?.*)?$/.test(this.path);
-
-    // Only pre-compile .less files
-    if (! this.css) {
-        imports.push(this.path, function (e, root) {
-            if (e) { e.index = index }
-            that.root = root || new(tree.Ruleset)([], []);
-        });
+        var pathValue = this.getPath();
+        if (pathValue && /css([\?;].*)?$/.test(pathValue)) {
+            this.css = true;
+        }
     }
 };
 
@@ -46,31 +38,84 @@ tree.Import = function (path, imports, features, index) {
 // ruleset.
 //
 tree.Import.prototype = {
-    toCSS: function (env) {
-        var features = this.features ? ' ' + this.features.toCSS(env) : '';
-
+    type: "Import",
+    accept: function (visitor) {
+        if (this.features) {
+            this.features = visitor.visit(this.features);
+        }
+        this.path = visitor.visit(this.path);
+        if (!this.options.inline && this.root) {
+            this.root = visitor.visit(this.root);
+        }
+    },
+    genCSS: function (env, output) {
         if (this.css) {
-            return "@import " + this._path.toCSS() + features + ';\n';
-        } else {
-            return "";
+            output.add("@import ", this.currentFileInfo, this.index);
+            this.path.genCSS(env, output);
+            if (this.features) {
+                output.add(" ");
+                this.features.genCSS(env, output);
+            }
+            output.add(';');
+        }
+    },
+    toCSS: tree.toCSS,
+    getPath: function () {
+        if (this.path instanceof tree.Quoted) {
+            var path = this.path.value;
+            return (this.css !== undefined || /(\.[a-z]*$)|([\?;].*)$/.test(path)) ? path : path + '.less';
+        } else if (this.path instanceof tree.URL) {
+            return this.path.value.value;
+        }
+        return null;
+    },
+    evalForImport: function (env) {
+        return new(tree.Import)(this.path.eval(env), this.features, this.options, this.index, this.currentFileInfo);
+    },
+    evalPath: function (env) {
+        var path = this.path.eval(env);
+        var rootpath = this.currentFileInfo && this.currentFileInfo.rootpath;
+
+        if (!(path instanceof tree.URL)) {
+            if (rootpath) {
+                var pathValue = path.value;
+                // Add the base path if the import is relative
+                if (pathValue && env.isPathRelative(pathValue)) {
+                    path.value = rootpath +pathValue;
+                }
+            }
+            path.value = env.normalizePath(path.value);
         }
+
+        return path;
     },
     eval: function (env) {
         var ruleset, features = this.features && this.features.eval(env);
 
-        if (this.css) {
-            return this;
+        if (this.skip) {
+            if (typeof this.skip === "function") {
+                this.skip = this.skip();
+            }
+            if (this.skip) {
+                return []; 
+            }
+        }
+         
+        if (this.options.inline) {
+            //todo needs to reference css file not import
+            var contents = new(tree.Anonymous)(this.root, 0, {filename: this.importedFilename}, true);
+            return this.features ? new(tree.Media)([contents], this.features.value) : [contents];
+        } else if (this.css) {
+            var newImport = new(tree.Import)(this.evalPath(env), features, this.options, this.index);
+            if (!newImport.css && this.error) {
+                throw this.error;
+            }
+            return newImport;
         } else {
-            ruleset = new(tree.Ruleset)([], this.root.rules.slice(0));
+            ruleset = new(tree.Ruleset)(null, this.root.rules.slice(0));
+
+            ruleset.evalImports(env);
 
-            for (var i = 0; i < ruleset.rules.length; i++) {
-                if (ruleset.rules[i] instanceof tree.Import) {
-                    Array.prototype
-                         .splice
-                         .apply(ruleset.rules,
-                                [i, 1].concat(ruleset.rules[i].eval(env)));
-                }
-            }
             return this.features ? new(tree.Media)(ruleset.rules, this.features.value) : ruleset.rules;
         }
     }

data/lib/less/js/lib/less/tree/javascript.js

@@ -6,6 +6,7 @@ tree.JavaScript = function (string, index, escaped) {
     this.index = index;
 };
 tree.JavaScript.prototype = {
+    type: "JavaScript",
     eval: function (env) {
         var result,
             that = this,
@@ -18,26 +19,32 @@ tree.JavaScript.prototype = {
         try {
             expression = new(Function)('return (' + expression + ')');
         } catch (e) {
-            throw { message: "JavaScript evaluation error: `" + expression + "`" ,
+            throw { message: "JavaScript evaluation error: " + e.message + " from `" + expression + "`" ,
                     index: this.index };
         }
 
-        for (var k in env.frames[0].variables()) {
-            context[k.slice(1)] = {
-                value: env.frames[0].variables()[k].value,
-                toJS: function () {
-                    return this.value.eval(env).toCSS();
-                }
-            };
+        var variables = env.frames[0].variables();
+        for (var k in variables) {
+            if (variables.hasOwnProperty(k)) {
+                /*jshint loopfunc:true */
+                context[k.slice(1)] = {
+                    value: variables[k].value,
+                    toJS: function () {
+                        return this.value.eval(env).toCSS();
+                    }
+                };
+            }
         }
 
         try {
             result = expression.call(context);
         } catch (e) {
-            throw { message: "JavaScript evaluation error: '" + e.name + ': ' + e.message + "'" ,
+            throw { message: "JavaScript evaluation error: '" + e.name + ': ' + e.message.replace(/["]/g, "'") + "'" ,
                     index: this.index };
         }
-        if (typeof(result) === 'string') {
+        if (typeof(result) === 'number') {
+            return new(tree.Dimension)(result);
+        } else if (typeof(result) === 'string') {
             return new(tree.Quoted)('"' + result + '"', result, this.escaped, this.index);
         } else if (Array.isArray(result)) {
             return new(tree.Anonymous)(result.join(', '));

data/lib/less/js/lib/less/tree/keyword.js

@@ -1,9 +1,14 @@
 (function (tree) {
 
-tree.Keyword = function (value) { this.value = value };
+tree.Keyword = function (value) { this.value = value; };
 tree.Keyword.prototype = {
-    eval: function () { return this },
-    toCSS: function () { return this.value },
+    type: "Keyword",
+    eval: function () { return this; },
+    genCSS: function (env, output) {
+        if (this.value === '%') { throw { type: "Syntax", message: "Invalid % without number" }; }
+        output.add(this.value);
+    },
+    toCSS: tree.toCSS,
     compare: function (other) {
         if (other instanceof tree.Keyword) {
             return other.value === this.value ? 0 : 1;

data/lib/less/js/lib/less/tree/media.js

@@ -1,56 +1,94 @@
 (function (tree) {
 
-tree.Media = function (value, features) {
-    var el = new(tree.Element)('&', null, 0),
-        selectors = [new(tree.Selector)([el])];
+tree.Media = function (value, features, index, currentFileInfo) {
+    this.index = index;
+    this.currentFileInfo = currentFileInfo;
+
+    var selectors = this.emptySelectors();
 
     this.features = new(tree.Value)(features);
-    this.ruleset = new(tree.Ruleset)(selectors, value);
-    this.ruleset.allowImports = true;
+    this.rules = [new(tree.Ruleset)(selectors, value)];
+    this.rules[0].allowImports = true;
 };
 tree.Media.prototype = {
-    toCSS: function (ctx, env) {
-        var features = this.features.toCSS(env);
-
-        this.ruleset.root = (ctx.length === 0 || ctx[0].multiMedia);
-        return '@media ' + features + (env.compress ? '{' : ' {\n  ') +
-               this.ruleset.toCSS(ctx, env).trim().replace(/\n/g, '\n  ') +
-                           (env.compress ? '}': '\n}\n');
+    type: "Media",
+    accept: function (visitor) {
+        if (this.features) {
+            this.features = visitor.visit(this.features);
+        }
+        if (this.rules) {
+            this.rules = visitor.visitArray(this.rules);
+        }
+    },
+    genCSS: function (env, output) {
+        output.add('@media ', this.currentFileInfo, this.index);
+        this.features.genCSS(env, output);
+        tree.outputRuleset(env, output, this.rules);
     },
+    toCSS: tree.toCSS,
     eval: function (env) {
         if (!env.mediaBlocks) {
             env.mediaBlocks = [];
             env.mediaPath = [];
         }
         
-        var blockIndex = env.mediaBlocks.length;
-        env.mediaPath.push(this);
-        env.mediaBlocks.push(this);
-
-        var media = new(tree.Media)([], []);
-        media.features = this.features.eval(env);
+        var media = new(tree.Media)(null, [], this.index, this.currentFileInfo);
+        if(this.debugInfo) {
+            this.rules[0].debugInfo = this.debugInfo;
+            media.debugInfo = this.debugInfo;
+        }
+        var strictMathBypass = false;
+        if (!env.strictMath) {
+            strictMathBypass = true;
+            env.strictMath = true;
+        }
+        try {
+            media.features = this.features.eval(env);
+        }
+        finally {
+            if (strictMathBypass) {
+                env.strictMath = false;
+            }
+        }
         
-        env.frames.unshift(this.ruleset);
-        media.ruleset = this.ruleset.eval(env);
+        env.mediaPath.push(media);
+        env.mediaBlocks.push(media);
+        
+        env.frames.unshift(this.rules[0]);
+        media.rules = [this.rules[0].eval(env)];
         env.frames.shift();
         
-        env.mediaBlocks[blockIndex] = media;
         env.mediaPath.pop();
 
         return env.mediaPath.length === 0 ? media.evalTop(env) :
-                    media.evalNested(env)
+                    media.evalNested(env);
+    },
+    variable: function (name) { return tree.Ruleset.prototype.variable.call(this.rules[0], name); },
+    find: function () { return tree.Ruleset.prototype.find.apply(this.rules[0], arguments); },
+    rulesets: function () { return tree.Ruleset.prototype.rulesets.apply(this.rules[0]); },
+    emptySelectors: function() { 
+        var el = new(tree.Element)('', '&', this.index, this.currentFileInfo),
+            sels = [new(tree.Selector)([el], null, null, this.index, this.currentFileInfo)];
+        sels[0].mediaEmpty = true;
+        return sels;
+    },
+    markReferenced: function () {
+        var i, rules = this.rules[0].rules;
+        this.rules[0].markReferenced();
+        this.isReferenced = true;
+        for (i = 0; i < rules.length; i++) {
+            if (rules[i].markReferenced) {
+                rules[i].markReferenced();
+            }
+        }
     },
-    variable: function (name) { return tree.Ruleset.prototype.variable.call(this.ruleset, name) },
-    find: function () { return tree.Ruleset.prototype.find.apply(this.ruleset, arguments) },
-    rulesets: function () { return tree.Ruleset.prototype.rulesets.apply(this.ruleset) },
 
     evalTop: function (env) {
         var result = this;
 
         // Render all dependent Media blocks.
         if (env.mediaBlocks.length > 1) {
-            var el = new(tree.Element)('&', null, 0);
-            var selectors = [new(tree.Selector)([el])];
+            var selectors = this.emptySelectors();
             result = new(tree.Ruleset)(selectors, env.mediaBlocks);
             result.multiMedia = true;
         }
@@ -108,6 +146,11 @@ tree.Media.prototype = {
           }
           return result;
       }
+    },
+    bubbleSelectors: function (selectors) {
+      if (!selectors)
+        return;
+      this.rules = [new(tree.Ruleset)(selectors.slice(0), [this.rules[0]])];
     }
 };