less 2.0.0 → 2.6.0

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) {
-    var that = this;
+tree.Import = function (path, features, options, index, currentFileInfo) {
+    this.options = options;
+    this.index = index;
+    this.path = path;
+    this.features = features;
+    this.currentFileInfo = currentFileInfo;
 
-    this._path = path;
-
-    // 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 (root) {
-            if (! root) {
-                throw new(Error)("Error parsing " + that.path);
-            }
-            that.root = root;
-        });
+        var pathValue = this.getPath();
+        if (pathValue && /css([\?;].*)?$/.test(pathValue)) {
+            this.css = true;
+        }
     }
 };
 
@@ -46,32 +38,87 @@ tree.Import = function (path, imports) {
 // ruleset.
 //
 tree.Import.prototype = {
-    toCSS: function () {
+    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() + ';\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;
+        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)(null, this.root.rules.slice(0));
 
-            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 ruleset.rules;
+            ruleset.evalImports(env);
+
+            return this.features ? new(tree.Media)(ruleset.rules, this.features.value) : ruleset.rules;
         }
     }
 };
 
-})(require('less/tree'));
+})(require('../tree'));

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(', '));
@@ -47,5 +54,5 @@ tree.JavaScript.prototype = {
     }
 };
 
-})(require('less/tree'));
+})(require('../tree'));
 

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

@@ -1,9 +1,24 @@
 (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;
+        } else {
+            return -1;
+        }
+    }
 };
 
-})(require('less/tree'));
+tree.True = new(tree.Keyword)('true');
+tree.False = new(tree.Keyword)('false');
+
+})(require('../tree'));

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

@@ -0,0 +1,157 @@
+(function (tree) {
+
+tree.Media = function (value, features, index, currentFileInfo) {
+    this.index = index;
+    this.currentFileInfo = currentFileInfo;
+
+    var selectors = this.emptySelectors();
+
+    this.features = new(tree.Value)(features);
+    this.rules = [new(tree.Ruleset)(selectors, value)];
+    this.rules[0].allowImports = true;
+};
+tree.Media.prototype = {
+    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 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.mediaPath.push(media);
+        env.mediaBlocks.push(media);
+        
+        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);
+    },
+    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();
+            }
+        }
+    },
+
+    evalTop: function (env) {
+        var result = this;
+
+        // Render all dependent Media blocks.
+        if (env.mediaBlocks.length > 1) {
+            var selectors = this.emptySelectors();
+            result = new(tree.Ruleset)(selectors, env.mediaBlocks);
+            result.multiMedia = true;
+        }
+
+        delete env.mediaBlocks;
+        delete env.mediaPath;
+
+        return result;
+    },
+    evalNested: function (env) {
+        var i, value,
+            path = env.mediaPath.concat([this]);
+
+        // Extract the media-query conditions separated with `,` (OR).
+        for (i = 0; i < path.length; i++) {
+            value = path[i].features instanceof tree.Value ?
+                        path[i].features.value : path[i].features;
+            path[i] = Array.isArray(value) ? value : [value];
+        }
+
+        // Trace all permutations to generate the resulting media-query.
+        //
+        // (a, b and c) with nested (d, e) ->
+        //    a and d
+        //    a and e
+        //    b and c and d
+        //    b and c and e
+        this.features = new(tree.Value)(this.permute(path).map(function (path) {
+            path = path.map(function (fragment) {
+                return fragment.toCSS ? fragment : new(tree.Anonymous)(fragment);
+            });
+
+            for(i = path.length - 1; i > 0; i--) {
+                path.splice(i, 0, new(tree.Anonymous)("and"));
+            }
+
+            return new(tree.Expression)(path);
+        }));
+
+        // Fake a tree-node that doesn't output anything.
+        return new(tree.Ruleset)([], []);
+    },
+    permute: function (arr) {
+      if (arr.length === 0) {
+          return [];
+      } else if (arr.length === 1) {
+          return arr[0];
+      } else {
+          var result = [];
+          var rest = this.permute(arr.slice(1));
+          for (var i = 0; i < rest.length; i++) {
+              for (var j = 0; j < arr[0].length; j++) {
+                  result.push([arr[0][j]].concat(rest[i]));
+              }
+          }
+          return result;
+      }
+    },
+    bubbleSelectors: function (selectors) {
+      if (!selectors)
+        return;
+      this.rules = [new(tree.Ruleset)(selectors.slice(0), [this.rules[0]])];
+    }
+};
+
+})(require('../tree'));