Render the list of crumbs using renderer
972717
def render_crumbs(options = {})
      raise ArgumentError, "Renderer and block given" if options.has_key?(:renderer) && block_given?
      return yield(crumbs, options) if block_given?
      
      @_renderer ||= if options.has_key?(:renderer)
        options.delete(:renderer)
      else
        require 'crummy/standard_renderer'
        Crummy::StandardRenderer.new
      end

      @_renderer.render_crumbs(crumbs, options)
    end
1233493
def _render_content_list(self, content, depth, dstack, **settings):
        
        result = []
        i = 0
        size = len(content)
        for value in content:
            ds = [(depth, i, size)]
            ds = dstack + ds
            if isinstance(value, dict):
                result.append(self._render_item(ds, "[{}]".format(i), **settings))
                result += self._render_content_dict(value, depth + 1, ds, **settings)
            elif isinstance(value, list):
                result.append(self._render_item(ds, "[{}]".format(i), **settings))
                result += self._render_content_list(value, depth + 1, ds, **settings)
            else:
                result.append(self._render_item(ds, value, **settings))
            i += 1
        return result
10762
def render_children
      children = ''

      list_item.children.each do |child|
        children += self.class.render(child, opts)
      end

      children
    end
53370
def render(self, *args, **kwargs):
        '''
        
        '''
        user_name = kwargs.get('user_name', args[0])
        kind = kwargs.get('kind', args[1])
        num = kwargs.get('num', args[2] if len(args) > 2 else 6)
        with_tag = kwargs.get('with_tag', False)
        glyph = kwargs.get('glyph', '')

        all_cats = MUsage.query_most(user_name, kind, num).objects()
        kwd = {
            'with_tag': with_tag,
            'router': router_post[kind],
            'glyph': glyph
        }
        return self.render_string('modules/info/list_user_equation.html',
                                  recs=all_cats,
                                  kwd=kwd)
180851
function renderChoices(choices, pointer) {
  var output = '';
  var separatorOffset = 0;

  choices.forEach(function(choice, i) {
    output += '\n  ';

    if (choice.type === 'separator') {
      separatorOffset++;
      output += ' ' + choice;
      return;
    }

    var index = i - separatorOffset;
    var display = (index + 1) + ') ' + choice.name;
    if (index === pointer) {
      display = utils.chalk.cyan(display);
    }
    output += display;
  });

  return output;
}
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.")
1203718
def _render_list(data):
  
  return IPython.core.display.HTML(google.datalab.utils.commands.HtmlBuilder.render_list(data))
1031337
function Renderer(options) {
  var defaults = {
    headers: {
      included: true,
      downcase: true,
      upcase: true
    },

    delimiter: 'tab',
    decimalSign: 'comma',
    outputDataType: 'json',
    columnDelimiter: "\t",
    rowDelimiter: '\n',

    inputHeader: {},
    outputHeader: {},
    dataSelect: {},

    outputText: '',

    newline: '\n',
    indent: '  ',

    commentLine: '//',
    commentLineEnd: '',
    tableName: 'converter',

    useUnderscores: true,
    includeWhiteSpace: true,
    useTabsForIndent: false
  };

  this.options = merge({}, defaults, options);
  if (this.options.includeWhiteSpace) {
    this.options.newline = '\n';
  } else {
    this.options.indent = '';
    this.options.newline = '';
  }
}
1292005
function renderList() {
        var recentProjects = getRecentProjects(),
            currentProject = FileUtils.stripTrailingSlash(ProjectManager.getProjectRoot().fullPath),
            templateVars   = {
                projectList : [],
                Strings     : Strings
            };

        recentProjects.forEach(function (root) {
            if (root !== currentProject) {
                templateVars.projectList.push(parsePath(root));
            }
        });

        return Mustache.render(ProjectsMenuTemplate, templateVars);
    }
507151
private void render(List<T> data) {
        List<Widget> widgets = new ArrayList<>();
        for (T model : data) {
            Widget widget = renderer.render(model);
            widget.getElement().setId("item-" + itemCount);
            add(widget);
            widgets.add(widget);
            itemCount++;
        }

        // Check if recycling is enabled
        if (isEnableRecycling()) {
            recycleManager.recycleWidgets(widgets);
        }

        // Will force the scroll panel to have a scroll if it isn't visible
        if (!hasScrollBar()) {
            int height = $(widgets.get(0).getElement()).outerHeight();
            getElement().getStyle().setHeight(height, Style.Unit.PX);
        }
    }
1324905
public function renderBreadcrumb($class = 'breadcrumb', $itemClass = 'breadcrumb-item', $list = true) {
        $breadcrumb = new Breadcrumb();
        $breadcrumb->navArray = $this->navigation;
        return $breadcrumb->setBreacrumbLinks($this->currentArray)->createBreadcrumb($class, $itemClass, $list);
    }
1039769
function render(list) {
	const blank = new Array(process.stdout.rows).fill('\n')
	console.log(blank)
	readline.cursorTo(process.stdout, 0, 0)
	readline.clearScreenDown(process.stdout)
	list.forEach( user => {
		console.log(`${chalk.hsl(color(user.name),100,50)(user.name)}: ${user.id}`)
	})


}
1107111
def markdown(iterable, renderer=HTMLRenderer):
    
    with renderer() as renderer:
        return renderer.render(Document(iterable))
1049205
private void addList(final WList.Type type, final WList.Separator separator,
			final boolean renderBorder, final WComponent renderer) {
		WList list = new WList(type);

		if (separator != null) {
			list.setSeparator(separator);
		}

		list.setRenderBorder(renderBorder);
		list.setRepeatedComponent(renderer);
		add(list);

		lists.add(list);
	}
809087
def render(self, context, instance, placeholder):
        '''  '''
        context = super(LocationPlugin,self).render(context,instance,placeholder)
        context['location_list'] = [instance.location,]
        return context
742240
def render_children(self, block, view_name=None, context=None):
        
        results = []
        for child_id in block.children:
            child = self.get_block(child_id)
            result = self.render_child(child, view_name, context)
            results.append(result)
        return results
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