less 2.0.4 → 2.1.0

data/lib/less/js/lib/less/functions.js

@@ -86,6 +86,13 @@ tree.functions = {
         hsl.a = clamp(hsl.a);
         return hsla(hsl);
     },
+    fade: function (color, amount) {
+        var hsl = color.toHSL();
+
+        hsl.a = amount.value / 100;
+        hsl.a = clamp(hsl.a);
+        return hsla(hsl);
+    },
     spin: function (color, amount) {
         var hsl = color.toHSL();
         var hue = (hsl.h + amount.value) % 360;
@@ -137,16 +144,63 @@ tree.functions = {
         return new(tree.Quoted)('"' + str + '"', str);
     },
     round: function (n) {
+        return this._math('round', n);
+    },
+    ceil: function (n) {
+        return this._math('ceil', n);
+    },
+    floor: function (n) {
+        return this._math('floor', n);
+    },
+    _math: function (fn, n) {
         if (n instanceof tree.Dimension) {
-            return new(tree.Dimension)(Math.round(number(n)), n.unit);
+            return new(tree.Dimension)(Math[fn](number(n)), n.unit);
         } else if (typeof(n) === 'number') {
-            return Math.round(n);
+            return Math[fn](n);
         } else {
-	    throw {
-                error: "RuntimeError",
-                message: "math functions take numbers as parameters"
-            };
+            throw { type: "Argument", message: "argument must be a number" };
         }
+    },
+    argb: function (color) {
+        return new(tree.Anonymous)(color.toARGB());
+
+    },
+    percentage: function (n) {
+        return new(tree.Dimension)(n.value * 100, '%');
+    },
+    color: function (n) {
+        if (n instanceof tree.Quoted) {
+            return new(tree.Color)(n.value.slice(1));
+        } else {
+            throw { type: "Argument", message: "argument must be a string" };
+        }
+    },
+    iscolor: function (n) {
+        return this._isa(n, tree.Color);
+    },
+    isnumber: function (n) {
+        return this._isa(n, tree.Dimension);
+    },
+    isstring: function (n) {
+        return this._isa(n, tree.Quoted);
+    },
+    iskeyword: function (n) {
+        return this._isa(n, tree.Keyword);
+    },
+    isurl: function (n) {
+        return this._isa(n, tree.URL);
+    },
+    ispixel: function (n) {
+        return (n instanceof tree.Dimension) && n.unit === 'px' ? tree.True : tree.False;
+    },
+    ispercentage: function (n) {
+        return (n instanceof tree.Dimension) && n.unit === '%' ? tree.True : tree.False;
+    },
+    isem: function (n) {
+        return (n instanceof tree.Dimension) && n.unit === 'em' ? tree.True : tree.False;
+    },
+    _isa: function (n, Type) {
+        return (n instanceof Type) ? tree.True : tree.False;
     }
 };
 
@@ -171,4 +225,4 @@ function clamp(val) {
     return Math.min(1, Math.max(0, val));
 }
 
-})(require('less/tree'));
+})(require('./tree'));

data/lib/less/js/lib/less/index.js

@@ -1,14 +1,12 @@
 var path = require('path'),
-    sys = require('sys'),
+    sys = require('util'),
     fs = require('fs');
 
