function config(err, props) {
// Files to copy (and process).
var files = init.filesToCopy(props);
// Actually copy (and process) files.
init.copyAndProcess(files, props);
props.settings=true;
var travis = nunjucks.render("config/.travis.yml",props);
var gruntfile = nunjucks.render("config/Gruntfile.js",props);
var index = nunjucks.render("config/index.html",props);
var crawl = nunjucks.render("config/crawl.js",props);
var configtravis = nunjucks.render("config/configtravis.sh",props);
// init.writePackageJSON('Gruntfile.js',gruntfile);
grunt.file.write(".travis.yml",travis);
grunt.file.write("Gruntfile.js",gruntfile);
grunt.file.write("index.html",index);
grunt.file.write("crawl.js",crawl);
grunt.file.write("configtravis.sh",configtravis);
// All done!
grunt.file.write(settingsPath, JSON.stringify(props,null,2));
grunt.verbose.or.ok();
done();
}
const make = _.debounce(() => {
console.log("[INFO]: start building");
// locals
let toc = yaml.load(readSync(__dirname + '/readme.yml'));
toc = _.map(toc, (v,k) => {
return {
title: k,
items: v && v.map(item => {
return {
title: _.keys(item)[0],
num: _.values(item)[0]
};
})
};
});
debug('toc: %j', toc);
const readme = njk.render(__dirname + '/README.md.njk', {
toc: toc
});
fs.writeFileSync(__dirname + '/../README.md', readme, 'utf8');
console.log('[INFO]: OK');
}, 500);
Storage.exportHTML = function () {
return nunjucks.render("player.html", {
svg: this.document.asText,
pres: this.presentation,
json: JSON.stringify(this.presentation.toMinimalStorable())
});
};
const buildShell = async () => {
// html-minifier breaks when trying to minify partial HTML, so we have to
// render the shell as a full page, minify it, and then split it up.
const SHELL_SPLIT_POINT = 'SHELL_SPLIT_POINT';
const data = {
ENV,
site: book.site,
articles: book.articles,
page: {
path: '',
private: true,
content: SHELL_SPLIT_POINT,
},
layout: 'shell.html',
};
const html = nunjucks.render('shell.html', data);
const processedHtml = processHtml(html);
const [shellStart, shellEnd] = processedHtml.split(SHELL_SPLIT_POINT);
await generateRevisionedAsset('shell-start.html', shellStart);
await generateRevisionedAsset('shell-end.html', shellEnd);
};
function fkCacheDrop(args, callback) {
let config = getConfig(args);
let objectSql = nunjucks.render('drop-objects.sql', config);
fs.writeFileSync('out.sql', '');
fs.appendFileSync('out.sql', objectSql);
for (let cache of config.cache) {
let context = Object.assign({}, cache, { outputSchema: config.outputSchema });
let triggerSql = nunjucks.render(template[cache.type].drop, context);
fs.appendFileSync('out.sql', triggerSql);
}
execute(config);
callback();
}
(file.metadata.types || ['html']).forEach(function(type, i) {
var curFile = file;
var nunjucksOptions = {
env: conf.build.root,
prod: prod,
tree: tree,
conf: conf,
type: type,
root: rootItems[curFile.metadata.lang],
metadata: curFile.metadata,
content: curFile.contents.toString('utf-8'),
};
if (0 < i) {
curFile = file.clone();
}
if ('html' !== type) {
curFile.path =
curFile.path.substr(0, curFile.path.length - 4) + type;
}
// Render the template
curFile.contents = new Buffer(
Nunjucks.render(
type +
'/' +
(nunjucksOptions.metadata.template || 'page') +
'.tpl',
nunjucksOptions
)
);
// Save it.
dest.write(curFile);
});
async.each(files,function(item, cb){
console.log(item.name + ';' + item.path + ';' + item.renderPath);
item.nunjucksContent = nunjucks.render(item.renderPath);
if(item.path){item.path += '/';}
fs.exists('./build/html /'+item.path, function (exists) {
var tasks = [];
if(!exists){
tasks.push(function(callback){
fs.mkdir('./build/html /'+item.path, function(err){
callback(err);
});
})
}
tasks.push(function (callback) {
fs.writeFile('./build/html /'+item.path+item.name, item.nunjucksContent, function (err) {
console.log('save');
callback(err);
});
});
async.waterfall(tasks, function (err) {
cb(err);
})
});
},function(err){
render: function (template, data, options) {
options = options || {};
var locals = data || {};
var header = '';
var footer = '';
var html;
var subject;
var locale = options.locale;
var partial = options.partial;
// This option is really only used for tests
var dir = options.dir || 'templates';
var metaData = require(__dirname + '/' + dir +'/' + template);
locale = isLanguageSupported(locale) ? locale : DEFAULT_LANG;
locals.gettext = gettext(locale);
locals.locale = locale;
try {
html = nunjucks.render(dir + '/' + template + '/index.html', data);
subject = nunjucks.renderString(locals.gettext(metaData.subject), data);
if (!partial) {
header = baseHtml.header;
footer = baseHtml.footer;
} else {
// displaying html inline, so replace body tags
html = html.replace(/<body( .*?)?>/gi, '<div$1>');
html = html.replace(/<\/(body)>/gi, '</div>');
}
return {
html: header + html + footer,
subject: subject
};
} catch (err) {
console.log(err);
}
}
module.exports = function (callback) {
var templatesDir = __dirname + '/../templates';
var files = fs.readdirSync(templatesDir);
var manifest = [];
files.forEach(function (dir) {
var stats = fs.statSync(path.join(templatesDir, dir));
if (!stats.isDirectory()) {
return;
}
var templateName = dir;
var metaData = require(templatesDir + '/' + templateName);
var html = generateHtml(templateName, metaData);
manifest.push({
metaData: metaData,
path: templateName + '.html'
});
fs.writeFileSync(__dirname + '/../build/' + templateName + '.html', html);
});
var manifestHtml = nunjucks.render('test/fixtures/manifest-layout.html', {templates: manifest});
fs.writeFileSync(__dirname +'/../build/index.html', manifestHtml);
callback();
};
API.test = function (req, res , next){
// res.setHeader('Access-Control-Allow-Origin','*');
res.setHeader('Content-Type','text/html; charset=utf-8');
var renderOpts = { hello: 'world' };
res.send(200, nj.render('index.html', renderOpts));
return next();
}
.then(invaders => {
if(!invaders.length) {
return next(createError(404, 'not found'));
}
let renderedInvaders = nunjucks.render('invaders.njk', {invaderList: invaders});
res.send(renderedInvaders);
});
app.get('/signup', function (req, res) {
var file = nunjucks.render(__dirname + '/../client/index.html', {
...env,
captcha: true
})
res.send(file)
})
var thisClip = req.models.clip.get(urlParts[2], function (err, clip) {
if (err) {
res.send(404, 'Sorry, this clip does not exist.');
return;
}
var response = nunjucks.render('templates/clip.html', { video_id: clip['youtube_id'], start: Math.ceil(clip['start']), stop: Math.ceil(clip['stop']) });
res.send(response)
});
Cosmos.prototype.generateConfigFile = (servicesData) => {
const flattenedData = [].concat.apply([], servicesData)
const services = flattenedData.map(i => i.get())
nunjucks.configure('template', { autoescape: true })
return nunjucks.render('haproxy.cfg.njk', { services })
}
router.get('/manage', [Package.commonViewComponentsMiddleware], function (req, res, next) {
var toInject = Package.Services.Admin.processModules();
toInject.injectables = JSON.stringify(toInject.injectables);
res.send(nunjucks.render('index.nunj', {
siteName: Package.options.siteName || App.Config.app.siteName || 'MCMS Admin',
files: toInject || {}
}));
});
return new Promise((resolve, reject) => {
return nunjucks.render(...args, (err, res) => {
if (err) {
reject(err)
}
resolve(res)
})
})
app.get(['/', '/app', '/login', '/user/:username'], function (req, res) {
console.log('user', req.user)
var file = nunjucks.render(__dirname + '/../client/index.html', {
...env,
user: req.user
})
res.send(file)
})
return new Promise(function(fullfill, reject) {
nunjucks.render(self._file + '.html', self._data, function(err, res) {
if (err) {
return reject(err);
}
fullfill(res);
});
});
return Q.fcall(function() {
var result = nunjucks.render(config.template, ramlObj);
if (config.processOutput) {
return config.processOutput(result);
}
return result;
});
exports.template = (template, options) => {
if (/[<>{}]/.test(template)) {
return nunjucks.renderString(template, options);
}
template = template.replace(/(\.html|)+$/, '.html');
return nunjucks.render(template, options);
};
return function* (next) {
try {
yield next;
if (this.response.status === 404 && !this.response.body) {
this.throw(404);
}
} catch (err) {
this.status = err.status || 500;
// application
this.app.emit('error', err, this);
// accepted types
switch (this.accepts('html', 'text', 'json')) {
case 'text':
this.type = 'text/plain';
if (process.env.NODE_ENV === 'development' || err.expose) {
this.body = err.message;
} else {
throw err;
}
break;
case 'json':
this.type = 'application/json';
if (process.env.NODE_ENV === 'development' || err.expose) {
this.body = {
error: err.message,
};
} else {
this.body = {
error: http.STATUS_CODES[this.status],
};
}
break;
case 'html':
this.type = 'text/html';
if (process.env.NODE_ENV === 'development' || process.env.DEBUG) {
this.body = nunjucks.render('application/error.html', {
...settings, ctx: this, request: this.request, response: this.response,
status: this.status, error: err.message, stack: err.stack, code: err.code,
});
} else {
if ([404, 422].includes(this.status)) {
this.redirect(`/${this.status}.html`);
} else {
this.redirect('/500.html');
}
}
break;
default:
throw err;
}
}
};
generate: function (templatePath, context, generated_callback) {
if (arguments.length === 2) {
generated_callback = context;
context = templatePath;
templatePath = path.join(__dirname, "./default-template.html");
}
nunjucks.render(templatePath, context, generated_callback);
}
document: function (app, controller, req, res, body, cb) {
nunjucks.render('./index.html', { body: body }, (err, html) => {
if(err) {
return cb(err, null);
}
cb(null, html);
})
}
return new Promise(resolve => {
resolve(
nunjucks.render(template, {
...settings,
...parameters,
csrf: this.csrf,
})
);
});
.pipe(through.obj(function (file, enc, callback) {
file.articleData.body = file.contents.toString('utf8');
file.contents = new Buffer(nunjucks.render('article.tmpl.html', {
article: file.articleData
}));
callback(null, file);
}))
pipe(through2.obj(function (file, enc, cb) {
file.contents = new Buffer(nunjucks.render('templates/article.html', file.data));
file.path = gulpUtil.replaceExtension(file.path, '.html');
this.push(file);
cb();
})).
parseTemplate: function (request, reply) {
var template;
var username = request.params.username;
template = nunjucks.render('./app/templates/userPage.html', {
username: username
});
reply(template);
},
parseTemplate: function (results, chordData) {
var template;
template = nunjucks.render('./app/templates/chordTestUsers.html', {
results: results,
chordData: JSON.stringify(chordData)
});
return template;
},
export function serialize({api}, done) {
nunjucks.render('template.nunjucks', {api}, (err, apib) => {
if (err) {
return done(err);
}
// Attempt to filter out extra spacing
done(null, apib.replace(/\n\s*\n\s*\n/g, '\n\n'));
});
}
function fkCacheCreate(args, callback) {
let config = getConfig(args);
let objectSql = nunjucks.render('create-objects.sql', config);
fs.writeFileSync('out.sql', '');
fs.appendFileSync('out.sql', objectSql);
for (let cache of config.cache) {
if (cache.triggerPrefix[0].match(/[0-9]/)) {
throw new Error(`Trigger prefix cannot start with a number. Trigger prefix for table '${cache.table}' starts with a number: '${cache.triggerPrefix}'`); // Unknown reason PostgreSQL fails a name starting with number even in double quotes. Change prefix in test config and see that.
}
let context = Object.assign({}, cache, { outputSchema: config.outputSchema });
let triggerSql = nunjucks.render(template[cache.type].create, context);
fs.appendFileSync('out.sql', triggerSql);
}
execute(config);
callback();
}