less 1.7.0 → 1.7.5

package/lib/less/tree/rule.js.orig

@@ -0,0 +1,164 @@
+var Node = require("./node.js"),
+    Value = require("./value.js"),
+    Keyword = require("./keyword.js");
+
+<<<<<<< HEAD
+var Rule = function (name, value, important, merge, index, currentFileInfo, inline) {
+=======
+tree.Rule = function (name, value, important, merge, index, currentFileInfo, inline, variable) {
+>>>>>>> origin/master
+    this.name = name;
+    this.value = (value instanceof Node) ? value : new(Value)([value]); //value instanceof tree.Value || value instanceof tree.Ruleset ??
+    this.important = important ? ' ' + important.trim() : '';
+    this.merge = merge;
+    this.index = index;
+    this.currentFileInfo = currentFileInfo;
+    this.inline = inline || false;
+    this.variable = (variable !== undefined) ? variable
+        : (name.charAt && (name.charAt(0) === '@'));
+};
+
+<<<<<<< HEAD
+=======
+tree.Rule.prototype = {
+    type: "Rule",
+    accept: function (visitor) {
+        this.value = visitor.visit(this.value);
+    },
+    genCSS: function (env, output) {
+        output.add(this.name + (env.compress ? ':' : ': '), this.currentFileInfo, this.index);
+        try {
+            this.value.genCSS(env, output);
+        }
+        catch(e) {
+            e.index = this.index;
+            e.filename = this.currentFileInfo.filename;
+            throw e;
+        }
+        output.add(this.important + ((this.inline || (env.lastRule && env.compress)) ? "" : ";"), this.currentFileInfo, this.index);
+    },
+    toCSS: tree.toCSS,
+    eval: function (env) {
+        var strictMathBypass = false, name = this.name, variable = this.variable, evaldValue;
+        if (typeof name !== "string") {
+            // expand 'primitive' name directly to get
+            // things faster (~10% for benchmark.less):
+            name = (name.length === 1) 
+                && (name[0] instanceof tree.Keyword)
+                    ? name[0].value : evalName(env, name);
+            variable = false; // never treat expanded interpolation as new variable name
+        }
+        if (name === "font" && !env.strictMath) {
+            strictMathBypass = true;
+            env.strictMath = true;
+        }
+        try {
+            evaldValue = this.value.eval(env);
+            
+            if (!this.variable && evaldValue.type === "DetachedRuleset") {
+                throw { message: "Rulesets cannot be evaluated on a property.",
+                        index: this.index, filename: this.currentFileInfo.filename };
+            }
+
+            return new(tree.Rule)(name,
+                              evaldValue,
+                              this.important,
+                              this.merge,
+                              this.index, this.currentFileInfo, this.inline,
+                              variable);
+        }
+        catch(e) {
+            if (typeof e.index !== 'number') {
+                e.index = this.index;
+                e.filename = this.currentFileInfo.filename;
+            }
+            throw e;
+        }
+        finally {
+            if (strictMathBypass) {
+                env.strictMath = false;
+            }
+        }
+    },
+    makeImportant: function () {
+        return new(tree.Rule)(this.name,
+                              this.value,
+                              "!important",
+                              this.merge,
+                              this.index, this.currentFileInfo, this.inline);
+    }
+};
+
+>>>>>>> origin/master
+function evalName(env, name) {
+    var value = "", i, n = name.length,
+        output = {add: function (s) {value += s;}};
+    for (i = 0; i < n; i++) {
+        name[i].eval(env).genCSS(env, output);
+    }
+    return value;
+}
+
+Rule.prototype = new Node();
+Rule.prototype.type = "Rule";
+Rule.prototype.genCSS = function (env, output) {
+    output.add(this.name + (env.compress ? ':' : ': '), this.currentFileInfo, this.index);
+    try {
+        this.value.genCSS(env, output);
+    }
+    catch(e) {
+        e.index = this.index;
+        e.filename = this.currentFileInfo.filename;
+        throw e;
+    }
+    output.add(this.important + ((this.inline || (env.lastRule && env.compress)) ? "" : ";"), this.currentFileInfo, this.index);
+};
+Rule.prototype.eval = function (env) {
+    var strictMathBypass = false, name = this.name, evaldValue;
+    if (typeof name !== "string") {
+        // expand 'primitive' name directly to get
+        // things faster (~10% for benchmark.less):
+        name = (name.length === 1)
+            && (name[0] instanceof Keyword)
+                ? name[0].value : evalName(env, name);
+    }
+    if (name === "font" && !env.strictMath) {
+        strictMathBypass = true;
+        env.strictMath = true;
+    }
+    try {
+        evaldValue = this.value.eval(env);
+
+        if (!this.variable && evaldValue.type === "DetachedRuleset") {
+            throw { message: "Rulesets cannot be evaluated on a property.",
+                    index: this.index, filename: this.currentFileInfo.filename };
+        }
+
+        return new(Rule)(name,
+                          evaldValue,
+                          this.important,
+                          this.merge,
+                          this.index, this.currentFileInfo, this.inline);
+    }
+    catch(e) {
+        if (typeof e.index !== 'number') {
+            e.index = this.index;
+            e.filename = this.currentFileInfo.filename;
+        }
+        throw e;
+    }
+    finally {
+        if (strictMathBypass) {
+            env.strictMath = false;
+        }
+    }
+};
+Rule.prototype.makeImportant = function () {
+    return new(Rule)(this.name,
+                          this.value,
+                          "!important",
+                          this.merge,
+                          this.index, this.currentFileInfo, this.inline);
+};
+
+module.exports = Rule;

package/lib/less/tree/ruleset.js

@@ -266,6 +266,7 @@ tree.Ruleset.prototype = {
     },
     genCSS: function (env, output) {
         var i, j,
+            charsetRuleNodes = [],
             ruleNodes = [],
             rulesetNodes = [],
             rulesetNodeCnt,
@@ -283,14 +284,38 @@ tree.Ruleset.prototype = {
             tabSetStr = env.compress ? '' : Array(env.tabLevel).join("  "),
             sep;
 
+        function isRulesetLikeNode(rule, root) {
+             // if it has nested rules, then it should be treated like a ruleset
+             if (rule.rules)
+                 return true;
+
+             // medias and comments do not have nested rules, but should be treated like rulesets anyway
+             if ( (rule instanceof tree.Media) || (root && rule instanceof tree.Comment))
+                 return true;
+
+             // some directives and anonumoust nodes are ruleset like, others are not
+             if ((rule instanceof tree.Directive) || (rule instanceof tree.Anonymous)) {
+                 return rule.isRulesetLike();
+             }
+
+             //anything else is assumed to be a rule
+             return false;
+        }
+
         for (i = 0; i < this.rules.length; i++) {
             rule = this.rules[i];
-            if (rule.rules || (rule instanceof tree.Media) || rule instanceof tree.Directive || (this.root && rule instanceof tree.Comment)) {
+            if (isRulesetLikeNode(rule, this.root)) {
                 rulesetNodes.push(rule);
             } else {
-                ruleNodes.push(rule);
+                //charsets should float on top of everything
+                if (rule.isCharset && rule.isCharset()) {
+                    charsetRuleNodes.push(rule);
+                } else {
+                    ruleNodes.push(rule);
+                }
             }
         }
+        ruleNodes = charsetRuleNodes.concat(ruleNodes);
 
         // If this is the root node, we don't render
         // a selector, or {}.

package/lib/less/tree/selector.js

@@ -73,7 +73,7 @@ tree.Selector.prototype = {
                 css += v.value.value;
             }
 
-            this._elements = css.match(/[,&#\.\w-]([\w-]|(\\.))*/g);
+            this._elements = css.match(/[,&#\*\.\w-]([\w-]|(\\.))*/g);
 
             if (this._elements) {
                 if (this._elements[0] === "&") {

package/lib/less/tree.js

@@ -43,9 +43,9 @@ tree.find = function (obj, fun) {
 
 tree.jsify = function (obj) {
     if (Array.isArray(obj.value) && (obj.value.length > 1)) {
-        return '[' + obj.value.map(function (v) { return v.toCSS(false); }).join(', ') + ']';
+        return '[' + obj.value.map(function (v) { return v.toCSS(); }).join(', ') + ']';
     } else {
-        return obj.toCSS(false);
+        return obj.toCSS();
     }
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "less",
-  "version": "1.7.0",
+  "version": "1.7.5",
   "description": "Leaner CSS",
   "homepage": "http://lesscss.org",
   "author": {
@@ -31,7 +31,7 @@
     "test": "./test"
   },
   "jam": {
-    "main": "./dist/less-1.6.3.js"
+    "main": "./dist/less-1.7.5.js"
   },
   "engines": {
     "node": ">=0.8.0"
@@ -40,25 +40,26 @@
     "test": "grunt test"
   },
   "optionalDependencies": {
-    "mime": "1.2.x",
-    "request": ">=2.33.0",
-    "mkdirp": "~0.3.5",
-    "clean-css": "2.1.x",
+    "graceful-fs": "~3.0.2",
+    "mime": "~1.2.11",
+    "request": "~2.40.0",
+    "mkdirp": "~0.5.0",
+    "clean-css": "2.2.x",
     "source-map": "0.1.x"
   },
   "devDependencies": {
     "diff": "~1.0",
     "grunt": "~0.4.2",
     "grunt-contrib-clean": "~0.5.0",
-    "grunt-contrib-concat": "~0.3.0",
-    "grunt-contrib-connect": "~0.6.0",
+    "grunt-contrib-concat": "~0.4.0",
+    "grunt-contrib-connect": "~0.7.0",
     "grunt-contrib-jasmine": "~0.5.2",
-    "grunt-contrib-jshint": "~0.8.0",
-    "grunt-contrib-uglify": "~0.3.2",
-    "grunt-shell": "~0.6.4",
+    "grunt-contrib-jshint": "~0.10.0",
+    "grunt-contrib-uglify": "~0.4.0",
+    "grunt-shell": "~0.7.0",
     "http-server": "~0.6.1",
     "matchdep": "~0.3.0",
-    "time-grunt": "~0.2.9"
+    "time-grunt": "~0.3.1"
  },
   "keywords": [
     "compile less",