Render the Liquid content

 @return [String] the rendered content
352670
def call
      liquid = ::Liquid::Template.parse(template)
      liquid.send(:render, stringify_assigns, liquid_options).html_safe
    end
794548
def render
      buffer = []
      _guess_col_widths
      rows = @list.size.to_s.length
      @rows = rows
      _prepare_format
      
      str = ""
      if @numbering
        str = " "*(rows+1)+@y
      end
      str <<  @fmstr % @columns
      buffer << str
      #puts "-" * str.length
      buffer << separator
      if @list
        if @numbering
          @fmstr = "%#{rows}d "+ @y + @fmstr
        end
        #@list.each { |e| puts e.join(@y) }
        count = 0
        @list.each_with_index { |r,i|  
          value = convert_value_to_text r, count
          buffer << value
          count += 1
        }
      end
      buffer
    end
563532
def render(object, options={}, return_obj=false)
      if options[:inspect]
        puts(object.inspect)
      else
        render_object(object, options, return_obj) unless silent_object?(object)
      end
    end
384347
def render(document)
      renderer = find_renderer(document)
      renderer.render(document) unless renderer.nil?
    end
590674
public function render()
	{
		$buffer	= '';
		foreach( $this->list as $content )
			$buffer	.= $this->renderInner( $content );
		return $buffer;
	}
296934
def render(self, content = None, **settings):
        
        (content, settings) = self.get_setup(content, **settings)
        return self._render(content, **settings)
584767
def _render_content(self, content, **settings):
        
        if isinstance(content, dict):
            return self._render_content_dict(content, 0, [], **settings)
        elif isinstance(content, list):
            return self._render_content_list(content, 0, [], **settings)
        else:
            raise Exception("Received invalid data tree for rendering.")
605503
def render(tmpl)
      t = Tilt.new(File.join('views', tmpl)) # @todo Caching!
      t.render(self)
    end
727409
def rendered_cell_content(route, parameters)
      render_cell(route.klass.underscore.to_sym, route.action.to_sym, parameters)
    end
350071
def render_string string, options
      escaped = html_escape(string)
      if options[:pretty]
        indent = ' ' * (options[:indent] * options[:depth])
        indent + escaped + "\n"
      else
        escaped
      end
    end
984280
def render_header
      return unless requires_header?

      if IOStreams.blank?(header.columns)
        raise(Errors::MissingHeader, "Header columns must be set before attempting to render a header for format: #{format.inspect}")
      end

      parser.render(header.columns, header)
    end
938996
def render(item, parent = nil)
      item = item.to_hash if item.respond_to?(:to_hash)
      if item.is_a?(Hash)
        item = item.inject({}) { |memo, (k,v)| memo[sym(k)] = v; memo }
        item.inject({}) {|memo, (k,v)| memo[sym(k)] = render(v, item); memo}
      elsif item.is_a?(Array)
        item.map { |i| render(i, parent) }
      elsif item.is_a?(String)
        item % parent rescue item
      else
        item
      end
    end
1342453
def render(format = :html, max_col = 80, max_row = nil, colors = Screen.default_css_colors, css_class = nil, css_style = nil)
			css_class ||= 'screen'
			kcode ||= Guess.kcode(@lexer.buffer)
			screens = populate(format, max_col, max_row, colors)
			separator = case format
			when :html
				"\n"
			when :text
				"\n---\n"
			end
			return screens.map{|screen| screen.render(format, css_class, css_style)}.join(separator)
		end
544562
def render_to_string(*)
      result = super
      if result.respond_to?(:each)
        string = +""
        result.each { |r| string << r }
        string
      else
        result
      end
    end
490352
def render_title(options={})
      result = ::Liquid::Template.parse(title).render(optional_data(options))
    rescue => e
      log_error(e)
    ensure
      return result.to_s
    end
511340
def render
      @key_length, results = get_key_length, []

      @bullet_data.each do |key, item|
        results.concat(render_bullet(key, item))
      end

      @bullet_data = []
      results
    end
759242
def render(*args, &block)
      captured = helpers.capture do
        helpers.concat(helpers.render(*args, &block))
        helpers.output_buffer.to_s
      end
      rawtext(captured)
    end