less 2.4.0 → 2.5.0

data/lib/less/js/lib/less/tree/directive.js

@@ -1,44 +1,65 @@
 (function (tree) {
 
-tree.Directive = function (name, value) {
+tree.Directive = function (name, value, index, currentFileInfo) {
     this.name = name;
 
     if (Array.isArray(value)) {
-        this.ruleset = new(tree.Ruleset)([], value);
-        this.ruleset.allowImports = true;
+        this.rules = [new(tree.Ruleset)(null, value)];
+        this.rules[0].allowImports = true;
     } else {
         this.value = value;
     }
+    this.index = index;
+    this.currentFileInfo = currentFileInfo;
+
 };
 tree.Directive.prototype = {
     type: "Directive",
     accept: function (visitor) {
-        this.ruleset = visitor.visit(this.ruleset);
-        this.value = visitor.visit(this.value);
+        if (this.rules) {
+            this.rules = visitor.visitArray(this.rules);
+        }
+        if (this.value) {
+            this.value = visitor.visit(this.value);
+        }
     },
-    toCSS: function (env) {
-        if (this.ruleset) {
-            this.ruleset.root = true;
-            return this.name + (env.compress ? '{' : ' {\n  ') +
-                   this.ruleset.toCSS(env).trim().replace(/\n/g, '\n  ') +
-                               (env.compress ? '}': '\n}\n');
+    genCSS: function (env, output) {
+        output.add(this.name, this.currentFileInfo, this.index);
+        if (this.rules) {
+            tree.outputRuleset(env, output, this.rules);
         } else {
-            return this.name + ' ' + this.value.toCSS() + ';\n';
+            output.add(' ');
+            this.value.genCSS(env, output);
+            output.add(';');
         }
     },
+    toCSS: tree.toCSS,
     eval: function (env) {
         var evaldDirective = this;
-        if (this.ruleset) {
+        if (this.rules) {
             env.frames.unshift(this);
-            evaldDirective = new(tree.Directive)(this.name);
-            evaldDirective.ruleset = this.ruleset.eval(env);
+            evaldDirective = new(tree.Directive)(this.name, null, this.index, this.currentFileInfo);
+            evaldDirective.rules = [this.rules[0].eval(env)];
+            evaldDirective.rules[0].root = true;
             env.frames.shift();
         }
         return evaldDirective;
     },
-    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) }
+    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]); },
+    markReferenced: function () {
+        var i, rules;
+        this.isReferenced = true;
+        if (this.rules) {
+            rules = this.rules[0].rules;
+            for (i = 0; i < rules.length; i++) {
+                if (rules[i].markReferenced) {
+                    rules[i].markReferenced();
+                }
+            }
+        }
+    }
 };
 
 })(require('../tree'));

data/lib/less/js/lib/less/tree/element.js

