Render the `nocache` blocks of the content and return the whole
        html
5895
def render_nocache(self):
        
        tmpl = template.Template(''.join([
            # start by loading the cache library
            template.BLOCK_TAG_START,
            'load %s' % self.get_templatetag_module(),
            template.BLOCK_TAG_END,
            # and surround the cached template by "raw" tags
            self.RAW_TOKEN_START,
            self.content,
            self.RAW_TOKEN_END,
        ]))
        return tmpl.render(self.context)
280741
function renderHTML(callback) {
            async.map(codeList, function (locals, n) {
                locals.req = req;
                ViewHelper.render({
                    cache: true,
                    path: SCRIPT_JADE
                }, locals, n)
            }, function (err, buf) {
                if (!err) {
                    buf = buf || [];
                    buf.splice(0, 0, SCRIPT_START_TAG);
                    buf.push(bottomScriptList.join(""));
                    buf.push(SCRIPT_END_TAG);
                }
                callback(err, buf.join(""));
            });
        }
1111950
def render(opts, functions, states=None, proxy=None, context=None):
    '''
    
    '''
    if context is None:
        context = {}

    pack = {'__salt__': functions,
            '__grains__': opts.get('grains', {}),
            '__context__': context}

    if states:
        pack['__states__'] = states
    pack['__proxy__'] = proxy or {}
    ret = LazyLoader(
        _module_dirs(
            opts,
            'renderers',
            'render',
            ext_type_dirs='render_dirs',
        ),
        opts,
        tag='render',
        pack=pack,
    )
    rend = FilterDictWrapper(ret, '.render')

    if not check_render_pipe_str(opts['renderer'], rend, opts['renderer_blacklist'], opts['renderer_whitelist']):
        err = ('The renderer {0} is unavailable, this error is often because '
               'the needed software is unavailable'.format(opts['renderer']))
        log.critical(err)
        raise LoaderError(err)
    return rend
797515
def render(self, content_state=None):
        
        if content_state is None:
            content_state = {}

        blocks = content_state.get('blocks', [])
        wrapper_state = WrapperState(self.block_map, blocks)
        document = DOM.create_element()
        entity_map = content_state.get('entityMap', {})
        min_depth = 0

        for block in blocks:
            depth = block['depth']
            elt = self.render_block(block, entity_map, wrapper_state)

            if depth > min_depth:
                min_depth = depth

            # At level 0, append the element to the document.
            if depth == 0:
                DOM.append_child(document, elt)

        # If there is no block at depth 0, we need to add the wrapper that contains the whole tree to the document.
        if min_depth > 0 and wrapper_state.stack.length() != 0:
            DOM.append_child(document, wrapper_state.stack.tail().elt)

        return DOM.render(document)
198342
def _render_context(self, template, block, **context):
        
        return u''.join(block(template.new_context(context)))
710320
def _render(self, text):
        ''''''
        parser = commonmark.Parser()
        ast = parser.parse(text)
        renderer = HtmlRenderer(self)
        html = renderer.render(ast)
        return html
329964
public function render($caching = false, $params = array())
	{
		if (!isset($params['template']))
		{
			if (App::isAdmin())
			{
				$db = App::get('db');
				$db->setQuery("SELECT s.`template`, e.protected FROM `#__template_styles` AS s INNER JOIN `#__extensions` AS e ON e.`element`=s.`template` WHERE s.`client_id`=0 AND s.`home`=1");
				$result = $db->loadObject();
			}
			else
			{
				$result = App::get('template');
			}

			$params['template'] = $result->template;
			if (is_dir(PATH_APP . DS . 'templates' . DS . $result->template))
			{
				$params['directory'] = PATH_APP . DS . 'templates';
			}
			else
			{
				$params['directory'] = PATH_CORE . DS . 'templates';
			}
		}

		if (!isset($params['file']))
		{
			$params['file'] = 'email.php';
		}

		if (!file_exists($params['directory'] . DS . $params['template'] . DS . $params['file']))
		{
			$params['template']  = 'system';
			$params['directory'] = PATH_CORE . DS . 'templates';
		}

		$this->_caching = $caching;

		if (!empty($this->_template))
		{
			$data = $this->_renderTemplate();
		}
		else
		{
			$this->parse($params);
			$data = $this->_renderTemplate();
		}

		if (class_exists('\Pelago\Emogrifier') && $data)
		{
			$data = str_replace('&#', '{_ANDNUM_}', $data);
			$emogrifier = new \Pelago\Emogrifier();
			$emogrifier->preserveEncoding = true;
			$emogrifier->setHtml($data);
			//$emogrifier->setCss($css);

			$data = $emogrifier->emogrify();
			$data = str_replace('{_ANDNUM_}', '&#', $data);
		}

		return $data;
	}
