mirror of
https://github.com/less/less.js.git
synced 2026-01-25 15:18:03 -05:00
253 lines
8.5 KiB
JavaScript
253 lines
8.5 KiB
JavaScript
var path = require('path'),
|
|
url = require('url'),
|
|
request,
|
|
fs = require('fs');
|
|
|
|
var less = {
|
|
version: [1, 7, 0],
|
|
Parser: require('./parser').Parser,
|
|
tree: require('./tree'),
|
|
render: function (input, options, callback) {
|
|
options = options || {};
|
|
|
|
if (typeof(options) === 'function') {
|
|
callback = options;
|
|
options = {};
|
|
}
|
|
|
|
var parser = new(less.Parser)(options),
|
|
ee;
|
|
|
|
if (callback) {
|
|
parser.parse(input, function (e, root) {
|
|
if (e) { callback(e); return; }
|
|
var css;
|
|
try {
|
|
css = root && root.toCSS && root.toCSS(options);
|
|
}
|
|
catch (err) { callback(err); return; }
|
|
callback(null, css);
|
|
});
|
|
} else {
|
|
ee = new (require('events').EventEmitter)();
|
|
|
|
process.nextTick(function () {
|
|
parser.parse(input, function (e, root) {
|
|
if (e) { return ee.emit('error', e); }
|
|
try { ee.emit('success', root.toCSS(options)); }
|
|
catch (err) { ee.emit('error', err); }
|
|
});
|
|
});
|
|
return ee;
|
|
}
|
|
},
|
|
formatError: function(ctx, options) {
|
|
options = options || {};
|
|
|
|
var message = "";
|
|
var extract = ctx.extract;
|
|
var error = [];
|
|
var stylize = options.color ? require('./lessc_helper').stylize : function (str) { return str; };
|
|
|
|
// only output a stack if it isn't a less error
|
|
if (ctx.stack && !ctx.type) { return stylize(ctx.stack, 'red'); }
|
|
|
|
if (!ctx.hasOwnProperty('index') || !extract) {
|
|
return ctx.stack || ctx.message;
|
|
}
|
|
|
|
if (typeof(extract[0]) === 'string') {
|
|
error.push(stylize((ctx.line - 1) + ' ' + extract[0], 'grey'));
|
|
}
|
|
|
|
if (typeof(extract[1]) === 'string') {
|
|
var errorTxt = ctx.line + ' ';
|
|
if (extract[1]) {
|
|
errorTxt += extract[1].slice(0, ctx.column) +
|
|
stylize(stylize(stylize(extract[1][ctx.column], 'bold') +
|
|
extract[1].slice(ctx.column + 1), 'red'), 'inverse');
|
|
}
|
|
error.push(errorTxt);
|
|
}
|
|
|
|
if (typeof(extract[2]) === 'string') {
|
|
error.push(stylize((ctx.line + 1) + ' ' + extract[2], 'grey'));
|
|
}
|
|
error = error.join('\n') + stylize('', 'reset') + '\n';
|
|
|
|
message += stylize(ctx.type + 'Error: ' + ctx.message, 'red');
|
|
if (ctx.filename) {
|
|
message += stylize(' in ', 'red') + ctx.filename +
|
|
stylize(' on line ' + ctx.line + ', column ' + (ctx.column + 1) + ':', 'grey');
|
|
}
|
|
|
|
message += '\n' + error;
|
|
|
|
if (ctx.callLine) {
|
|
message += stylize('from ', 'red') + (ctx.filename || '') + '/n';
|
|
message += stylize(ctx.callLine, 'grey') + ' ' + ctx.callExtract + '/n';
|
|
}
|
|
|
|
return message;
|
|
},
|
|
writeError: function (ctx, options) {
|
|
options = options || {};
|
|
if (options.silent) { return; }
|
|
console.error(less.formatError(ctx, options));
|
|
}
|
|
};
|
|
|
|
require('./tree/color');
|
|
require('./tree/directive');
|
|
require('./tree/detached-ruleset');
|
|
require('./tree/operation');
|
|
require('./tree/dimension');
|
|
require('./tree/keyword');
|
|
require('./tree/variable');
|
|
require('./tree/ruleset');
|
|
require('./tree/element');
|
|
require('./tree/selector');
|
|
require('./tree/quoted');
|
|
require('./tree/expression');
|
|
require('./tree/rule');
|
|
require('./tree/call');
|
|
require('./tree/url');
|
|
require('./tree/alpha');
|
|
require('./tree/import');
|
|
require('./tree/mixin');
|
|
require('./tree/comment');
|
|
require('./tree/anonymous');
|
|
require('./tree/value');
|
|
require('./tree/javascript');
|
|
require('./tree/assignment');
|
|
require('./tree/condition');
|
|
require('./tree/paren');
|
|
require('./tree/media');
|
|
require('./tree/unicode-descriptor');
|
|
require('./tree/negative');
|
|
require('./tree/extend');
|
|
require('./tree/ruleset-call');
|
|
|
|
|
|
var isUrlRe = /^(?:https?:)?\/\//i;
|
|
|
|
less.Parser.fileLoader = function (file, currentFileInfo, callback, env) {
|
|
var pathname, dirname, data,
|
|
newFileInfo = {
|
|
relativeUrls: env.relativeUrls,
|
|
entryPath: currentFileInfo.entryPath,
|
|
rootpath: currentFileInfo.rootpath,
|
|
rootFilename: currentFileInfo.rootFilename
|
|
};
|
|
|
|
function handleDataAndCallCallback(data) {
|
|
var j = file.lastIndexOf('/');
|
|
|
|
// Pass on an updated rootpath if path of imported file is relative and file
|
|
// is in a (sub|sup) directory
|
|
//
|
|
// Examples:
|
|
// - If path of imported file is 'module/nav/nav.less' and rootpath is 'less/',
|
|
// then rootpath should become 'less/module/nav/'
|
|
// - If path of imported file is '../mixins.less' and rootpath is 'less/',
|
|
// then rootpath should become 'less/../'
|
|
if(newFileInfo.relativeUrls && !/^(?:[a-z-]+:|\/)/.test(file) && j != -1) {
|
|
var relativeSubDirectory = file.slice(0, j+1);
|
|
newFileInfo.rootpath = newFileInfo.rootpath + relativeSubDirectory; // append (sub|sup) directory path of imported file
|
|
}
|
|
newFileInfo.currentDirectory = pathname.replace(/[^\\\/]*$/, "");
|
|
newFileInfo.filename = pathname;
|
|
|
|
callback(null, data, pathname, newFileInfo);
|
|
}
|
|
|
|
var isUrl = isUrlRe.test( file );
|
|
if (isUrl || isUrlRe.test(currentFileInfo.currentDirectory)) {
|
|
if (request === undefined) {
|
|
try { request = require('request'); }
|
|
catch(e) { request = null; }
|
|
}
|
|
if (!request) {
|
|
callback({ type: 'File', message: "optional dependency 'request' required to import over http(s)\n" });
|
|
return;
|
|
}
|
|
|
|
var urlStr = isUrl ? file : url.resolve(currentFileInfo.currentDirectory, file),
|
|
urlObj = url.parse(urlStr);
|
|
|
|
request.get({uri: urlStr, strictSSL: !env.insecure }, function (error, res, body) {
|
|
if (res.statusCode === 404) {
|
|
callback({ type: 'File', message: "resource '" + urlStr + "' was not found\n" });
|
|
return;
|
|
}
|
|
if (!body) {
|
|
console.error( 'Warning: Empty body (HTTP '+ res.statusCode + ') returned by "' + urlStr +'"' );
|
|
}
|
|
if (error) {
|
|
callback({ type: 'File', message: "resource '" + urlStr + "' gave this Error:\n "+ error +"\n" });
|
|
}
|
|
pathname = urlStr;
|
|
dirname = urlObj.protocol +'//'+ urlObj.host + urlObj.pathname.replace(/[^\/]*$/, '');
|
|
handleDataAndCallCallback(body);
|
|
});
|
|
} else {
|
|
|
|
var paths = [currentFileInfo.currentDirectory].concat(env.paths);
|
|
paths.push('.');
|
|
|
|
if (env.syncImport) {
|
|
for (var i = 0; i < paths.length; i++) {
|
|
try {
|
|
pathname = path.join(paths[i], file);
|
|
fs.statSync(pathname);
|
|
break;
|
|
} catch (e) {
|
|
pathname = null;
|
|
}
|
|
}
|
|
|
|
if (!pathname) {
|
|
callback({ type: 'File', message: "'" + file + "' wasn't found" });
|
|
return;
|
|
}
|
|
|
|
try {
|
|
data = fs.readFileSync(pathname, 'utf-8');
|
|
handleDataAndCallCallback(data);
|
|
} catch (e) {
|
|
callback(e);
|
|
}
|
|
} else {
|
|
(function tryPathIndex(i) {
|
|
if (i < paths.length) {
|
|
pathname = path.join(paths[i], file);
|
|
fs.stat(pathname, function (err) {
|
|
if (err) {
|
|
tryPathIndex(i + 1);
|
|
} else {
|
|
fs.readFile(pathname, 'utf-8', function(e, data) {
|
|
if (e) { callback(e); }
|
|
handleDataAndCallCallback(data);
|
|
});
|
|
}
|
|
});
|
|
} else {
|
|
callback({ type: 'File', message: "'" + file + "' wasn't found" });
|
|
}
|
|
}(0));
|
|
}
|
|
}
|
|
};
|
|
|
|
require('./env');
|
|
require('./functions');
|
|
require('./colors');
|
|
require('./visitor.js');
|
|
require('./import-visitor.js');
|
|
require('./extend-visitor.js');
|
|
require('./join-selector-visitor.js');
|
|
require('./to-css-visitor.js');
|
|
require('./source-map-output.js');
|
|
|
|
for (var k in less) { if (less.hasOwnProperty(k)) { exports[k] = less[k]; }}
|