@@ -1,6 +1,6 @@
 (function (tree) {
 
-tree.Element = function (combinator, value, index) {
+tree.Element = function (combinator, value, index, currentFileInfo) {
     this.combinator = combinator instanceof tree.Combinator ?
                       combinator : new(tree.Combinator)(combinator);
 
@@ -12,21 +12,29 @@ tree.Element = function (combinator, value, index) {
         this.value = "";
     }
     this.index = index;
+    this.currentFileInfo = currentFileInfo;
 };
 tree.Element.prototype = {
     type: "Element",
     accept: function (visitor) {
+        var value = this.value;
         this.combinator = visitor.visit(this.combinator);
-        this.value = visitor.visit(this.value);
+        if (typeof value === "object") {
+            this.value = visitor.visit(value);
+        }
     },
     eval: function (env) {
         return new(tree.Element)(this.combinator,
                                  this.value.eval ? this.value.eval(env) : this.value,
-                                 this.index);
+                                 this.index,
+                                 this.currentFileInfo);
+    },
+    genCSS: function (env, output) {
+        output.add(this.toCSS(env), this.currentFileInfo, this.index);
     },
     toCSS: function (env) {
         var value = (this.value.toCSS ? this.value.toCSS(env) : this.value);
-        if (value == '' && this.combinator.value.charAt(0) == '&') {
+        if (value === '' && this.combinator.value.charAt(0) === '&') {
             return '';
         } else {
             return this.combinator.toCSS(env || {}) + value;
@@ -41,13 +49,13 @@ tree.Attribute = function (key, op, value) {
 };
 tree.Attribute.prototype = {
     type: "Attribute",
-    accept: function (visitor) {
-        this.value = visitor.visit(this.value);
-    },
     eval: function (env) {
         return new(tree.Attribute)(this.key.eval ? this.key.eval(env) : this.key,
             this.op, (this.value && this.value.eval) ? this.value.eval(env) : this.value);
     },
+    genCSS: function (env, output) {
+        output.add(this.toCSS(env));
+    },
     toCSS: function (env) {
         var value = this.key.toCSS ? this.key.toCSS(env) : this.key;
 
@@ -69,17 +77,32 @@ tree.Combinator = function (value) {
 };
 tree.Combinator.prototype = {
     type: "Combinator",
-    toCSS: function (env) {
-        return {
-            ''  : '',
-            ' ' : ' ',
-            ':' : ' :',
-            '+' : env.compress ? '+' : ' + ',
-            '~' : env.compress ? '~' : ' ~ ',
-            '>' : env.compress ? '>' : ' > ',
-            '|' : env.compress ? '|' : ' | '
-        }[this.value];
-    }
+    _outputMap: {
+        ''  : '',
+        ' ' : ' ',
+        ':' : ' :',
+        '+' : ' + ',
+        '~' : ' ~ ',
+        '>' : ' > ',
+        '|' : '|',
+        '^' : ' ^ ',
+        '^^' : ' ^^ '
+    },
+    _outputMapCompressed: {
+        ''  : '',
+        ' ' : ' ',
+        ':' : ' :',
+        '+' : '+',
+        '~' : '~',
+        '>' : '>',
+        '|' : '|',
+        '^' : '^',
+        '^^' : '^^'
+    },
+    genCSS: function (env, output) {
+        output.add((env.compress ? this._outputMapCompressed : this._outputMap)[this.value]);
+    },
+    toCSS: tree.toCSS
 };
 
 })(require('../tree'));

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

@@ -4,7 +4,9 @@ tree.Expression = function (value) { this.value = value; };
 tree.Expression.prototype = {
     type: "Expression",
     accept: function (visitor) {
-        this.value = visitor.visit(this.value);
+        if (this.value) {
+            this.value = visitor.visitArray(this.value);
+        }
     },
     eval: function (env) {
         var returnValue,
@@ -33,11 +35,15 @@ tree.Expression.prototype = {
         }
         return returnValue;
     },
-    toCSS: function (env) {
-        return this.value.map(function (e) {
-            return e.toCSS ? e.toCSS(env) : '';
-        }).join(' ');
+    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: 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

@@ -4,6 +4,8 @@ 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":
@@ -16,6 +18,7 @@ tree.Extend = function Extend(selector, option, index) {
         break;
     }
 };
+tree.Extend.next_id = 0;
 
 tree.Extend.prototype = {
     type: "Extend",
@@ -30,9 +33,16 @@ tree.Extend.prototype = {
     },
     findSelfSelectors: function (selectors) {
         var selfElements = [],
-            i;
+            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);
         }
 

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

@@ -12,16 +12,14 @@
 // the file has been fetched, and parsed.
 //
 tree.Import = function (path, features, options, index, currentFileInfo) {
-    var that = this;
-
     this.options = options;
     this.index = index;
     this.path = path;
     this.features = features;
     this.currentFileInfo = currentFileInfo;
 
-    if (this.options.less !== undefined) {
-        this.css = !this.options.less;
+    if (this.options.less !== undefined || this.options.inline) {
+        this.css = !this.options.less || this.options.inline;
     } else {
         var pathValue = this.getPath();
         if (pathValue && /css([\?;].*)?$/.test(pathValue)) {
@@ -42,19 +40,26 @@ tree.Import = function (path, features, options, index, currentFileInfo) {
 tree.Import.prototype = {
     type: "Import",
     accept: function (visitor) {
-        this.features = visitor.visit(this.features);
+        if (this.features) {
+            this.features = visitor.visit(this.features);
+        }
         this.path = visitor.visit(this.path);
-        this.root = visitor.visit(this.root);
+        if (!this.options.inline && this.root) {
+            this.root = visitor.visit(this.root);
+        }
     },
-    toCSS: function (env) {
-        var features = this.features ? ' ' + this.features.toCSS(env) : '';
-
+    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;
@@ -70,28 +75,37 @@ tree.Import.prototype = {
     evalPath: function (env) {
         var path = this.path.eval(env);
         var rootpath = this.currentFileInfo && this.currentFileInfo.rootpath;
-        if (rootpath && !(path instanceof tree.URL)) {
-            var pathValue = path.value;
-            // Add the base path if the import is relative
-            if (pathValue && env.isPathRelative(pathValue)) {
-                path.value =  rootpath + pathValue;
+
+        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.skip) { return []; }
-
-        if (this.css) {
+         
+        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);
 

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

@@ -19,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,10 +1,13 @@
 (function (tree) {
 
-tree.Keyword = function (value) { this.value = value };
+tree.Keyword = function (value) { this.value = value; };
 tree.Keyword.prototype = {
     type: "Keyword",
     eval: function () { return this; },
-    toCSS: function () { return this.value; },
+    genCSS: function (env, output) {
+        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,34 +1,40 @@
 (function (tree) {
 
-tree.Media = function (value, features) {
+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 = {
     type: "Media",
     accept: function (visitor) {
-        this.features = visitor.visit(this.features);
-        this.ruleset = visitor.visit(this.ruleset);
+        if (this.features) {
+            this.features = visitor.visit(this.features);
+        }
+        if (this.rules) {
+            this.rules = visitor.visitArray(this.rules);
+        }
     },
-    toCSS: function (env) {
-        var features = this.features.toCSS(env);
-
-        return '@media ' + features + (env.compress ? '{' : ' {\n  ') +
-               this.ruleset.toCSS(env).trim().replace(/\n/g, '\n  ') +
-                           (env.compress ? '}': '\n}\n');
+    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 media = new(tree.Media)([], []);
+        var media = new(tree.Media)(null, [], this.index, this.currentFileInfo);
         if(this.debugInfo) {
-            this.ruleset.debugInfo = this.debugInfo;
+            this.rules[0].debugInfo = this.debugInfo;
             media.debugInfo = this.debugInfo;
         }
         var strictMathBypass = false;
@@ -48,21 +54,32 @@ tree.Media.prototype = {
         env.mediaPath.push(media);
         env.mediaBlocks.push(media);
         
-        env.frames.unshift(this.ruleset);
-        media.ruleset = this.ruleset.eval(env);
+        env.frames.unshift(this.rules[0]);
+        media.rules = [this.rules[0].eval(env)];
         env.frames.shift();
         
         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.ruleset, name) },
-    find: function () { return tree.Ruleset.prototype.find.apply(this.ruleset, arguments) },
-    rulesets: function () { return tree.Ruleset.prototype.rulesets.apply(this.ruleset) },
+    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)('', '&', 0);
-        return [new(tree.Selector)([el])];
+        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.isReferenced = true;
+        for (i = 0; i < rules.length; i++) {
+            if (rules[i].markReferenced) {
+                rules[i].markReferenced();
+            }
+        }
     },
 
     evalTop: function (env) {
@@ -130,7 +147,7 @@ tree.Media.prototype = {
       }
     },
     bubbleSelectors: function (selectors) {
-      this.ruleset = new(tree.Ruleset)(selectors.slice(0), [this.ruleset]);
+      this.rules = [new(tree.Ruleset)(selectors.slice(0), [this.rules[0]])];
     }
 };