fs.readFile(filePath, function(err, data) {
if (err) throw err;
// set our template id to the filename
var templateId = path.basename(filePath, '.dust'),
// and mirror our template path
output_path = cwd + config.pre_dir + filePath.substring(input_path.length);
output_path = path.normalize(output_path.substring(0, output_path.lastIndexOf('.')) + '.js');
// compile and save
var compiled = dust.compile(String(data), templateId);
var dirname = path.dirname(output_path);
if (!fs.existsSync(dirname)) {
fs.mkdirSync(dirname);
}
fs.writeFile(output_path, compiled, function(err) {
if (err) throw err;
console.log('Saved ' + output_path);
});
});
requirejs(['tmp/test/fixtures/scripts/render_dust/view.js'], function(view){
var templateData = {
data: ['item1', 'item2', 'item3']
};
var compiled = dust.compile(view, "view");
dust.loadSource(compiled);
dust.render("view", templateData, function(err, out){
if(err){
throw new Error(err);
}
var expected = grunt.file.read('test/expected/engine_expected.html');
test.equal(out, expected, 'should render a template file with Dust');
test.done();
});
});
Executor.prototype.handleNamespacePage = function(request, response) {
var tests = this.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: this.urlNamespace + '/results/' + testId,
testSandboxUrl: this.urlNamespace + '/sandbox/' + testId,
testId: testId
};
harnessTemplate = this.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);
});
};
clustor(function () {
var fs = require('fs');
var http = require('http');
var express = require('express');
var favicon = require('serve-favicon');
var bodyParser = require('body-parser');
var builder = require('component-middleware');
var agent = require('hub-agent');
var proxy = require('proxy');
var procevent = require('procevent')(process);
var utils = require('utils');
var dust = require('dustjs-linkedin');
var build = require('build');
var prod = utils.prod();
var index = fs.readFileSync(__dirname + '/public/index.html', 'utf-8');
dust.loadSource(dust.compile(index, 'index'));
var app = express();
app.use(favicon(__dirname + '/public/images/favicon.ico'));
app.use('/public', express.static(__dirname + '/public'));
app.use(proxy);
if (prod) {
log.info('building components during startup');
build();
} else {
log.info('hot component building with express middleware');
app.use(builder({
path: '/public/build'
}));
}
app.use(bodyParser.urlencoded({
extended: true
}));
//index page with embedded oauth tokens
app.all('/auth/oauth', function (req, res) {
var context = {
code: req.body.code || req.query.code,
error: req.body.error || req.query.error,
errorCode: req.body.error_code || req.query.error_code
};
//TODO: check caching headers
dust.render('index', context, function (err, index) {
if (err) {
log.error(err);
res.status(500).send({
error: 'error rendering requested page'
});
return;
}
res.set('Content-Type', 'text/html').status(200).send(index);
});
});
//index page
app.all('*', function (req, res) {
//TODO: check caching headers
res.set('Content-Type', 'text/html').status(200).send(index);
});
var server = http.createServer(app);
server.listen(port);
agent('/drones', function (err, io) {
proxy.listen(self, io);
procevent.emit('started');
});
}, function (err, address) {
function loadDustTemplate(name) {
var template = fs.readFileSync("./templates/" + name + ".dust", "UTF8").toString(), compiledTemplate = DustJS.compile(template, name);
DustJS.loadSource(compiledTemplate);
}
compile = function(template, name){
var compiled = dust.compile(template, name);
dust.loadSource(compiled);
};
var Readable = require('stream').Readable
, fs = require('fs')
, util = require('util')
, dust = require('dustjs-linkedin')
, template = dust.compile( fs.readFileSync('./files/vast.xml.dust').toString()
, "vast")
;
dust.loadSource(template);
util.inherits(Templater, Readable);
var iid = function() {
return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
var r = Math.random()*16|0, v = c == 'x' ? r : (r&0x3|0x8);
return v.toString(16);
});
}
var random = iid;
function Templater(){
var self = this;
Readable.call(self);
var channelData = {
iid: iid()
, random: random // Dust will execute this lambda!
, anticache: Date.now()
, analyticsUrl: 'http://staging.analytics.domain.com'
, clickTag: 'http://click-tracking.com'
, companionAd: 'bose/v4t/assets/Q3FY13_SL2_Launch_Static_300x250.jpg'
module.exports = function(content, file, conf){
var name = conf.basePath ? conf.basePath + file.filename : file.subpathNoExt;
return "define('" + file.getId() + "', function (require, exports, module) {\n\t" + dust.compile(content.toString(), name) + "\n});";
};
function renderDust(source, locals, cb) {
dust.loadSource(dust.compile(source, 'tmp'));
dust.render('tmp', locals, cb);
}
], function(name) {
var file = path.join(__dirname, name + '.dust');
var source = self.grunt.file.read(file);
dust.loadSource(dust.compile(source, name));
});
var esprima = require("esprima");
var junify = require("junify");
var moduleExportsPattern = require("./patterns/module-exports");
var exportsPattern = require("./patterns/exports");
var moduleExportsAssignPattern = require("./patterns/module-exports-assign");
var prototypePattern = require("./patterns/prototype");
var dust = require("dustjs-linkedin");
var fs = require("fs");
var beautify = require("js-beautify");
var glob = require("glob");
var basetmpl = dust.compile(fs.readFileSync(__dirname + "/templates/base.dust", "utf8"), "base");
var classtmpl = dust.compile(fs.readFileSync(__dirname + "/templates/class.dust", "utf8"), "class");
var statictmpl = dust.compile(fs.readFileSync(__dirname + "/templates/static.dust", "utf8"), "static");
var funcDecPattern = require("./patterns/identifiers/declaration/function.js");
var staticSinglePattern = require("./patterns/identifiers/single-static.js");
var objectPattern = require("./patterns/identifiers/m-e-object.js")
dust.loadSource(basetmpl);
dust.loadSource(classtmpl);
dust.loadSource(statictmpl);
var classIdFiles = glob.sync(__dirname + "/patterns/identifiers/class/**/*.js");
var classIdentifiers = [];
for(var i in classIdFiles){
classIdentifiers.push(require(classIdFiles[i]));
}
var prototypeIdFiles = glob.sync(__dirname + "/patterns/identifiers/prototypes/**/*.js");
var prototypeIdentifiers = [];
exports.plugin = function(Account, LostPassword, httpServer, emailer, loader) {
if(!emailer) return;
//register the dust tpl ~ fugly >.>
eval(dust.compile(fs.readFileSync(loader.params("http.lostPasswordEmailTpl"), "utf8"), "lostPasswordEmailTpl"));
httpServer.get("/lost_password", function(req, res) {
res.render("lost_password");
});
httpServer.post("/lost_password", function(req, res) {
var on = reqOutcome(req, res, "lost_password");
step(
function() {
Account.findOne({ email: req.body.email }, this);
},
on.success(function(account) {
if(!account) return on(new Error("account does not exist"));
this.account = account;
var lostPassword = new LostPassword({ account: account._id });
lostPassword.save(this);
}),
on.success(function(lostPassword) {
var next = this;
dust.render("lostPasswordEmailTpl", { email: "email", token: lostPassword._id }, this);
}),
on.success(function(tpl) {
var next = this;
emailer.send({
to: this.account.email,
subject: "Reset Password",
htmlBody: tpl
}, function(err) {
if(err) return on(new Error("Unable to send password recovery email"));
next();
})
}),
on.success(function() {
res.render("lost_password_sent", {
email: this.account.email
});
})
);
});
function lostPasswordExists(req, res, next) {
var on = reqOutcome(req, res, "lost_password");
step(
function() {
LostPassword.findOne({ _id: req.query.token || req.body.token }, this);
},
on.success(function(lostPassword) {
if(!lostPassword) {
return on(new Error("The reset password token does not exist."));
} else
if(lostPassword.expiresAt.getTime() < Date.now()) {
lostPassword.remove();
return on(new Error("The reset password link has expired."));
}
req.lostPassword = lostPassword;
this();
}),
next
);
}
httpServer.get("/reset_password", lostPasswordExists, function(req, res) {
res.render("reset_password", {
token: req.query.token
});
});
httpServer.post("/reset_password", lostPasswordExists, function(req, res) {
var on = reqOutcome(req, res, "reset_password");
step(
function() {
if(req.body.password.length < 6) {
console.log(vine.error(new Error("password must be at least 6 characters")).data)
return on(new Error("password must be at least 6 characters"));
}
if(req.body.password != req.body.password2) {
return on(new Error("passwords don't match"));
}
this();
},
function() {
Account.findOne({ _id: req.lostPassword.account }, this);
},
on.success(function(account) {
if(!account) return on(new Error("account doesn't exist"));
account.password = req.body.password;
account.save(this);
}),
on.success(function(account) {
res.render("login", vine.message("Please re-login with your new password").data);
req.lostPassword.remove();
})
);
});
}
exports.plugin = function(auth, httpServer, emailer, Referral, loader) {
var domain = loader.params("domain"),
serviceName = loader.params("serviceName"),
Account = auth.Account;
eval(dust.compile(fs.readFileSync(loader.params("http.inviteEmailTpl"), "utf8"), "inviteEmailTpl"));
Account.prototype.inviteAccount = function(email, next) {
var on = outcome.error(next),
InvitedAccount = this.model("referrals"),
self = this;
step(
function() {
console.log("find email %s", email);
Account.findOne({ email: email }, this);
},
on.success(function(account) {
if(account) return new Error(sprintf("%s already has an account", email));
console.log("account doesn't exist, finding referral");
Referral.findOne({ key: email }, this);
}),
on.success(function(referral) {
if(referral) return new Error(sprintf("%s has already been invited by someone else", email));
console.log("referral doesn't exist, parsing invite template");
this.referral = referral = new Referral({ key: email, invitedBy: self._id });
referral.save(this);
}),
on.success(function(referral) {
dust.render("inviteEmailTpl", { url: "http://" + domain + "/referrals/" + referral._id + "?src=email" }, this);
}),
on.success(function(tpl) {
var next = this;
Referral.emit("sent", this.referral, email);
emailer.send({
to: email,
subject: "You've been invited to check out " + serviceName,
htmlBody: tpl
}, function(err) {
if(err) console.error(err)
next();
});
}),
next
);
}
function checkReferral(req, res, next) {
Referral.findOne({ _id: req.params.referral }, function(err, referral) {
req.referral = referral;
if(!referral) return res.redirect("/");
next();
});
}
httpServer.get("/referrals/:referral", checkReferral, function(req, res, next) {
res.render("referral_signup", {
referralId: req.params.referral,
src: req.query.src
});
});
httpServer.post("/referrals/:referral", checkReferral, function(req, res, next) {
Account.signup(req.body, function(err, account) {
if(err) return res.render("referral_signup", vine.error(err).data);
req.referral.addAccount(account);
res.redirect("/login");
});
});
httpServer.get("/invite", auth.middleware.authCheckpoint, function(req, res) {
res.render("invite", {
account: req.account._id
});
});
httpServer.post("/invite", auth.middleware.authCheckpoint, function(req, res) {
var emails = String(req.body.emails).split(/[\n,]+/g),
result = vine.api();
step(
function() {
seq(emails).seqEach(function(email) {
var next = this;
req.account.inviteAccount(email, function(err) {
if(err) {
console.error(err);
emails.splice(email.indexOf(email), 1);
result.error(err);
return;
}
result.success(sprintf("%s has been invited", email));
})
}).seq(this);
},
function() {
res.render("invite", result.data);
}
);
res.render("invite", {
account: req.account._id
});
});
}
var end = function() {
this.queue(wrap(filename, dust.compile(input, filename)));
this.queue(null);
};
Template.findOne({ name: data.message.template, company: data.message.company, tenant: data.message.tenant }, function (errPickTemplate, resPickTemp) {
if (!errPickTemplate) {
if (resPickTemp && resPickTemp.content && resPickTemp.content.content) {
var compileid = uuid.v4();
var compiled = dust.compile(resPickTemp.content.content, compileid);
dust.loadSource(compiled);
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);
}
}
});
} else {
logger.error("No template found");
data.ack.acknowledge();
}
} else {
logger.error("Pick template failed ", errPickTemplate);
data.ack.acknowledge();
}
});
var jsont = utility.async(function*(alias, filename) {
var src = yield readFile(filename, 'utf8');
var compiled = dust.compile(src, alias);
dust.loadSource(compiled);
return dustRender(alias, original);
});
var fs = require('fs');
var dust = require('dustjs-linkedin');
var express = require('express');
var app = express();
// var request = require('request');
/**
* compiling on the server, avoid in production!
*/
var appRoot = process.cwd();
var src = fs.readFileSync(appRoot + '/app/views/hello-world.dust', 'utf8');
var compiled = dust.compile(src, 'say-hello-world');
// var compiled = dust.compile("Say hello {world}", 'say-hello-world');
dust.loadSource(compiled);
dust.render('say-hello-world', { world: "Venus" }, function(err, out) {
// `out` contains the rendered output.
console.log(out);
});
var templateName = 'hello-world';
// Pre-2.7
fs.readFile(appRoot +'/app/lib/' + templateName + '.js', { encoding: 'utf8' }, function(err, data) {
dust.loadSource(data);
dust.render(templateName, { world: "Pluto" }, function(err, out) {
console.log(out);
});
});
fs.readdirSync(template_dir).forEach(function (file) {
if (file.match(/\.dust$/)) {
var template = fs.readFileSync(path.join(template_dir, file), 'utf-8');
compiled += dust.compile(template, file.replace(/\.dust$/, ''));
}
});
export async function renderTypes(model, templateDir, outputSpec, options, languageSettings) {
const dusts = {}; // dusts[base of filename] = boolean
function fail(msg) {
throw new Error(msg);
}
function checkBasename(templateName) {
if (!(templateName in languageSettings.basenames)) {
fail(`No basename found in 'configuration while running template '${templateName}'`);
}
}
function checkExtension(templateName) {
if (!(templateName in languageSettings.extensions)) {
fail(`No extension found in configuration while running template '${templateName}'`);
}
}
if (undefined === languageSettings) {
fail('No config.json was found');
}
if (!modelLooksReasonable(model)) {
fail('No type information was received');
}
dust.loadSource(dust.compile('{@contextDump/}', 'model'));
if (options.base) {
loadDustTemplates(options.templates, dusts);
}
loadDustTemplates(templateDir, dusts);
dusts.model = 1;
// Run any renames
if (languageSettings.renames) {
for (const t of model.allTypes) {
if (languageSettings.renames[t.packedName]) {
t.packedName = languageSettings.renames[t.packedName];
}
}
}
// Add important items to a global dust context in addition to the passed in model
const globals = {};
globals.languageSettings = languageSettings;
globals.suppressJs = options.s;
globals.typePrefix = languageSettings.typePrefix;
globals.baseClass = languageSettings.baseClass;
globals.namespace = languageSettings.namespace;
Object.assign(model, globals);
// Depending on what templates exist, run them over the matching items in the model.
// We'll work from a list of jobs.
const jobs = [];
// templates we know about
const singleFiles = ['header', 'impl', 'enums', 'typedefs', 'importAll'];
const multiFiles = {
classHeader: model.classes,
class: model.classes,
enum: model.enums,
};
// don't mention JSON if suppressed
if (!(options.s)) {
addRenderOneFileJob('model', globals, model, jobs, path.join(outputSpec, 'model.json'));
}
// here are the single templates, we generate many things from the template name
for (const t of singleFiles) {
if (dusts[t]) {
checkBasename(t);
checkExtension(t);
// generate filename. for now, the dot is included in extensions! TODO
const fname = languageSettings.basenames[t] + languageSettings.extensions[t];
addRenderOneFileJob(t, globals, model, jobs, path.join(outputSpec, fname));
}
}
// here are the multi templates
function makeJob(extension) {
return c => path.join(outputSpec, model.typePrefix + c.packedName + extension);
}
for (const t in multiFiles) {
if (dusts[t]) {
checkExtension(t);
addRenderMultipleFilesJob(t, globals, model, multiFiles[t],
languageSettings, jobs, makeJob(languageSettings.extensions[t]));
}
}
return await Promise.all(jobs);
}
function compileAndLoad(data, name) {
loadSource(dust.compile(data, name));
}
var dust = require('dustjs-linkedin'),
path = require('path'),
fs = require('fs');
var dir = path.join(__dirname, '..', 'views', 'templates');
var writer = fs.createWriteStream(path.join(__dirname, '..', 'public', 'javascripts', 'compiled_templates.js')),
files = fs.readdirSync(dir);
for (var i = 0; i < files.length; i++) {
var str = fs.readFileSync(path.join(dir, files[i]), 'utf8'),
name = path.basename(files[i], '.html');
writer.write(dust.compile(str, name));
}
writer.end();
compile: function (sourcePath, templateName) {
var source = libfs.readFileSync(sourcePath, 'utf8');
// compiling as string
return dust.compile(source, templateName);
}
function loadTemplate(name) {
var template = fs.readFileSync(path.join(__dirname, '../templates', `${name}.dust`)).toString();
var compiledTemplate = dust.compile(template, name);
dust.loadSource(compiledTemplate);
}
Template.findOne({name:message.template,company:message.company,tenant:message.tenant},function (errPickTemplate,resPickTemp) {
if(!errPickTemplate){
if(resPickTemp){
var compileid = uuid.v4();
var compiled = dust.compile(resPickTemp.content.content, compileid);
dust.loadSource(compiled);
dust.render(compileid, 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))
{
mailOptions.text = renderedTemplate;
SendRequest(company,tenant,mailOptions,function(done){
if(!done)
ack.reject(true);
else
ack.acknowledge();
});
}
}
}
else
{
console.log("Rendering Done");
mailOptions.text = outRendered;
SendRequest(company,tenant,mailOptions,function(done){
if(!done)
ack.reject(true);
else
ack.acknowledge();
});
}
}
});
}else{
logger.error("No template found");
ack.reject(true);
}
}else{
logger.error("Pick template failed ",errPickTemplate);
ack.reject(true);
}
});
var mongoose = require( 'mongoose' );
var dust = require( 'dustjs-linkedin' );
var fs = require( 'fs' );
dust.loadSource( dust.compile( fs.readFileSync( 'templates/messages/github_commit.dust', 'ascii' ), 'github_commit' ) );
var FeedGithub = function() {
var self = this;
self.GetURLs = function( obj ) {
if ( !obj )
{
return {
};
}
if ( obj instanceof models.Room )
{
return {
'feed_github': '/api/1.0/Room/' + obj._id + '/Feed/Github'
};
}
return {};
};
self.bind = function( app ) {
app.post( '/api/1.0/Room/:roomId/Feed/Github', function( request, response ) {
models.Room.findById( request.params.roomId, function( error, room ) {
if ( error )
{