-require.paths.unshift(path.join(__dirname, '..'));
-
 var less = {
-    version: [1, 1, 3],
-    Parser: require('less/parser').Parser,
-    importer: require('less/parser').importer,
-    tree: require('less/tree'),
+    version: [1, 3, 0],
+    Parser: require('./parser').Parser,
+    importer: require('./parser').importer,
+    tree: require('./tree'),
     render: function (input, options, callback) {
         options = options || {};
 
@@ -16,12 +14,12 @@ var less = {
             callback = options, options = {};
         }
 
-        var parser = new(this.Parser)(options),
+        var parser = new(less.Parser)(options),
             ee;
 
         if (callback) {
             parser.parse(input, function (e, root) {
-                callback(e, root.toCSS(options));
+                callback(e, root && root.toCSS && root.toCSS(options));
             });
         } else {
             ee = new(require('events').EventEmitter);
@@ -36,15 +34,18 @@ var less = {
         }
     },
     writeError: function (ctx, options) {
+        options = options || {};
+
         var message = "";
         var extract = ctx.extract;
         var error = [];
-
-        options = options || {};
+        var stylize = options.color ? less.stylize : function (str) { return str };
 
         if (options.silent) { return }
 
-        if (!ctx.index) {
+        if (ctx.stack) { return sys.error(stylize(ctx.stack, 'red')) }
+
+        if (!ctx.hasOwnProperty('index')) {
             return sys.error(ctx.stack || ctx.message);
         }
 
@@ -52,17 +53,20 @@ var less = {
             error.push(stylize((ctx.line - 1) + ' ' + extract[0], 'grey'));
         }
 
-        error.push(ctx.line + ' ' + extract[1].slice(0, ctx.column)
-                            + stylize(stylize(extract[1][ctx.column], 'bold')
-                            + extract[1].slice(ctx.column + 1), 'yellow'));
+        if (extract[1]) {
+            error.push(ctx.line + ' ' + extract[1].slice(0, ctx.column)
+                                + stylize(stylize(stylize(extract[1][ctx.column], 'bold')
+                                + extract[1].slice(ctx.column + 1), 'red'), 'inverse'));
+        }
 
         if (typeof(extract[2]) === 'string') {
             error.push(stylize((ctx.line + 1) + ' ' + extract[2], 'grey'));
         }
         error = error.join('\n') + '\033[0m\n';
 
-        message += stylize(ctx.message, 'red');
-        ctx.filename && (message += stylize(' in ', 'red') + ctx.filename);
+        message += stylize(ctx.type + 'Error: ' + ctx.message, 'red');
+        ctx.filename && (message += stylize(' in ', 'red') + ctx.filename +
+                stylize(':' + ctx.line + ':' + ctx.column, 'grey'));
 
         sys.error(message, error);
 
@@ -70,22 +74,25 @@ var less = {
             sys.error(stylize('from ', 'red')       + (ctx.filename || ''));
             sys.error(stylize(ctx.callLine, 'grey') + ' ' + ctx.callExtract);
         }
-        if (ctx.stack) { sys.error(stylize(ctx.stack, 'red')) }
     }
 };
 
-['color',    'directive', 'operation',  'dimension',
- 'keyword',  'variable',  'ruleset',    'element',
- 'selector', 'quoted',    'expression', 'rule',
- 'call',     'url',       'alpha',      'import',
- 'mixin',    'comment',   'anonymous',  'value', 'javascript'
+['color',      'directive',  'operation',  'dimension',
+ 'keyword',    'variable',   'ruleset',    'element',
+ 'selector',   'quoted',     'expression', 'rule',
+ 'call',       'url',        'alpha',      'import',
+ 'mixin',      'comment',    'anonymous',  'value',
+ 'javascript', 'assignment', 'condition',  'paren',
+ 'media'
 ].forEach(function (n) {
-    require(path.join('less', 'tree', n));
+    require('./tree/' + n);
 });
 
-less.Parser.importer = function (file, paths, callback) {
+less.Parser.importer = function (file, paths, callback, env) {
     var pathname;
 
+    // TODO: Undo this at some point,
+    // or use different approach.
     paths.unshift('.');
 
     for (var i = 0; i < paths.length; i++) {
@@ -100,23 +107,26 @@ less.Parser.importer = function (file, paths, callback) {
 
     if (pathname) {
         fs.readFile(pathname, 'utf-8', function(e, data) {
-          if (e) sys.error(e);
-
-          new(less.Parser)({
-              paths: [path.dirname(pathname)],
-              filename: pathname
-          }).parse(data, function (e, root) {
-              if (e) less.writeError(e);
-              callback(root);
-          });
+            if (e) return callback(e);
+
+            new(less.Parser)({
+                paths: [path.dirname(pathname)].concat(paths),
+                filename: pathname
+            }).parse(data, function (e, root) {
+                callback(e, root, data);
+            });
         });
     } else {
-        sys.error("file '" + file + "' wasn't found.\n");
-        process.exit(1);
+        if (typeof(env.errback) === "function") {
+            env.errback(file, paths, callback);
+        } else {
+            callback({ type: 'File', message: "'" + file + "' wasn't found.\n" });
+        }
     }
 }
 
-require('less/functions');
+require('./functions');
+require('./colors');
 
 for (var k in less) { exports[k] = less[k] }
 
@@ -134,4 +144,5 @@ function stylize(str, style) {
     return '\033[' + styles[style][0] + 'm' + str +
            '\033[' + styles[style][1] + 'm';
 }
+less.stylize = stylize;