function benchmark() {
var dust = require('dustjs-linkedin');
var fs = require('fs');
var layout, howItWorks, html;
layout = fs.readFileSync('/data/Framework-Tests/node/layout.dustc', 'utf8');
howItWorks = fs.readFileSync('/data/Framework-Tests/node/howItWorks.dustc', 'utf8');
// console.log(layout);
// console.log(howItWorks);
//var compiledLayout = dust.compile(layout, 'layout');
//var compiledHowItWorks = dust.compile(howItWorks, 'howItWorks');
dust.loadSource(layout);
dust.loadSource(howItWorks);
dust.render('howItWorks.html', {host: 'justin.flipkey.net'}, function(err, output) {
if(err) {
console.log(err);
}
html = output;
});
this.res.end(html);
}
app.get(this.urlNamespace + '/sandbox/:testid', function(request, response) {
var tests = exec.testgroup.tests,
testId = request.params.testid,
test = tests[testId],
fixtureContent,
fixtureId,
fixturePartialReference,
templateData,
harnessTemplate,
harnessTemplateId;
// Check if testid is valid and in the currently loaded testgroup
if (!test || !test.harnessTemplate) {
return response.status(404).json(
{ error: 'TestId ' + testId + ' does not exist' }
);
}
// Load the test fixture (ie. @venus-fixture) content via Dust. Then,
// modify fixtureTemplate by finding the closing 'body' tag, and prepending
// it with a reference to the test fixture, using Dust partials.
fixtureContent = test.annotations[testcase.annotation.VENUS_FIXTURE];
fixtureId = 'fixture_' + testId;
dust.loadSource(dust.compile(fixtureContent, fixtureId));
fixturePartialReference = '<body>{>' + fixtureId + '/}';
harnessTemplate = test.harnessTemplate;
harnessTemplate = harnessTemplate.replace(/<body>/,
fixturePartialReference);
// Set template data, and render the Dust template
harnessTemplateId = 'harness_template_' + testId;
dust.loadSource(dust.compile(harnessTemplate, harnessTemplateId));
templateData = {
scriptIncludes : test.url.includes.slice(0, -1),
testcaseFile : _.last(test.url.includes),
testId : testId,
host : host,
port : port
};
dust.render(harnessTemplateId, templateData, function(err, out) {
if(err) {
response.status(500).json(
{ error: 'Harness template for test ' + testId + ' failed to render' }
);
}
response.send(out);
});
});
templates.forEach(function(template) {
console.log('compiling', template);
var compiled = dust.compile(e[template], template);
if (compiled) {
dust.loadSource(compiled);
}
});
app.get(this.urlNamespace + '/:testid', function(request, response) {
var tests = exec.testgroup.tests,
testId = request.params.testid,
test = tests[testId],
harnessTemplate,
harnessTemplateId,
templateData;
// Check if testid is valid and in the currently loaded testgroup
if (!test) {
return response.status(404).json(
{ error: 'TestId ' + testId + ' does not exist' }
);
}
// Set template data, and render the Dust template
templateData = {
postTestResultsUrl: exec.urlNamespace + '/results/' + testId,
testSandboxUrl: exec.urlNamespace + '/sandbox/' + testId,
testId: testId
};
harnessTemplate = exec.config.loadTemplate('default');
harnessTemplateId = 'harness-' + testId;
dust.loadSource(dust.compile(harnessTemplate, harnessTemplateId));
dust.render(harnessTemplateId, templateData, function(err, out) {
if (err) {
response.status(500).json({
error: 'Cannot render harness for test ' + testId
});
}
response.send(out);
});
});
t.test('do nested helpers work?', function (t) {
dustjs.loadSource(dustjs.compile('{@useContent bundle="test"}{@useContent bundle="test2"}{@message key="hello" /}{/useContent}{/useContent}', 'nested'));
dustjs.render('nested', dustjs.context({}, { option: true }), function (err, out) {
t.equal(out, "this morning!");
t.end();
});
});
// check final
function checkfinal() {
if (++gnum == gout.length) {
var model = {
"dtime": new Date() ,
"report": gout
};
if (gfmt && gfmt != 'html') {
output(JSON.stringify(model));
}
else {
var tmpl = templ;
if (gtmpl) {
try {
tmpl = fs.readFileSync( gtmpl, 'utf8');
}
catch(e) {
except("Template read exception:" + e);
}
}
var compiled = dust.compile(tmpl, "intro");
dust.loadSource(compiled);
dust.render("intro", model, function(err, out) {
if (err) except(err);
else output(out);
});
}
}
}
t.test('do empty helpers work?', function (t) {
var tmpl = dustjs.loadSource(dustjs.compile('!{@useContent bundle="test" /}!'));
dustjs.render(tmpl, dustjs.context({}, { option: true }), function (err, out) {
t.equal(out, "!!");
t.end();
});
});
test('bundle annotation', function (t) {
helper(function(context, bundle, cont) {
t.same(context.options.option, true);
t.pass('loader got called');
if (bundle == 'test') {
cont(null, {"hello": "world"});
} else {
cont(null, {"hello": "this morning!"});
}
}).registerWith(dustjs);
messages.registerWith(dustjs);
dustjs.helpers.wompwomp = function (chunk, context, blocks, params) {
return chunk.map(function (chunk) {
chunk.end(context.get('intl.bundle'));
});
}
dustjs.loadSource(dustjs.compile('{@useContent bundle="test"}{@wompwomp/}{/useContent}', 'test'));
dustjs.render('test', dustjs.context({}, { option: true }), function (err, out) {
t.error(err);
t.equal(out, "test");
t.end();
});
});
"/render" : function(request, response){
var body = response.body;
var errorText;
if(body && body.id && body.compiledMarkup){
dust.loadSource(body.compiledMarkup);
if(body.data){
try{
body.data = JSON.parse(body.data);
}catch(e){
resolveError(response, e);
}
}
dust.render(body.id, body.data, function(error, html){
if(error){
resolveError(response, error);
}else{
response.writeHead(200, mimeMapper.html);
response.end(html);
}
});
}else{
errorText = "파라메터가 올바르지 않습니다.";
if(!body){
errorText += " 파라메터 자체가 존재하지 않습니다.";
}else{
errorText = errorText + "id와 compiledMarkup은 반드시 존재해야 합니다.";
errorText = errorText + " id : " + body.id + ", compiledMarkup : " + body.compiledMarkup
}
response.writeHead(400, mimeMapper.text);
response.end(errorText);
}
}
'dust': function(file, data, callback, context) {
var inputTemplate = file.readAsString();
var templateName = file.getName();
var compiled;
try
{
compiled = dust.compile(inputTemplate, templateName, false);
dust.loadSource(compiled);
}
catch(e) {
throw new Error('The content of "' + file.getAbsolutePath() + '" is not a valid Dust template. Exception: ' + e);
}
try {
dust.render(
templateName,
data,
function(err, out) {
callback(err, out);
});
}
catch(e) {
callback(e);
}
},
_.each (_templates, function (_descriptor, _identifier) {
var _path = path.join (configuration.renderersRoot, _identifier + ".dust");
var _source = fs.readFileSync (_path, {encoding : "utf-8"});
var _source = dust.compile (_source, _identifier);
dust.loadSource (_source);
reloader.watchFile (_path);
});
Application.prototype.load_views = function ( view_path ) {
if ( !view_path && this.views_loaded && this._config.cache_views !== false ) return true;
view_path = view_path || '';
var full_view_path = path.join( this.path_to_views, view_path );
var stats = null;
try {
stats = fs.statSync( full_view_path );
}
catch(e) {
this.log( 'Views folder is not found. Skip loading views', 'warning' );
}
if ( stats && stats.isDirectory() ) fs.readdirSync( full_view_path ).forEach( function( file ) {
this.load_views( path.join( view_path, file ) );
}, this );
else if ( stats && stats.isFile() && this._views_mtime[ view_path ] != stats.mtime.getTime() ) {
this.log( 'Load view `%s`'.format( view_path ), 'trace' );
var template = fs.readFileSync( full_view_path, 'utf8' );
var compiled = dust.compile( template, view_path );
this._views_mtime[ view_path ] = stats.mtime.getTime();
dust.loadSource( compiled );
}
if ( !view_path ) {
this.views_loaded = true;
if ( stats ) this.log( 'Views are loaded', 'info' );
this.emit( 'views_are_loaded' );
}
};
app.get("/", function(req, res) {
// TODO: cache index in prod VS no cache in dev
if(!compiledIndexPage) {
compiledIndexPage = dust.compile(fs.readFileSync(__dirname + "/static/index.dust", "utf8"), "index");
dust.loadSource(compiledIndexPage);
}
var data = {
title: process.env.ARKHAIOS_TITLE || "Arkhaios",
forkMe: process.env.ARKHAIOS_FORK_ME
}
if(process.env.ARKHAIOS_GA_UA && process.env.ARKHAIOS_GA_HOST) {
data.googleAnalytics= {
UA: process.env.ARKHAIOS_GA_UA,
host: process.env.ARKHAIOS_GA_HOST
}
}
dust.render("index", data, function(err, rendered) {
if(err) {
logger.error(err)
res.send({reason: "non public"}, 500);
} else {
// res.contentType("text/html");
res.send(rendered);
}
})
})
function runit(tmpl, model, callback) {
var compiled = dust.compile(tmpl, "test");
dust.loadSource(compiled);
var out = dust.render("test", model, function (err, result) {
return callback(null, result);
});
}
dust.render(compileid, data.message.Parameters, function (errRendered, outRendered) {
if (errRendered) {
logger.error("Error in rendering " + errRendered);
}
else {
var renderedTemplate = "";
var juiceOptions = {
applyStyleTags: true
}
if (resPickTemp.styles.length > 0) {
for (var i = 0; i < resPickTemp.styles.length; i++) {
if (i == 0) {
renderedTemplate = outRendered;
}
//console.log(resPickTemp.styles[i].content);
logger.info("Rendering is success " + resPickTemp.styles[i].content);
renderedTemplate = juice.inlineContent(renderedTemplate, resPickTemp.styles[i].content, juiceOptions);
if (i == (resPickTemp.styles.length - 1)) {
if (resPickTemp.filetype.toLowerCase() == 'html') {
mailOptions.html = renderedTemplate;
} else {
mailOptions.text = renderedTemplate;
}
}
}
}
else {
console.log("Rendering Done");
if (resPickTemp.filetype.toLowerCase() == 'html') {
mailOptions.html = outRendered;
} else {
mailOptions.text = outRendered;
}
//SendMail(mailOptions, data);
}
if (resPickTemp.content.subject) {
var compilesubid = uuid.v4();
var compiledsub = dust.compile(resPickTemp.content.subject, compilesubid);
dust.loadSource(compiledsub);
dust.render(compilesubid, data.message.Parameters, function (errsubRendered, outsubRendered) {
mailOptions.subject = outsubRendered;
SendMail(mailOptions, data);
});
} else {
SendMail(mailOptions, data);
}
}
});
/* Load template from filesystem */
function do_load(file, name) {
var name = name || file;
if(!file) throw new Error("file not defined");
var c = do_compile(file, name);
dust.loadSource(c);
if(_debug) console.log("[dustfs] [" + name + "] Template loaded: " + file);
return c;
}
fs.readFile(path.join(__dirname, 'emailified', f + '.html'), function(err, raw) {
if (err) {
throw err;
}
var compiled = dust.compile(raw.toString(), 'mail/' + f);
dust.loadSource(compiled);
});
t.test('does loader get called?', function (t) {
dustjs.loadSource(dustjs.compile('{@useContent bundle="test"}{@message key="hello" /}{/useContent}', 'test'));
dustjs.render('test', dustjs.context({}, { option: true }), function (err, out) {
t.equal(out, "world");
t.pass("loader is called");
t.end();
});
});
var loadCustom = function(type, engine) {
type = 'custom' + type;
for (var k in engine[type + 's']) {
var name = type + '_' + k;
var compiled = dust.compile(engine[type + 's'][k], name);
if (compiled) {
dust.loadSource(compiled);
}
}
};
plugin.compile(content, 'dirs/dir/template.dust', function(error, data) {
expect(error).not.to.be.ok;
dust.loadSource(data);
dust.render('template', {'name': 'Batman'}, function(error, output) {
expect(error).not.to.be.ok;
expect(output).to.equal(expected);
done();
});
});
Bar.prototype.loadTemplate = function(data, status, xhr) {
var self = this;
console.log('loadTemplate');
this.compiledTemplate = dust.compile(data, 'bar-chart');
dust.loadSource(this.compiledTemplate);
if (this.data) {
this.create(this.data);
}
};
fs.readdirSync(directory).forEach((t) => {
if (t.match(/\.dust$/)) {
const label = path.basename(t, '.dust');
// THESE GO INTO THE DUST MODULE and OUR TEMPLATE NAMES COLLIDE.
// so you can't (safely) generate multiple languages in parallel.
const compiled = dust.compile(fs.readFileSync(path.join(directory, t), 'utf8'), label);
dust.loadSource(compiled);
dusts[label] = 1;
}
});
partials.forEach(function(v, i) {
var contents = grunt.file.read(v);
var name = path.basename(v, path.extname(v));
if(me.options.templateEngine === 'handlebars') {
Handlebars.registerPartial(name, contents);
} else if(me.options.templateEngine === 'dust') {
var templateName = name;
var source = dust.compile(contents, templateName);
dust.loadSource(source);
}
});
'dust': function () {
var file = this,
name = path.join(this.params.parent || '', this.params.path.replace(/^templates(\/|\\|$)/, ''), path.basename(this.basename, '.dust')),
template,
moduleRx = /\{@my([^\}]*)\}/g,
moduleNameRx = /module="([^"]*)"/,
BOMcheck = /^\uFEFF/,
modules;
if (this.content.match(BOMcheck)) {
this.errors = [
{
reason: 'BOM mark detected!',
file: this.path,
line: 1,
character: 1
}
];
this.content = this.content.replace(BOMcheck, '');
}
name = name.replace(/\\/g, '/');
this.modules = [];
// проверяем, подключаются ли в шаблоне модули
modules = this.content.match(moduleRx);
if (modules) {
// если подключаются, находим их названия
modules.forEach(function (module) {
module = module.match(moduleNameRx)[1];
if (module && file.modules.indexOf(module) === -1) {
file.modules.push(module);
}
});
}
try {
template = dust.compile(this.content, name);
dust.loadSource(template);
} catch (e) {
sys.log('Dust syntax error\n\tFile: ' + this.path);
sys.puts('\t' + e.message);
throw e;
}
this.params.type = 'js';
return template;
}
function tpl(tpl, data)
{
var compiledTemplate = dust.compile(tpl, tpl);
dust.loadSource(compiledTemplate);
var output = '';
dust.render(tpl, data, function(err, str) {
if (err) {
throw err;
}
output = str;
});
return output;
}
dust.onLoad(fullname, function(err, src) {
if (err)
return chunk.setError(err);
if (!dust.cache[namespace])
dust.cache[namespace] = {};
if (!dust.cache[namespace][name])
dust.loadSource(dust.compile(src, fullname));
dust.cache[namespace][name](chunk, context).end();
});
var render = function render(data, output, callback) {
var tmplLibrary = fs.readFileSync(path.join(__dirname, templateLibrary), "UTF-8");
var tmplSteps = fs.readFileSync(path.join(__dirname, templateSteps), "UTF-8");
var insertionTemplate = fs.readFileSync(path.join(__dirname, templateInsertion), "UTF-8").toString();
var data2 = JSON.parse(data);
//check for existing output and check if data contains steps
if (output && data2 && data2.feature.scenarios.length > 0 && data2.feature.scenarios[0].steps.length) {
//use regex and replace to find first scenario comment and append insertion template
output = output.replace(/(\/\*Scenario:.*\*\/)/, insertionTemplate + "$1");
} else if (output === null) {
output = "{" + ">library/" + "}"; //jsdoc dust parsing error occurs if not expressed this way
}
dust.optimizers.format = function formatReturnNode(ctx, node) {
return node;
};
dust.loadSource(dust.compile(tmplSteps, "steps", false));
dust.loadSource(dust.compile(tmplLibrary, "library", false));
dust.loadSource(dust.compile(output, "output", false));
dust.render("output", data2, callback);
};
compile: function compile(html) {
// Disable white space removal, by not using this the html is not valid because
// of Javascript comments in the source
dust.optimizers.format = (ctx, node) => node;
// Compile the template
const compiled = dust.compile(html, 'template');
// Load the compiled source into Dust
dust.loadSource(compiled);
return compiled;
},
function genTest(uuid) {
var sutFilePath = store[uuid].filePath,
testdir = 'tests/unit/',
testFilePath = util.format(testdir+'%s-%s.js', sutFilePath, uuid),
template = 'template/test.template',
compiled = dust.compile(fs.readFileSync(template,'UTF-8'), "template"),
params,
result;
params = {
testFilePath: testFilePath,
filePath: path.relative(path.dirname(testFilePath), sutFilePath),
fileName: path.basename(sutFilePath),
funName: store[uuid].funName
};
//input
params.arguments = [];
store[uuid]['input'].arguments.forEach(function(arg) {
/*if(typeof arg.value === 'function') {
return;
}
else */if(arg.value === undefined)
params.arguments.push({name: arg.name, value: 'undefined'});
else
params.arguments.push({name: arg.name, value: JSON.stringify(arg.value)});
});
//return
if(store[uuid]['output']['return'].name) {
params.return = JSON.stringify(store[uuid]['output']['return'].value);
}
//callback
if(store[uuid]['callback'].name) {
params.callback = {};
params.callback.name = store[uuid]['callback'].name;
params.callback.arguments = store[uuid]['callback'].arguments;
}
//render
dust.loadSource(compiled);
dust.render("template", params, function(err, out) {
result = beautify(out, { indent_size: 4 });
});
mkdirp.sync(path.dirname(testFilePath));
fs.writeFileSync(testFilePath, result);
}
_.each(self.components, function(component) {
try {
var filepath = path.join(templatePath, component.page.template);
var template = fs.readFileSync(filepath, "utf8");
var name = component.page.template.slice(0, component.page.template.indexOf('.'));
var compiled = dust.compile(template, name, true);
dust.loadSource(compiled);
}
catch (e) {
var message = '\nCouldn\'t compile Dust template at "' + filepath + '". ' + e + '\n';
console.log(message);
throw e;
}
});