mirror of
https://github.com/discourse/discourse.git
synced 2024-12-11 17:33:43 +08:00
173 lines
5.1 KiB
JavaScript
173 lines
5.1 KiB
JavaScript
// This is a mechanism for quickly rendering templates which is Ember aware
|
|
// templates are highly compatible with Ember so you don't need to worry about calling "get"
|
|
// and computed properties function, additionally it uses stringParams like Ember does
|
|
|
|
// compat with ie8 in case this gets picked up elsewhere
|
|
const objectCreate = Object.create || function(parent) {
|
|
function F() {}
|
|
F.prototype = parent;
|
|
return new F();
|
|
};
|
|
|
|
const RawHandlebars = Handlebars.create();
|
|
|
|
RawHandlebars.helper = function() {};
|
|
RawHandlebars.helpers = objectCreate(Handlebars.helpers);
|
|
|
|
RawHandlebars.helpers['get'] = function(context, options) {
|
|
var firstContext = options.contexts[0];
|
|
var val = firstContext[context];
|
|
|
|
if (context.indexOf('controller') === 0) {
|
|
context = context.replace(/^controller\./, '');
|
|
}
|
|
|
|
if (val && val.isDescriptor) { return Em.get(firstContext, context); }
|
|
val = val === undefined ? Em.get(firstContext, context): val;
|
|
return val;
|
|
};
|
|
|
|
// adds compatability so this works with stringParams
|
|
function stringCompatHelper(fn) {
|
|
const old = RawHandlebars.helpers[fn];
|
|
RawHandlebars.helpers[fn] = function(context,options) {
|
|
return old.apply(this, [
|
|
RawHandlebars.helpers.get(context,options),
|
|
options
|
|
]);
|
|
};
|
|
};
|
|
|
|
// #each .. in support (as format is transformed to this)
|
|
RawHandlebars.registerHelper('each', function(localName,inKeyword,contextName,options){
|
|
var list = Em.get(this, contextName);
|
|
var output = [];
|
|
var innerContext = objectCreate(this);
|
|
for (var i=0; i<list.length; i++) {
|
|
innerContext[localName] = list[i];
|
|
output.push(options.fn(innerContext));
|
|
}
|
|
return output.join('');
|
|
});
|
|
|
|
stringCompatHelper("if");
|
|
stringCompatHelper("unless");
|
|
stringCompatHelper("with");
|
|
|
|
|
|
function buildPath(blk, args) {
|
|
var result = { type: "PathExpression",
|
|
data: false,
|
|
depth: blk.path.depth,
|
|
loc: blk.path.loc };
|
|
|
|
// Server side precompile doesn't have jquery.extend
|
|
Object.keys(args).forEach(function (a) {
|
|
result[a] = args[a];
|
|
});
|
|
|
|
return result;
|
|
}
|
|
|
|
function replaceGet(ast) {
|
|
var visitor = new Handlebars.Visitor();
|
|
visitor.mutating = true;
|
|
|
|
visitor.MustacheStatement = function(mustache) {
|
|
if (!(mustache.params.length || mustache.hash)) {
|
|
mustache.params[0] = mustache.path;
|
|
mustache.path = buildPath(mustache, { parts: ['get'], original: 'get', strict: true, falsy: true });
|
|
}
|
|
return Handlebars.Visitor.prototype.MustacheStatement.call(this, mustache);
|
|
};
|
|
|
|
// rewrite `each x as |y|` as each y in x`
|
|
// This allows us to use the same syntax in all templates
|
|
visitor.BlockStatement = function(block) {
|
|
if (block.path.original === 'each' && block.params.length === 1) {
|
|
var paramName = block.program.blockParams[0];
|
|
block.params = [ buildPath(block, { original: paramName }),
|
|
{ type: "CommentStatement", value: "in" },
|
|
block.params[0] ];
|
|
delete block.program.blockParams;
|
|
}
|
|
|
|
return Handlebars.Visitor.prototype.BlockStatement.call(this, block);
|
|
};
|
|
|
|
visitor.accept(ast);
|
|
}
|
|
|
|
if (Handlebars.Compiler) {
|
|
RawHandlebars.Compiler = function() {};
|
|
RawHandlebars.Compiler.prototype = objectCreate(Handlebars.Compiler.prototype);
|
|
RawHandlebars.Compiler.prototype.compiler = RawHandlebars.Compiler;
|
|
|
|
RawHandlebars.JavaScriptCompiler = function() {};
|
|
|
|
RawHandlebars.JavaScriptCompiler.prototype = objectCreate(Handlebars.JavaScriptCompiler.prototype);
|
|
RawHandlebars.JavaScriptCompiler.prototype.compiler = RawHandlebars.JavaScriptCompiler;
|
|
RawHandlebars.JavaScriptCompiler.prototype.namespace = "RawHandlebars";
|
|
|
|
RawHandlebars.precompile = function(value, asObject) {
|
|
var ast = Handlebars.parse(value);
|
|
replaceGet(ast);
|
|
|
|
var options = {
|
|
knownHelpers: {
|
|
get: true
|
|
},
|
|
data: true,
|
|
stringParams: true
|
|
};
|
|
|
|
asObject = asObject === undefined ? true : asObject;
|
|
|
|
var environment = new RawHandlebars.Compiler().compile(ast, options);
|
|
return new RawHandlebars.JavaScriptCompiler().compile(environment, options, undefined, asObject);
|
|
};
|
|
|
|
RawHandlebars.compile = function(string) {
|
|
var ast = Handlebars.parse(string);
|
|
replaceGet(ast);
|
|
|
|
// this forces us to rewrite helpers
|
|
var options = { data: true, stringParams: true };
|
|
var environment = new RawHandlebars.Compiler().compile(ast, options);
|
|
var templateSpec = new RawHandlebars.JavaScriptCompiler().compile(environment, options, undefined, true);
|
|
|
|
var t = RawHandlebars.template(templateSpec);
|
|
t.isMethod = false;
|
|
|
|
return t;
|
|
};
|
|
}
|
|
|
|
|
|
RawHandlebars.get = function(ctx, property, options) {
|
|
if (options.types && options.data.view) {
|
|
var view = options.data.view;
|
|
return view.getStream ? view.getStream(property).value() : view.getAttr(property);
|
|
} else {
|
|
return Ember.get(ctx, property);
|
|
}
|
|
};
|
|
|
|
export function template() {
|
|
return RawHandlebars.template.apply(this, arguments);
|
|
}
|
|
|
|
export function precompile() {
|
|
return RawHandlebars.precompile.apply(this, arguments);
|
|
}
|
|
|
|
export function compile() {
|
|
return RawHandlebars.compile.apply(this, arguments);
|
|
}
|
|
|
|
export function get() {
|
|
return RawHandlebars.get.apply(this, arguments);
|
|
}
|
|
|
|
export default RawHandlebars;
|