yield_html renders the content passed into a tag as a string.  You can ```.watch!```
 ```yield_html``` and it will be run again when anything in the template changes.
438631
def yield_html
      if (template_path = attrs.content_template_path)
        @yield_renderer ||= StringTemplateRenderer.new(@volt_app, attrs.content_controller, template_path)
        @yield_renderer.html
      else
        # no template, empty string
        ''
      end
    end
909731
def render(template=None, ostr=None, **kwargs):
    
    jinja_environment.filters['texscape'] = tex_escape
    template = template or DEFAULT_TEMPLATE
    ostr = ostr or sys.stdout
    jinja_template = jinja_environment.get_template(template)
    jinja_template.stream(**kwargs).dump(ostr)
1227955
def render_to_string(self, request, template, context, content_instance=None):
        
        if not content_instance:
            content_instance = PluginContext(request)

        content_instance.update(context)
        return render_to_string(template, content_instance.flatten(), request=request)
227210
def render_html_tree(tree):
    

    # Restore any tag names that were changed in get_html_tree()
    for el in tree.iter():
        if '__tag_name' in el.attrib:
            actual_tag_name = el.attrib.pop('__tag_name')
            el.tag = actual_tag_name

    html = lxml.html.tostring(tree, encoding='utf8').decode('utf8')

    return strip_wrapping(html)
630211
def render_tag(name, attributes = {}, &block)
      if name =~ /^(.+?):(.+)$/
        render_tag($1) { render_tag($2, attributes, &block) }
      else
        tag_definition_block = @definitions[qualified_tag_name(name.to_s)]
        if tag_definition_block
          stack(name, attributes, block) do |tag|
            tag_definition_block.call(tag).to_s
          end
        else
          tag_missing(name, attributes, &block)
        end
      end
    end
152835
def pumper(html_generator):
    
    source = html_generator()
    parser = etree.HTMLPullParser(
        events=('start', 'end'),
        remove_comments=True
    )
    while True:
        for element in parser.read_events():
            yield element
        try:
            parser.feed(next(source))
        except StopIteration:
            # forces close of any unclosed tags
            parser.feed('</html>')
            for element in parser.read_events():
                yield element
            break
886483
def render
      @viewer.render_html(self.send(@render_type), url)
    rescue Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::EPIPE
      @viewer = DefaultViewer
    end
221796
def render_to_response(self, template_name, __data,
                           content_type="text/html"):
        ''''''
        resp = self.render(template_name, __data)
        return Response(resp,
                        content_type=content_type)
116507
def render_html(html_str):
    
    import utool as ut
    from os.path import abspath
    import webbrowser

    try:
        html_str = html_str.decode('utf8')
    except Exception:
        pass

    html_dpath = ut.ensure_app_resource_dir('utool', 'temp_html')
    fpath = abspath(ut.unixjoin(html_dpath, 'temp.html'))
    url = 'file://' + fpath
    ut.writeto(fpath, html_str)
    webbrowser.open(url)
439643
def innerHTML(self):
        '''
            
        '''

        # If a self-closing tag, there are no contents
        if self.isSelfClosing is True:
            return ''

        # Assemble all the blocks.
        ret = []

        # Iterate through blocks
        for block in self.blocks:
            # For each block:
            #   If a tag, append the outer html (start tag, contents, and end tag)
            #   Else, append the text node directly

            if isinstance(block, AdvancedTag):
                ret.append(block.outerHTML)
            else:
                ret.append(block)
        
        return ''.join(ret)
1215453
function(el, tagName, tagData) {
                var helperTagCallback = tagData.options.read('tags.' + tagName, {
                        isArgument: true,
                        proxyMethods: false
                    })
                    .value,
                    tagCallback = helperTagCallback || tags[tagName];

                // If this was an element like <foo-bar> that doesn't have a component, just render its content
                var scope = tagData.scope,
                    res;

                if (tagCallback) {
                    var reads = can.__clearReading();
                    res = tagCallback(el, tagData);
                    can.__setReading(reads);
                } else {
                    res = scope;
                }



                // If the tagCallback gave us something to render with, and there is content within that element
                // render it!
                if (res && tagData.subtemplate) {

                    if (scope !== res) {
                        scope = scope.add(res);
                    }
                    var result = tagData.subtemplate(scope, tagData.options);
                    var frag = typeof result === "string" ? can.view.frag(result) : result;
                    can.appendChild(el, frag);
                }
            }
