Render source with a specific tilt template class
508817
def render_with_tilt_template(template_class, src, locals, &_block)
      @current_tilt_template = template_class
      template = template_class.new(source_path) { src }

      block_content = if block_given?
                        yield
                      else
                        ""
                      end

      template.render(@context, locals) do |name|
        if name
          @context._content_for_blocks[name]
        else
          block_content
        end
      end
    end
1260936
def get_compiled_file_content(path)
      begin
        Tilt.new(path.to_s).render({}, {
          :spec => spec
        })
      rescue RuntimeError
        File.read(path)
      end
    end
681247
function compileJSSource(ComponentClass) {
    var sourceBuffer = new CompileSourceBuffer();
    var contextId = genSSRId();

    sourceBuffer.addRendererStart();
    var renderId = compileComponentSource(sourceBuffer, ComponentClass, contextId);
    sourceBuffer.addRaw('return componentRenderers.' + renderId + '(data, noDataOutput)');
    sourceBuffer.addRendererEnd();

    return sourceBuffer.toCode();
}
1001906
def render_template(template, **context):
    
    parts = template.split('/')
    renderer = _get_renderer(parts[:-1])
    return renderer.render(renderer.load_template(parts[-1:][0]), context)
498815
function StepperView(vm, stepper) {
	function add(num) {
		stepper.value += num;
		vm.redraw();
	}

	function set(e) {
		stepper.value = +e.target.value;
	}

	// template renderer (called on each redraw)
	return function() {
		return el("#stepper", [
			el("button", {onclick: [add, -1]}, "-"),
			el("input[type=number]", {value: stepper.value, oninput: set}),
			el("button", {onclick: [add, +1]}, "+"),
		]);
	};
}
17424
def render(self, name, context):
        """"""
        if Generator.strict:
            self.env.undefined = TestableUndefined
        else:
            self.env.undefined = Undefined
        template = self.get_template(name)
        return template.render(context)
1200499
def render(template, extra={}, **kwargs):
    """"""
    context = hookenv.execution_environment()
    context.update(extra)
    context.update(kwargs)
    return template.format(**context)
263407
def render(self, template, context=None, def_name=None, subdir='templates', content_type=None, status=None, charset=None):
        ''''''
        template_adapter = self.get_template_loader(subdir).get_template(template)
        return getattr(template_adapter, 'render_to_response')(context=context, request=self.request, def_name=def_name, content_type=content_type, status=status, charset=charset)
984425
def render_source(output_dir, package_spec, jenv=JENV):
  
  path, module_name = package_spec.filepath
  java_template = jenv.get_template(TEMPLATE_NAME)
  module_path = "com." + package_spec.identifier
  yaml_filepath = "/".join(package_spec.filepath) + ".yaml"
  includes = [".".join(i.split(".")[:-1]) for i in package_spec.includes]
  includes = [i for i in includes if i != "types"]
  for msg in package_spec.definitions:
    msg_name = classnameify(msg.identifier) if msg.sbp_id else msg.identifier
    l = "/".join(package_spec.filepath)
    destination_filename = "%s/com/%s/%s.java" % (output_dir, l , msg_name)

    # Create the output directory if it doesn't exist
    if not os.path.exists(os.path.dirname(destination_filename)):
      os.mkdir(os.path.dirname(destination_filename))

    with open(destination_filename, 'w+') as f:
        print(destination_filename)
        f.write(java_template.render(m=msg,
                                     filepath=yaml_filepath,
                                     module_path=module_path,
                                     include=includes,
                                     description=package_spec.description))
584050
def render_template(self):
        """"""
        self.import_mappings()
        self.create_template()
        if self.description:
            self.set_template_description(self.description)
        self.setup_parameters()
        rendered = self.template.to_json(indent=self.context.template_indent)
        version = hashlib.md5(rendered.encode()).hexdigest()[:8]
        return (version, rendered)
836328
function getNewDefaultRenderer(map) {
        switch (map.orientation) {
            case "orthogonal":
                return new me.TMXOrthogonalRenderer(map);

            case "isometric":
                return new me.TMXIsometricRenderer(map);

            case "hexagonal":
                return new me.TMXHexagonalRenderer(map);

            case "staggered":
                return new me.TMXStaggeredRenderer(map);

            // if none found, throw an exception
            default:
                throw new Error(map.orientation + " type TMX Tile Map not supported!");
        }
    }
1317373
function Renderer(options) {
  options = options || {};
  this.MD   = new MDRenderer(options);
  this.CGMD = new CGMDRenderer(new MDRenderer(options));

  return this;
}
1112719
function (templatesMap, partialsMap) {
  var compiledHtml = [];

  for (let templateName in templatesMap) {
    let template = templatesMap[templateName].template;
    let templateData = templatesMap[templateName].data;

    compiledHtml.push(mustache.render(template, templateData, partialsMap));
  }

  return compiledHtml;
}
1099607
function mergeTemplateAndModel (source, data) {
  var renderer = data ? underscore.template : dummyRenderer
  return renderer(source, data)
}
61735
function(tplname, tplargs, tplloader) {
            tplname = tplname || this.template;
            tplargs = tplargs || _.result(this, "templateContext");
            tplloader = tplloader || _.result(this, "templateLoader");

            var tpl = new Template({
                template: tplname,
                args: tplargs,
                loader: tplloader,
                view: this
            });
            return tpl.render();
        }
1046196
public String renderFlat(String template) {
    int depth = context.getRenderDepth();

    try {
      if (depth > config.getMaxRenderDepth()) {
        ENGINE_LOG.warn("Max render depth exceeded: {}", Integer.toString(depth));
        return template;
      } else {
        context.setRenderDepth(depth + 1);
        return render(parse(template), false);
      }
    } finally {
      context.setRenderDepth(depth);
    }
  }
807272
def render_impl(**kwargs):
    
    if Template is None:
        tmpl = kwargs.get("file", None)
        if tmpl is None:
            tmpl = kwargs.get("source", None)
            return anytemplate.engines.base.fallback_renders(tmpl)

        return anytemplate.engines.base.fallback_render(tmpl, None, **kwargs)

    return Template(**kwargs).respond()