How to use mustache - 10 common examples

'use strict'

const fs = require('fs')
const path = require('path')
const tap = require('tap')
const uuid = require('uuid/v4')
const request = require('request')
const _ = require('lodash')
const moment = require('moment')
const faker = require('faker')

const mustache = require('mustache')
// disable html escaping
mustache.escape = (v) => v

const env = require('../test-env/init')()
const server = require('../../lib/server')

const host = 'http://localhost:3447/fhir'

const loadResource = (filename, conf) => {
  const resPath = path.join(__dirname, 'mhd-test-samples', filename)
  const res = fs.readFileSync(resPath).toString()
  return mustache.render(res, conf)
}

const post = (host, resourceType, headers, body, onSuccess) => {
  const url = `${host}/${resourceType}`
  request.post({
    url: url,

req(deps, function () {

          var mustacheFn,
              // Replace any hrefid/srcid with a {{toUrl:x}} value
              idParsed = parseIds(text, id);

          if (config.isBuild) {
            buildMap[id] = {
              deps: deps,
              idParsed: idParsed
            };
          } else {
            mustacheFn = mustache.compile(idParsed.text);
          }

          var templateFn = must.makeTemplateFn(req);
          templateFn.idParsed = idParsed;
          templateFn.fn = mustacheFn;

          onload({
            template: templateFn
          });
        });
      }, onload.error);

msg = translate(getLocaleFromObject(this), singular, plural);
  }
  if (count == null) count = namedValues.count;

  // parse translation and replace all digets '%d' by `count`
  // this also replaces extra strings '%%s' to parseble '%s' for next step
  // simplest 2 form implementation of plural, like https://developer.mozilla.org/en/docs/Localization_and_Plurals#Plural_rule_.231_.282_forms.29
  if (count > 1) {
    msg = vsprintf(msg.other, [parseInt(count, 10)]);
  } else {
    msg = vsprintf(msg.one, [parseInt(count, 10)]);
  }

  // if the msg string contains {{Mustache}} patterns we render it as a mini tempalate
  if ((/{{.*}}/).test(msg)) {
    msg = Mustache.render(msg, namedValues);
  }

  // if we have extra arguments with strings to get replaced,
  // an additional substition injects those strings afterwards
  if ((/%/).test(msg) && args && args.length > 0) {
    msg = vsprintf(msg, args);
  }

  return msg;
};

import moment from "moment";
import debug from "debug";
import Mustache from "mustache";
import { zipObject, isEmpty, map, filter, includes, union, uniq, has, identity, extend, each, some } from "lodash";

import { Parameter } from "./parameters";

Mustache.escape = identity; // do not html-escape values

export let Query = null; // eslint-disable-line import/no-mutable-exports

const logger = debug("redash:services:query");

function collectParams(parts) {
  let parameters = [];

  parts.forEach(part => {
    if (part[0] === "name" || part[0] === "&") {
      parameters.push(part[1].split(".")[0]);
    } else if (part[0] === "#") {
      parameters = union(parameters, collectParams(part[4]));
    }
  });

function render(options) {

  mustache.tags = options.tags.split(',');

  return Promise.all([
    // Read the template
    readTemplate(options),
    getReferencesPaths(options),
    getInlinedFilesContents(options),
  ]).then(function(results) {
    var template = results[0];
    var pathsByExtension = results[1];
    var contentsByExtension = results[2];
    var locales = extend({}, pathsByExtension, contentsByExtension);
    return mustache.render(template, locales);
  });
}

'use strict';
var connect = require('connect'),
    fs = require('fs'),
    remove = require('remove'),
    fmf = require('./lib/fmf'), // FiveMinFork - fmf.js
    crypto = require('crypto'),
    request = require('request'),
    http = require('http'),
    mustache = require('mustache'),
    credentials = require('./lib/credentials'),
    forks = {},
    template = mustache.compile(fs.readFileSync(__dirname + '/public/forking.html', 'utf8')),
    error = fs.readFileSync(__dirname + '/public/error.html', 'utf8'),
    timeout = 5 * 60 * 1000,
    debug = process.env.NODE_DEBUG || false;

if (debug) {
  console.log('>>> in debug mode');
}

function createRoute(dir) {
  return connect()
    .use(connect.static(dir))
    .use(connect.directory(dir))
    .use(function (req, res) {
      // if we hit this point, then we have a 404
      res.writeHead(404, { 'content-type': 'text/html' });
      res.end(error);

var filename = path.join(__dirname, 'template', 'template.html');
    var template = readFile(filename);

     // read mermaid javascripts
     var mermaid = readFile(path.join(__dirname, 'node_modules', 'mermaid', 'dist', 'mermaid.min.js'));

    // compile template
    var mustache = require('mustache');

    var view = {
      title: title,
      style: style,
      content: data,
      mermaid: mermaid
    };
    return mustache.render(template, view);
  } catch (error) {
    showErrorMessage('makeHtml()', error);
  }
}

if (type.extends && language.regionTypes[type.extends]) {
			type.inherited_properties = language.regionTypes[type.extends].properties;
		}
	});

	// find, render, and inject the menu template
	var menuTemplate = $('#template-menu').html();
	Mustache.parse(menuTemplate); // optional, speeds up future uses
	var menuRendered = Mustache.render(menuTemplate, data);
	$('#template-menu').html(menuRendered);


	// find, render, and inject the region-type api template
	var template = $('#template-regionTypes').html().replace(/>/g, ">");
	var propertyTemplate = $('#template-property').html();
	var rendered = Mustache.to_html(template, data, {prop: propertyTemplate});
	$('#template-regionTypes').html(rendered);


	//enable property clicking
	$(".property-name").css("cursor", "pointer");
	$(".properties.inherited-properties li").addClass("closed");

	$(".property-name").click(
		function() {
			$(this).parent().toggleClass("closed");
		}
	);
}

function init_overview(client, jobs) {
        var read_series, write_series;

        $('#vgroups').toggle(client.features.lvm2);
        $('#iscsi-sessions').toggle(client.features.iscsi);

        var mdraids_tmpl = $("#mdraids-tmpl").html();
        mustache.parse(mdraids_tmpl);

        function render_mdraids() {
            function cmp_mdraid(path_a, path_b) {
                // TODO - ignore host part
                return client.mdraids[path_a].Name.localeCompare(client.mdraids[path_b].Name);
            }

            function make_mdraid(path) {
                var mdraid = client.mdraids[path];

                return {
                    path: path,
                    UUID: mdraid.UUID,
                    Size: utils.fmt_size(mdraid.Size),
                    Name: utils.mdraid_name(mdraid)
                };

.reduce((accum, dep) => {
      const contents = loadDependency(dep);
      const tokens = mustache.parse(contents)
        .filter((x) => x[0] !== 'text')
        .map((x) => ({ id: x[1] }))
        .filter((x) => x.id !== 'author' && x.id !== 'id'); // Provided by cyto

      return [
        ...accum.filter((x) => !tokens.includes(x)),
        ...uniqBy(tokens, 'id'),
      ];
    }, []);
}