f.src.forEach(function(file) {
try {
name = options.templateNameFromFile(file);
if (options.precompile) {
var template = grunt.file.read(file);
var compiledTemplate;
// Run the `preprocess` function if specified in the options.
if (typeof options.preprocess === 'function') {
template = options.preprocess(template);
}
if (options.handlebarsPath && options.templateCompilerPath) {
compiledTemplate = manualCompile(options.handlebarsPath, options.templateCompilerPath, template);
} else {
compiledTemplate = compiler.precompile(template).toString();
}
// Wrap compiled template
contents = 'Ember.Handlebars.template(' + compiledTemplate + ')';
} else {
// Wrap raw (uncompiled) template
contents = 'Ember.Handlebars.compile(' + JSON.stringify(grunt.file.read(file)) + ')';
}
processedTemplates.push(options.templateRegistration(name, contents));
} catch(e) {
grunt.log.error(e);
grunt.fail.warn('Ember Handlebars failed to compile ' + file + '.');
}
});
function() {
var compiled = compiler.precompile(data).toString();
compiled = 'Ember.Handlebars.template('.concat(compiled, ');');
compiled = 'module.exports = '.concat(compiled);
this.queue(compiled);
this.queue(null);
}
TemplateCompiler.prototype.processString = function (string, relativePath) {
if (this.HTMLBars) {
return "export default " + compileSpec(string);
} else {
var input = handlbarsTemplateCompiler.precompile(string, false);
return "export default Ember.Handlebars.template(" + input + ")";
}
}
io.read(resId + ".hbs", function (text) {
var code = util.format(
"Ember.TEMPLATES[%s] = Ember.Handlebars.template(%s);",
JSON.stringify(name),
compiler.precompile(text)
);
io.write(_define(absId, ['ember'], '', '', code));
}, io.error);
['@test the template factory returned from precompile is the same as compile'](assert) {
let { owner } = this;
let { runtimeResolver } = this;
let templateStr = 'Hello {{name}}';
let options = { moduleName: 'my-app/templates/some-module.hbs' };
let spec = precompile(templateStr, options);
let body = `exports.default = template(${spec});`;
let module = new Function('exports', 'template', body);
let exports = { };
module(exports, template);
let Precompiled = exports['default'];
let Compiled = compile(templateStr, options);
assert.equal(typeof Precompiled.create, 'function', 'precompiled is a factory');
assert.ok(Precompiled.id, 'precompiled has id');
assert.equal(typeof Compiled.create, 'function', 'compiled is a factory');
assert.ok(Compiled.id, 'compiled has id');
assert.equal(runtimeResolver.templateCacheMisses, 0, 'misses 0');
assert.equal(runtimeResolver.templateCacheHits, 0, 'hits 0');
let precompiled = runtimeResolver.createTemplate(Precompiled, owner);
assert.equal(runtimeResolver.templateCacheMisses, 1, 'misses 1');
assert.equal(runtimeResolver.templateCacheHits, 0, 'hits 0');
let compiled = runtimeResolver.createTemplate(Compiled, owner);
assert.equal(runtimeResolver.templateCacheMisses, 2, 'misses 2');
assert.equal(runtimeResolver.templateCacheHits, 0, 'hits 0');
assert.ok(typeof precompiled.spec !== 'string', 'Spec has been parsed');
assert.ok(typeof compiled.spec !== 'string', 'Spec has been parsed');
this.registerComponent('x-precompiled', {
ComponentClass: Component.extend({
layout: Precompiled
})
});
this.registerComponent('x-compiled', {
ComponentClass: Component.extend({
layout: Compiled
})
});
this.render('{{x-precompiled name="precompiled"}} {{x-compiled name="compiled"}}');
assert.equal(runtimeResolver.templateCacheMisses, 2, 'misses 2');
assert.equal(runtimeResolver.templateCacheHits, 2, 'hits 2');
this.assertText('Hello precompiled Hello compiled');
}
TemplateCompiler.prototype.processString = function (string, relativePath) {
var extensionRegex = /.handlebars|.hbs/gi;
var filename = relativePath.toString().split('templates' + path.sep).reverse()[0].replace(extensionRegex, '');
var input = compiler.precompile(string);
var template = "Ember.Handlebars.template(" + input + ");\n";
if (this.options.module === true) {
return "import Ember from 'ember';\nexport default " + template;
} else {
return "Ember.TEMPLATES['" + filename + "'] = " + template;
}
};
EmberHandlebarsEs6Compiler.prototype.compile = function(data, path, callback) {
var tmplPath, tmplName, content;
try {
tmplPath = path.replace(this.root, '');
tmplPath = tmplPath.replace(/\\/g, '/');
tmplPath = tmplPath.substr(0, tmplPath.length - sysPath.extname(tmplPath).length);
tmplName = "Ember.TEMPLATES['" + tmplPath + "']";
content = compiler.precompile(data.toString()).toString();
var result = "export default " + tmplName + " = Ember.Handlebars.template(" + content + ");";
return callback(null,result);
} catch (error) {
return callback(error);
}
};
return function(content, file, done) {
var processed = null;
log.debug('Processing "%s".', file.originalPath);
try {
var template = new Cli({args: [file.originalPath]}).parseCommandLineArgs();
var input = compiler.precompile(template['content'], false).toString();
var processed = "Ember.TEMPLATES['" + template['name'] + "'] = Ember.Handlebars.template(" + input + ");";
} catch (e) {
log.error('%s\n at %s', e.message, file.originalPath);
}
done(processed);
};
function compileTemplate (fileContents, options, done) {
var compilerOutput;
try {
if (options.precompile) {
compilerOutput = compiler.precompile(fileContents, false);
} else {
compilerOutput = JSON.stringify(fileContents);
}
}
catch (e) {
return done(e);
}
done(null, compilerOutput);
}
glob.sync(pattern).forEach(function(pathMatch){
var contents = fs.readFileSync(pathMatch).toString();
var compiled = compiler.precompile(contents).toString();
output += "Ember.TEMPLATES['" + formatName(pathMatch) + "'] = Ember.Handlebars.template(" + compiled + ");";
});
}).forEach(function (template) {
var data = fs.readFileSync(path.join(templates, template), 'utf8');
var comp = hbscom.precompile(data).toString();
var name = template.replace(/\.(hbs|handlebars)$/, '');
toutput.push('Ember.TEMPLATES[\'' + name + '\'] = Ember.Handlebars.template(' + comp + ');');
});
templates.forEach(function(template) {
var fn = precompile(template.content);
template.src = fn.toString();
});
var compileHandlebars = function(file, callback) {
// Get the name of the template
var name = options.processName(file.path);
// Perform pre-compilation
try {
var compiled = compiler.precompile(file.contents.toString()).toString();
}
catch(err) {
return callback(err, file);
}
if (options.wrapped) {
compiled = 'Ember.Handlebars.template('+compiled+')';
}
// Handle different output times
if (options.outputType === 'browser' || options.outputType === 'hybrid') {
// Prepend namespace to name
if (options.namespace !== false) {
name = options.namespace+'.'+name;
}
// Get namespace information for the final template name
var nameNSInfo = getNSInfo(name, true);
if (options.outputType === 'hybrid') {
var templateDef = compiled;
compiled = "(function(g) {";
compiled += "var Handlebars = g.Handlebars || require('handlebars');";
if (options.declareNamespace) {
compiled += nameNSInfo.declaration+compiled;
}
compiled += "var template = "+templateDef+";"
compiled += "if (typeof exports === 'object' && exports) module.exports = template;";
compiled += nameNSInfo.namespace+' = template;';
compiled += "}(typeof window !== 'undefined' ? window : global));";
}
else {
// Add assignment
compiled = nameNSInfo.namespace+' = '+compiled+';';
if (options.declareNamespace) {
// Tack on namespace declaration, if necessary
compiled = nameNSInfo.declaration+compiled;
}
}
}
else if (options.outputType === 'amd') {
var fileName = file.path.split("/");
var finalFileName = [];
for (var i = fileName.length - 1; i >= 0; i--) {
if(fileName[i] === "templates"){
finalFileName.push(fileName[i]);
finalFileName.reverse()
break;
}
finalFileName.push(fileName[i].replace(/\.[^/.]+$/, ""));
};
finalFileName = finalFileName.toString();
finalFileName = finalFileName.replace(/,/g, "/");
fileName = options.namespace+"/"+finalFileName;
compiled = "define('"+fileName+"', [\"exports\"], function(_exports_) { _exports_[\"default\"] = "+compiled+";});";
}
else if (options.outputType === 'commonjs') {
compiled = "module.exports = function(Handlebars) {return "+compiled+";};";
}
else if (options.outputType === 'node') {
compiled = "module.exports = "+compiled+";";
compiled = "var Handlebars = global.Handlebars || require('handlebars');"+compiled;
}
else if (options.outputType !== 'bare') {
callback(new Error('Invalid output type: '+options.outputType), file);
}
file.path = path.join(path.dirname(file.path), name+'.js');
file.contents = new Buffer(compiled);
callback(null, file);
};