Render enriched record for view
 @param [Krikri::SearchIndexDocument]
 @return [String]
497301
def render_enriched_record(document)
      agg = document.aggregation
      return error_msg('Aggregation not found.') unless agg.present?
      JSON.pretty_generate(agg.to_jsonld['@graph'])
    end
815255
def render(filename, context=binding)
      contents=File.read(expand_filename(filename))
      template(contents, context)
    end
842449
def search_result_document(search_params)
        _, document_list = search_results(search_params)
        return document_list.first unless document_list.empty?
        document_not_found!
      end
1320622
def render(document)
      if Tolaria.config.markdown_renderer.nil?
        return simple_format(document)
      else
        @markdown_renderer ||= Tolaria.config.markdown_renderer.constantize
        return @markdown_renderer.render(document)
      end
    end
932208
function (record) {
      var recordToSend = { object: record };

      recordToSend.columnValues = this.getRecordColumnValues(record);
      recordToSend.searchKeywords = this.getRecordKeywords(record);
      recordToSend.filterValues = this.getRecordFilterValues(record);
      recordToSend.color = this.getRecordColor(record);

      return recordToSend;
    }
617576
def render(template, context = {})
      return nil unless exist?(template)

      path = File.join(@template_path, template + ".erb")
      layout_context = context.merge(partial: ERB.new(File.read(path)).result(Yokunai::RenderContext.new(context).get_binding))

      ERB.new(@raw_layout).result(Yokunai::RenderContext.new(layout_context).get_binding)
    end
559126
private String render(io.wcm.caravan.hal.docs.impl.model.Service service, Map<String, Object> model,
      Template template) throws IOException {
    Map<String, Object> mergedModel = ImmutableMap.<String, Object>builder()
        .putAll(model)
        .put("docsContext", ImmutableMap.<String, Object>builder()
            .put("baseUrl", DocsPath.get(service.getServiceId()) + "/")
            .put("resourcesPath", HalDocsBundleTracker.DOCS_RESOURCES_URI_PREFIX)
            .build())
        .build();
    return template.apply(mergedModel);
  }
517960
def _parsed_document(content, file_path)
      if file_path.nil? && content.nil?
        raise LoadError.new(nil, file_path, "Don't know what to do with nil values for both content and path")
      end

      content = if !file_path.nil? && content.nil?
                  File.read(file_path)
                else
                  content
                end

      parsed_document = parsed_documents[file_path]
      return parsed_document unless parsed_document.nil?

      parser = Parser.new(file_path: file_path)
      document = parser.parse(content)

      parser.dependency_paths.each do |path|
        new_path = _find_file!(path, file_path)
        next if new_path.nil?

        document.sub_documents << _parsed_document(nil, new_path)
      end

      document
    end
753263
def render_view(parser, token):
    
    bits = token.split_contents()

    n = len(bits)
    if n < 2:
        raise TemplateSyntaxError("'%s' takes at least one view as argument")

    viewname = bits[1]

    kwargs = {}
    if n > 2:
        for bit in bits[2:]:
            match = kwarg_re.match(bit)
            if not match:
                raise TemplateSyntaxError("Malformed arguments to render_view tag")
            name, value = match.groups()
            if name:
                kwargs[name] = parser.compile_filter(value)

    return StringNode(viewname, kwargs)
864678
def render(document)
      document['content'].each_with_object([]) do |node, result|
        result << find_renderer(node).render(node)
      end.join("\n")
    end
836703
def render_essence_view_by_name(element, name, options = {}, html_options = {})
      if element.blank?
        warning('Element is nil')
        return ""
      end
      content = element.content_by_name(name)
      render_essence_view(content, options, html_options)
    end
1314886
def record(index)
      seek_to_record(index)
      return nil if deleted_record?

      DBF::Record.new(@data.read(record_length), columns, version, @memo)
    end
364148
def custom_search(self, index, doc_type):
        '''
        
        '''
        from bungiesearch import Bungiesearch
        return Bungiesearch(raw_results=True).index(index).doc_type(doc_type)
1207124
function (records, cb) {

                // loop through each record
                async.each(records, function (record, recordDone) {

                    // loop through each field
                    async.each(Object.keys(req.linz.configList.fields), function (field, fieldDone) {

                        req.linz.configList.fields[field].renderer(record[field], record, field, req.linz.configs[record._id], function (err, value) {

                            if (err) {
                                return fieldDone(err, records);
                            }

                            var index = records.indexOf(record);
                            records[index][field] = value;

                            return fieldDone(null, records);

                        });

                    }, function (err) {

                        return recordDone(err, records);

                    });


                }, function (err) {

                    return cb(err, records);

                });

            }
1347319
def render_erb
      renderer = ERB.new(template_content, nil, '-')
      renderer.filename = @template_file
      renderer.result(binding)
    end
384347
def render(document)
      renderer = find_renderer(document)
      renderer.render(document) unless renderer.nil?
    end
1214164
def render_csv(filename = nil, view_name = nil)

      filename ||= params[:action]
      view_name ||= params[:action]
      filename.downcase!
      filename += '.csv' unless filename[-4..-1] == '.csv'

      headers['Content-Type'] = 'text/csv'
      headers['Content-Disposition'] = "attachment; filename=\"#{filename}\""

      render view_name, layout: false
    end