162 lines
4.2 KiB
JavaScript
162 lines
4.2 KiB
JavaScript
'use strict';
|
|
|
|
var sourceMapGenerator = require('./sourceMap');
|
|
var hasOwnProperty = Object.prototype.hasOwnProperty;
|
|
var noop = function() {};
|
|
|
|
function each(processChunk, node) {
|
|
var list = node.children;
|
|
var cursor = list.head;
|
|
|
|
while (cursor !== null) {
|
|
this.generate(processChunk, cursor.data, cursor, list);
|
|
cursor = cursor.next;
|
|
}
|
|
}
|
|
|
|
function eachComma(processChunk, node) {
|
|
var list = node.children;
|
|
var cursor = list.head;
|
|
|
|
while (cursor !== null) {
|
|
if (cursor.prev) {
|
|
processChunk(',');
|
|
}
|
|
|
|
this.generate(processChunk, cursor.data, cursor, list);
|
|
cursor = cursor.next;
|
|
}
|
|
}
|
|
|
|
function createGenerator(types) {
|
|
var context = {
|
|
generate: function(processChunk, node, item, list) {
|
|
if (hasOwnProperty.call(types, node.type)) {
|
|
types[node.type].call(this, processChunk, node, item, list);
|
|
} else {
|
|
throw new Error('Unknown node type: ' + node.type);
|
|
}
|
|
},
|
|
each: each,
|
|
eachComma: eachComma
|
|
};
|
|
|
|
return function(node, fn) {
|
|
if (typeof fn !== 'function') {
|
|
// default generator concats all chunks in a single string
|
|
var buffer = [];
|
|
context.generate(function(chunk) {
|
|
buffer.push(chunk);
|
|
}, node);
|
|
return buffer.join('');
|
|
}
|
|
context.generate(fn, node);
|
|
};
|
|
}
|
|
|
|
function createMarkupGenerator(types) {
|
|
var context = {
|
|
generate: function(processChunk, node, item, list) {
|
|
if (hasOwnProperty.call(types, node.type)) {
|
|
var nodeBuffer = [];
|
|
types[node.type].call(this, function(chunk) {
|
|
nodeBuffer.push(chunk);
|
|
}, node, item, list);
|
|
processChunk({
|
|
node: node,
|
|
value: nodeBuffer
|
|
});
|
|
} else {
|
|
throw new Error('Unknown node type: ' + node.type);
|
|
}
|
|
},
|
|
each: each,
|
|
eachComma: eachComma
|
|
};
|
|
|
|
return function(node, enter, leave) {
|
|
function updatePos(str) {
|
|
for (var i = 0; i < str.length; i++) {
|
|
if (str.charCodeAt(i) === 10) { // \n
|
|
line++;
|
|
column = 0;
|
|
} else {
|
|
column++;
|
|
}
|
|
}
|
|
|
|
return str;
|
|
}
|
|
|
|
function walk(node, buffer) {
|
|
var value = node.value;
|
|
|
|
enter(node.node, buffer, line, column);
|
|
|
|
if (typeof value === 'string') {
|
|
buffer += updatePos(value);
|
|
} else {
|
|
for (var i = 0; i < value.length; i++) {
|
|
if (typeof value[i] === 'string') {
|
|
buffer += updatePos(value[i]);
|
|
} else {
|
|
buffer = walk(value[i], buffer);
|
|
}
|
|
}
|
|
}
|
|
|
|
leave(node.node, buffer, line, column);
|
|
|
|
return buffer;
|
|
}
|
|
|
|
if (typeof enter !== 'function') {
|
|
enter = noop;
|
|
}
|
|
if (typeof leave !== 'function') {
|
|
leave = noop;
|
|
}
|
|
|
|
var buffer = [];
|
|
var line = 1;
|
|
var column = 0;
|
|
|
|
context.generate(function() {
|
|
buffer.push.apply(buffer, arguments);
|
|
}, node);
|
|
|
|
return walk(buffer[0], '');
|
|
};
|
|
}
|
|
|
|
function getTypesFromConfig(config) {
|
|
var types = {};
|
|
|
|
if (config.node) {
|
|
for (var name in config.node) {
|
|
var nodeType = config.node[name];
|
|
|
|
types[name] = nodeType.generate;
|
|
}
|
|
}
|
|
|
|
return types;
|
|
}
|
|
|
|
module.exports = function(config) {
|
|
var types = getTypesFromConfig(config);
|
|
var markupGenerator = createMarkupGenerator(types);
|
|
|
|
return {
|
|
translate: createGenerator(types),
|
|
translateWithSourceMap: function(node) {
|
|
return sourceMapGenerator(markupGenerator, node);
|
|
},
|
|
translateMarkup: markupGenerator
|
|
};
|
|
};
|
|
|
|
module.exports.createGenerator = createGenerator;
|
|
module.exports.createMarkupGenerator = createMarkupGenerator;
|
|
module.exports.sourceMap = require('./sourceMap');
|