1109155
def render(context_scope = nil, locals = nil, &block)
      apply(context_scope, locals, &block) if context_scope || locals || block

      cache_results do
        send("to_#{@_options[:format]}")
      end
    end
601786
def render
    content = output_capture(@block) do
      instance_exec( *@args, &@block )
    end
    content_wrapped = output_capture() { wrap( content ) }
    output_concat content_wrapped
  end
441295
def render_link(self):
        """"""
        extra_context = {
            'add_nofollow': settings.ADD_NOFOLLOW,
            'page': self,
            'querystring_key': self.querystring_key,
        }
        if self.is_current:
            template_name = 'el_pagination/current_link.html'
        else:
            template_name = 'el_pagination/page_link.html'
            if settings.USE_NEXT_PREVIOUS_LINKS:
                if self.is_previous:
                    template_name = 'el_pagination/previous_link.html'
                if self.is_next:
                    template_name = 'el_pagination/next_link.html'
        if template_name not in _template_cache:
            _template_cache[template_name] = loader.get_template(template_name)
        template = _template_cache[template_name]
        with self.context.push(**extra_context):
            return template.render(self.context.flatten())
1239359
def render(content)
      content = content.symbolize_keys
      self.class.renderers.keys.each do |renderer_name|
        if content.key?(renderer_name)
          renderer = self.class.renderers[renderer_name]
          to_render = content.delete(renderer_name)
          rendered = renderer[:proc].call(to_render)

          # Unwrap a promise if we got one back
          if rendered.is_a?(Promise)
            rendered = rendered.sync
          end

          return [rendered, content.merge(content_type: renderer[:content_type])]
        end
      end

      # If we couldn't find a renderer - just render an empty string
      ["Error: render only supports #{self.class.renderers.keys.join(', ')}", content_type: 'text/plain']
    end
296934
def render(self, content = None, **settings):
        
        (content, settings) = self.get_setup(content, **settings)
        return self._render(content, **settings)
1211222
def layout_render(content)
			return content unless @layout

			layout_files = find_layouts(@layout)
			return content if layout_files.empty?

			layout_files.each_with_object(content.dup) do |layout_file, result|
				layout = compile_file(layout_file)
				result.replace layout.render(@scope, @locals) { result }
			end
		end
923298
def render_as_html(self, full=False):
        """"""
        from jinja2.debugrenderer import render_traceback
        return u'%s\n\n<!--\n%s\n-->' % (
            render_traceback(self, full=full),
            self.render_as_text().decode('utf-8', 'replace')
        )
456393
def renderLink(self, relpath=""):
        
        # return from cache if available
        cachekey, html = self.checkCache('Link', relpath)
        if html is not None:
            return html
        # else regenerate
        html = CachingRenderer.renderLink(self, relpath)
        if self.headerfile is not None:
            html += """ (<A HREF="%s">header</A>)""" % quote_url(relpath + self.headerfile)
        # save to cache
        return self.writeCache(cachekey, html)
400744
def render(self, context):
        """"""
        import markdown
        content = self.get_content_from_context(context)
        return markdown.markdown(content)
416378
def render_blocks(self, template_name, **context):
        
        blocks = {}
        template = self._get_template(template_name)
        for block in template.blocks:
            blocks[block] = self._render_context(template,
                                                template.blocks[block],
                                                **context)
        return blocks