723681
function(result, tag) {

		var is_void = Lava.isVoidTag(tag.name),
			tag_start_text = "<" + tag.name
				+ this.renderTagAttributes(tag.attributes)
				+ (is_void ? '/>' : '>'),
			inner_template,
			count;

		this. _compileString(result, tag_start_text);

		if (Lava.schema.DEBUG && is_void && tag.content) Lava.t("Void tag with content");

		if (!is_void) {

			if (tag.content) {

				inner_template = this.compileTemplate(tag.content);
				count = inner_template.length;

				if (count && typeof (inner_template[0]) == 'string') {

					this._compileString(result, inner_template.shift());
					count--;

				}

				if (count) {

					result.splice.apply(result, [result.length, 0].concat(inner_template));

				}

			}

			this. _compileString(result, "</" + tag.name + ">");

		}

	}
817534
def render_to_string(self, template, context=None, def_name=None, subdir='templates'):
        ''''''
        template_adapter = self.get_template_loader(subdir).get_template(template)
        return getattr(template_adapter, 'render')(context=context, request=self.request, def_name=def_name)
699581
def render
      # Initialize the resulting tag
      tag_parts = []

      # Slice objects into separate lists
      lists = slice_objects

      # Render each list into `tag` variable
      lists.each do |list|
        items = list.collect { |item| render_link_for(item) }
        tag_parts << render_content_tag_for(items)
      end

      tag_parts.join.html_safe
    end
948496
def render_template(template_name, **context):
    """"""
    tmpl = jinja_env.get_template(template_name)
    context["url_for"] = url_for
    return Response(tmpl.render(context), mimetype="text/html")
1316626
def view(node, slice, &block)
      slice = slice.to_i
      case node
      when ::HTML::Tag then
        children_view = node.children.map {|child| view(child, slice, &block)}.compact.join
        if resized?
          resizing.resize_node(node)
        end
        if sliced?
          if slicing.map.get(node, slice) || children_view.present?
            if node.closing == :close
              "</#{node.name}>"
            else
              s = "<#{node.name}"
              node.attributes.each do |k,v|
                s << " #{k}"
                s << "=\"#{v}\"" if String === v
              end
              s << " /" if node.closing == :self
              s << ">"
              s += children_view
              s << "</#{node.name}>" if node.closing != :self && !node.children.empty?
              s
            end
          end
        else
          node.to_s
        end
      when ::HTML::Text then
        if sliced?
          if range = slicing.map.get(node, slice)
            (range.is_a?(Array) ? node.content[Range.new(*range)] : node.content).tap do |export|
              unless range == true || (range.is_a?(Array) && range.last == -1) # broken text
                export << slicing.options.text_break if slicing.options.text_break
                if block_given?
                  yield self, export
                end
              end
            end
          end
        else
          node.to_s
        end
      when ::HTML::CDATA then
        node.to_s
      when ::HTML::Node then
        node.children.map {|child| view(child, slice, &block)}.compact.join
      end
    end
75309
def render
      content_tag(:ul) do
        html = "\n"

        if show_first_page?
          html += content_tag(:li, :class => "first_page") do
            link_to_page collection.first_page, 'paginate.first_page_label'
          end
          html += "\n"
        end

        if show_previous_page?
          html += content_tag(:li, :class => "previous_page") do
            link_to_page collection.previous_page, 'paginate.previous_page_label'
          end
          html += "\n"
        end

        html += render_pager

        if show_next_page?
          html += content_tag(:li, :class => "next_page") do
            link_to_page collection.next_page, 'paginate.next_page_label'
          end
          html += "\n"
        end

        if show_last_page?
          html += content_tag(:li, :class => "last_page") do
            link_to_page collection.last_page, 'paginate.last_page_label'
          end
          html += "\n"
        end
        html.html_safe
      end
    end