Render data using default chain in the target format.

 data - the data to render
 format - format to use as a symbol
 name - name using the extension of the format

 Returns the processed data
492654
def render_default(data, format=:markdown, name='render_default.md')
      # set instance vars so we're able to render data without a wiki or page.
      @format = format
      @name   = name

      chain = [:Metadata, :PlainText, :Emoji, :TOC, :RemoteCode, :Code, :Sanitize, :WSD, :Tags, :Render]

      filter_chain = chain.map do |r|
        Gollum::Filter.const_get(r).new(self)
      end

      process_chain data, filter_chain
    end
461117
def data(self, data):
        
        self._data = self._enforceDataType(data) # Enforce self._data to be a QFont
        self.familyCti.data = fontFamilyIndex(self.data, list(self.familyCti.iterConfigValues))
        self.pointSizeCti.data = self.data.pointSize()
        self.weightCti.data = fontWeightIndex(self.data, list(self.weightCti.iterConfigValues))
        self.italicCti.data = self.data.italic()
42968
def get_render_data(self, **kwargs):
        
        if hasattr(self, 'get_context_data'):
            data = self.get_context_data(**kwargs)
        else:
            data = kwargs
        return data
1121530
def render(self, data, accepted_media_type=None, renderer_context=None):
        
        if data is None:
            return ''

        stream = StringIO()

        xml = SimplerXMLGenerator(stream, self.charset)
        xml.startDocument()
        xml.startElement(self.root_tag_name, {})

        self._to_xml(xml, data)

        xml.endElement(self.root_tag_name)
        xml.endDocument()
        return stream.getvalue()
518748
def _load_data(self):
        
        url = self.parent.build_url(self.parent._endpoints.get('format'))
        response = self.parent.session.get(url)
        if not response:
            return False
        data = response.json()

        self._bold = data.get('bold', False)
        self._color = data.get('color', '#000000')  # default black
        self._italic = data.get('italic', False)
        self._name = data.get('name', 'Calibri')  # default Calibri
        self._size = data.get('size', 10)  # default 10
        self._underline = data.get('underline', 'None')

        self._loaded = True
        return True
946685
function normalizeStyleData (data) {
  var style = normalizeStyleBinding(data.style);
  // static style is pre-processed into an object during compilation
  // and is always a fresh object, so it's safe to merge into it
  return data.staticStyle
    ? extend(data.staticStyle, style)
    : style
}
519669
function renderTemplate(template, css, data={}){
  
    // assign css
    data.inlinecss = css;

    // render template - use custom escape function to handle linebreaks!
    return _ejs.render(template, data, {
        escape: function(text){
            if (!text){
                return '';
            }

            // apply generic escape function
            text = _ejs.escapeXML(text);

            // linebreaks
            text = text.replace(/\n/g, '<br />');

            return text;
        }
    });
}
100949
function (data) {
    if (data.src.tagName) {
      // Since `data.src` can be an element, parse out the string if necessary for the hash.
      data = utils.extendDeep({}, data);
      data.src = data.src.src;
    }
    return JSON.stringify(data);
  }
854155
def _dataToString(self, data):
        
        if self.specialValueText is not None and data == self.minValue:
            return self.specialValueText
        else:
            return "{}{:.{}f}{}".format(self.prefix, data, self.decimals, self.suffix)
470358
def render(data, saltenv='base', sls='', argline='', **kwargs):  # pylint: disable=unused-argument
    '''
    
    '''
    translate_newlines = kwargs.get('translate_newlines', False)
    return _decrypt_object(data, translate_newlines=translate_newlines)
1203718
def _render_list(data):
  
  return IPython.core.display.HTML(google.datalab.utils.commands.HtmlBuilder.render_list(data))
1203065
def get_render_data(self, **kwargs):
        
        kwargs['model_name'] = self.model_name
        kwargs['model_name_plural'] = self.model_name_plural
        return super(ModelCMSView, self).get_render_data(**kwargs)
381389
def get_formats(self, id, **data):
        
        
        return self.get("/formats/{0}/".format(id), data=data)
394252
def render(self, mold_id, data):
        

        template = self.load_mold(mold_id)
        return template.render(**data)
400136
function compile (template, data) {
    for (var name in data) {
      template = template.replace('{{' + name + '}}', data[name])
    }
    return template
  }
552007
def define_data_format(self):
        
        data = javabridge.call(self.jobject, "defineDataFormat", "()Lweka/core/Instances;")
        if data is None:
            return None
        else:
            return Instances(data)
185836
def outputdata(self, data):
        
        if not isinstance(data, bytes):
            data = str(data).encode(self.encoding)
        self.output(MemoryStream(data))