index.js

/*!
 * jshtml
 * Copyright(c) 2011 Elmer Bulthuis <elmerbulthuis@gmail.com>
 * MIT Licensed
 */

var fs = require('fs');
var assert = require('assert');
var JsHtmlParser = require('./lib/jshtml/Parser');
var tools = require('./lib/tools');
var sjs = require('sjs');

var cache = {};

function compile(template, options) {

	return function(locals)	{
		var buffer = '';
		var atEnd = false;
	
		function write()	{
			var argumentCount = arguments.length;
			for(var argumentIndex = 0; argumentIndex < argumentCount; argumentIndex++){
				var argument = arguments[argumentIndex];
				buffer += tools.str(argument);
			}
		}
		function end()	{
			write.apply(this, arguments);
			atEnd = true;
		}
		
		compileAsync(template, options).call(this, write, end, locals);
 
		assert.ok(atEnd, 'not ended');
		
		return buffer;
	}
}

function render(template, options) {
	var options = tools.extend({}, options);
	var fn = options.filename 
		? (cache[options.filename] || (cache[options.filename] = compile(template, options)))
		: compile(template, options)
		;
	return fn.call(options.scope, options.locals || {});
}



var cacheAsync = {};

function compileAsync(template, options) {
	var fnSrc = '';
	var parser = new JsHtmlParser(function(data) {
//console.log(data);
		fnSrc += data;
	}, options);
	parser.end(template);

	if(options.with)	{
		fnSrc = '{' + fnSrc + '}';
		var contextList = Array.isArray()
		? options.with
		: [options.with]
		;
		contextList.forEach(function(context){
			fnSrc = 'with(' + context + ')' + fnSrc;
		});
	}

	console.log(fnSrc);

	var fn = new Function('write', 'end', 'tag', 'writePartial', 'writeBody', 'tools', 'locals', sjs.parse(fnSrc, options));

	return function(writeCallback, endCallback, locals) {

		function tag(tagName) {
			var tagAttributeSetList = [];
			var tagContentList = [];
			var argumentCount = arguments.length;
			var hasContent = false;
			for(var argumentIndex = 1; argumentIndex < argumentCount; argumentIndex++){
				var argument = arguments[argumentIndex];
				switch(typeof argument) {
					case 'object':
					tagAttributeSetList.push(argument);
					break;

					default:
					hasContent = true;
					tagContentList.push(argument);
				}
			}

			writeCallback.call(this, '<', tagName);
			tagAttributeSetList.forEach(function(tagAttributeSet) {
				writeCallback.call(this, ' ', tools.htmlAttributeEncode(tagAttributeSet));
			});
			if(hasContent) {
				writeCallback.call(this, '>');

				tagContentList.forEach(function(tagContent) {
					switch(typeof tagContent) {
						case 'function':
						tagContent();
						break;

						default:
						writeCallback.call(this, tools.htmlLiteralEncode(tagContent));
					}
				});

				writeCallback.call(this, '</', tagName, '>');
			}
			else{
				writeCallback.call(this, ' />');
			}
		}

		function writePartial() {
			writeCallback.call(this, locals.partial.apply(this, arguments));
		}

		function writeBody() {
			writeCallback.call(this, locals.body);
		}

		fn.call(this, writeCallback, endCallback, tag, writePartial, writeBody, tools, locals);
	};
}

function renderAsync(writeCallback, endCallback, template, options) {
	var options = tools.extend({}, options);
	var fn = options.filename 
		? (cacheAsync[options.filename] || (cacheAsync[options.filename] = compileAsync(template, options)))
		: compileAsync(template, options)
		;
	fn.call(options.scope, writeCallback, endCallback, options.locals || {});
}


//require
require.extensions['.jshtml'] = function(module, fileName) {
    var template = fs.readFileSync(fileName, 'utf-8');
	module.exports = compileAsync(template, {});
}

//exports
exports.compileAsync = compileAsync;
exports.renderAsync = renderAsync;
exports.compile = compile;
exports.render = render;