{user.username} commented {posts.timestamp}
{posts.content}
From 9bcf7d2cbf3cf46a272040e7b937bcc8d3e2bacd Mon Sep 17 00:00:00 2001
From: Austin Howe <720983+theaustinhowe@users.noreply.github.com>
Date: Wed, 5 Jan 2022 15:36:25 -0500
Subject: [PATCH 06/36] More testing.
---
public/lib/general.js | 494 ++++++++++++++++++++++++-
public/templates/comments/comments.tpl | 7 +
2 files changed, 500 insertions(+), 1 deletion(-)
diff --git a/public/lib/general.js b/public/lib/general.js
index c8732ce8..ed22ed8f 100644
--- a/public/lib/general.js
+++ b/public/lib/general.js
@@ -83,6 +83,8 @@
}
if (pagination) {
+ console.log(data, templates.blocks)
+ // var html = templates.parse(template, data);
html = normalizePost(parse(data, templates.blocks['posts']));
commentsDiv.innerHTML = commentsDiv.innerHTML + html;
} else {
@@ -354,4 +356,494 @@
})(data, "", template);
}
-}());
\ No newline at end of file
+}());
+
+
+// https://raw.githubusercontent.com/benchpressjs/benchpressjs/v0.3.1/lib/templates.js
+(function(module) {
+ var templates = {
+ cache: {},
+ globals: {}
+ },
+ helpers = {},
+ loader,
+ worker;
+
+ var regexes = {
+ nestedConditionals: /(?!^)(?!$)/g,
+ conditionalBlock: /[\r\n?\n]*?[\r\n?\n]*?/,
+ conditionalHelper: //,
+ conditionalArgs: /[ ]*,[ ]*/,
+ innerLoop: /\s*/g,
+ removeTabspace: /^\t*?|^\r\n?\t*?|\t?$|\r\n?\t*?$/g,
+ removeWhitespace: /(^[\r\n?|\n]*)|([\r\n\t]*$)/g,
+ cleanupEmptyLoops: /\s*/g,
+ cleanupMissingKeys: /[\r\n]*?[\/]?\{[a-zA-Z0-9\.]+[\r\n]*?\}/g,
+ leftoverRoot: /\.\.\/([\S]*?)[\}| ]/g,
+ getUndefinedKeys: //g,
+ backReferenceFix: /\$+/g,
+ escapeBlocks: //g,
+ escapeKeys: /\{([\s\S]*?)\}/g,
+ rootKey: /\{\.\.\/([\S]*?)\}/g,
+ rootConditional: /IF \.\.\/([\S]*?)/g,
+ rootConditionalFalse: /IF !\.\.\/([\S]*?)/g
+ };
+
+ if (typeof self !== 'undefined' && self.addEventListener) {
+ self.addEventListener('message', function(ev) {
+ if (!ev || !ev.data || !ev.data.template || !ev.data.object) {
+ return;
+ }
+ var data = ev.data;
+
+ self.postMessage({
+ result: !data.block ? templates.parse(data.template, data.object) : templates.parse(data.template, data.block, data.object),
+ signature: data.signature
+ }, '*');
+ }, false);
+ }
+
+ var callbacks = {},
+ signature = 0,
+ MAX_SAFE_INT = Math.pow(2, 53) - 1;
+
+ templates.setupWebWorker = function(pathToScript) {
+ try {
+ worker = new Worker(pathToScript);
+
+ worker.addEventListener('message', function(e) {
+ if (callbacks[e.data.signature]) {
+ callbacks[e.data.signature](e.data.result);
+ }
+ }, false);
+ } catch (err) {}
+ };
+
+ function launchWorker(template, obj, block, callback) {
+ signature++;
+ if (signature > MAX_SAFE_INT) {
+ signature = 0;
+ }
+
+ obj = sanitise(obj);
+
+ worker.postMessage({
+ template: template,
+ object: obj,
+ block: block,
+ signature: signature
+ });
+
+ callbacks[signature] = function(result) {
+ callback(result);
+ delete callbacks[signature];
+ };
+ }
+
+ function sanitise(obj) {
+ for(var prop in obj) {
+ if (!obj.hasOwnProperty(prop) || typeof obj[prop] === 'function') {
+ delete obj[prop];
+ }
+ }
+
+ return obj;
+ }
+
+ templates.parse = function(template, block, obj, callback) {
+ if (typeof block !== 'string') {
+ callback = obj;
+ obj = block;
+ block = false;
+ }
+
+ if (!template) {
+ return callback ? callback('') : '';
+ }
+
+ obj = registerGlobals(obj || {});
+
+ if (loader && callback) {
+ if (!templates.cache[template]) {
+ loader(template, function(loaded) {
+ templates.cache[template] = loaded;
+
+ launchCallback(loaded, obj, block, callback);
+ });
+ } else {
+ launchCallback(templates.cache[template], obj, block, callback);
+ }
+ } else if (callback) {
+ launchCallback(template, obj, block, callback);
+ } else {
+ return parseTemplate(block, template, obj);
+ }
+ };
+
+ function launchCallback(template, obj, block, callback) {
+ if (worker) {
+ launchWorker(template, obj, block, callback);
+ } else {
+ callback(parseTemplate(block, template, obj));
+ }
+ }
+
+ function parseTemplate(block, template, obj) {
+ block = !block ? template : templates.getBlock(template, block);
+ template = parse(block, obj);
+
+ return parseFunctions(template, template, obj);
+ }
+
+ templates.registerHelper = function(name, func) {
+ helpers[name] = func;
+ };
+
+ templates.registerLoader = function(func) {
+ loader = func;
+ };
+
+ templates.setGlobal = function(key, value) {
+ templates.globals[key] = value;
+ };
+
+ templates.getBlock = function(template, block) {
+ return template.replace(new RegExp('[\\s\\S]*([\\s\\S]*?)[\\s\\S]*', 'g'), '$1');
+ };
+
+ templates.flush = function() {
+ templates.cache = {};
+ };
+
+ function express(filename, options, fn) {
+ var fs = require('fs'),
+ tpl = filename.replace(options.settings.views + '/', '');
+
+ options._locals = null;
+
+ if (!templates.cache[tpl]) {
+ fs.readFile(filename, function(err, html) {
+ templates.cache[tpl] = (html || '').toString();
+ return fn(err, templates.parse(templates.cache[tpl], options));
+ });
+ } else {
+ return fn(null, templates.parse(templates.cache[tpl], options));
+ }
+ }
+
+ function replace(string, regex, value) {
+ return string.replace(regex, value.toString().replace(regexes.backReferenceFix, '$$$'));
+ }
+
+ function replaceValue(template, key, value) {
+ var string;
+
+ value = value.toString();
+ string = replace(template, new RegExp('{{' + key + '}}', 'g'), value);
+
+ return replace(string, new RegExp('{' + key + '}', 'g'), value
+ .replace(regexes.escapeKeys, '{$1}')
+ .replace(regexes.escapeBlocks, '<!--$1-->')
+ );
+ }
+
+ function makeRegex(block, namespace) {
+ namespace = '(' + namespace + ')?';
+ return new RegExp('[\\s\\S]*?');
+ }
+
+ function makeBlockRegex(block, namespace) {
+ namespace = '(' + namespace + ')?';
+ return new RegExp('([\\r\\n?|\\n]?)|()', 'g');
+ }
+
+ function makeConditionalRegex(block) {
+ return new RegExp('([\\s\\S]*?)', 'g');
+ }
+
+ function makeStatementRegex(key) {
+ return new RegExp('()|()', 'g');
+ }
+
+ function registerGlobals(obj) {
+ for (var g in templates.globals) {
+ if (templates.globals.hasOwnProperty(g)) {
+ obj[g] = obj[g] || templates.globals[g];
+ }
+ }
+
+ return obj;
+ }
+
+ function checkConditionals(template, key, value) {
+ return checkConditional(checkConditional(template, '!' + key, !value), key, value);
+ }
+
+ function checkConditional(template, key, value) {
+ var matches = template.match(makeConditionalRegex(key));
+
+ if (matches) {
+ var statement = makeStatementRegex(key);
+ for (var i = 0, ii = matches.length; i < ii; i++) {
+ var nestedConditionals = matches[i].match(regexes.nestedConditionals),
+ match = replace(matches[i].replace(statement, ''), regexes.nestedConditionals, ''),
+ conditionalBlock = match.split(regexes.conditionalBlock);
+
+ if (conditionalBlock[1]) {
+ // there is an else statement
+ template = replace(template, matches[i], replace(conditionalBlock[value ? 0 : 1], regexes.removeWhitespace, ''));
+ } else {
+ // regular if statement
+ template = replace(template, matches[i], value ? replace(match, regexes.removeWhitespace, '') : '');
+ }
+
+ if (nestedConditionals) {
+ for (var x = 0, xx = nestedConditionals.length; x < xx; x++) {
+ template = replace(template, '', nestedConditionals[x]);
+ }
+ }
+ }
+ }
+
+ return template;
+ }
+
+ function checkConditionalHelpers(template, obj) {
+ var string,
+ func;
+
+
+ while ((string = template.match(regexes.conditionalHelper)) !== null) {
+ var fn = string[1].trim(),
+ args = fn.split(regexes.conditionalArgs);
+
+ func = args[0];
+
+ if (helpers[func]) {
+ args.shift();
+ args.unshift(obj);
+ template = checkConditionals(template, 'function.' + fn, helpers[func].apply(null, args));
+ } else {
+ template = template.replace(makeConditionalRegex('function.' + fn));
+ }
+ }
+
+ return template;
+ }
+
+ function callMethod(method, parameters) {
+ return method.apply(templates, parameters);
+ }
+
+ function parseFunctions(block, result, obj) {
+ var functions = block.match(/{function.*?}/g, '');
+ if (!functions) {
+ return result;
+ }
+
+ for (var i=0, ii=functions.length; i{user.icon:text}
+ {user.icon:text}