Renders breadcrumbs inside view.

 @param [Hash] options

 @api public
427530
def breadcrumb_trail(options = {})
      return enum_for(:breadcrumb_trail) unless block_given?

      valid?(options)
      options = Loaf.configuration.to_hash.merge(options)
      _breadcrumbs.each do |crumb|
        name = title_for(crumb.name)
        path = url_for(_expand_url(crumb.url))
        current = current_crumb?(path, crumb.match)

        yield(Loaf::Breadcrumb[name, path, current])
      end
    end
1208023
protected function renderCrumbs()
    {
        end($this->breadcrumbs);
        $lastKey = key($this->breadcrumbs);

        $output = '';

        $hrefSegments = array();

        $position = 1;

        foreach ($this->breadcrumbs as $key => $crumb) {
            $isLast = ($lastKey === $key);

            if ($crumb['hrefIsFullUrl']) {
                $hrefSegments = array();
            }

            if ($crumb['href']) {
                $hrefSegments[] = $crumb['href'];
            }

            $href = implode('/', $hrefSegments);

            if (!preg_match('#^https?://.*#', $href)) {
                $href = "/{$href}";
            }

            $output .= $this->renderCrumb($crumb['name'], $href, $isLast, $position);
            $position++;
        }

        return $output;
    }
38515
def add_options(*args, &block)
      options = args.extract_options!
      if !options.is_a?(HashWithIndifferentAccess)
        options = options.with_indifferent_access
      end
      options[:block] = block if block
      if render_strategy.nil?
        self.render_strategy = if options.is_a?(HashWithRenderStrategy)
          options.render_strategy
        else
          RENDERING_STRATEGIES.detect {|render_strategy| options[render_strategy].present? }
        end
      end

      super(*args, options)
    end
1261637
function renderHtml(fragment, opts) {
    var html = (!fragment || !u.trim(fragment._txt)) ?
      '&nbsp;' : // show space for empty/missing to allow selection/editing
      renderMarkdown(fragment._txt, opts);
    // use opts.noWrap to avoid breaking CSS nested selectors like li > ul in menus
    if (opts && opts.noWrap) return html;
    var href = (fragment && esc(fragment._href)) || '';
    return '<div data-render-html="' + href + '">' + html + '</div>';
  }
49548
function renderNavItems({ pages, ...params }) {
  return (
    <List>
      {pages.reduce(
        // eslint-disable-next-line no-use-before-define
        (items, page) => reduceChildRoutes({ items, page, ...params }),
        [],
      )}
    </List>
  );
}
982598
def render_item
      partial_opts = {
        title: title,
        subtitle: subtitle,
        description: description,
        url: url,
        image: image(@opts[:image_version]),
        type: list_item.type,
        object: object_available? ? list_item.object.decorate : nil
      }

      controller.render partial: @opts[:partial_path], locals: partial_opts, layout: false
    end
245000
def breadcrumbs
      return unless show_breadcrumbs?

      content_for(
        :breadcrumbs,
        content_tag(:ol, class: "breadcrumb") do
          concat(content_tag(:li, link_to("Home", root_path)))

          if can_view_resource_index?
            concat(
              content_tag(
                :li, controller_link
              )
            )
          end
        end
      )
    end
1373531
def render(options = {})
      options[:graph_id]    ||= 'scruffy_graph'
      options[:complexity]  ||= (global_complexity || :normal)

      # Allow subclasses to muck with components prior to renders.
      rendertime_renderer = self.clone
      rendertime_renderer.instance_eval { before_render if respond_to?(:before_render) }

      svg = Builder::XmlMarkup.new(:indent => 2)
      unless options[:no_doctype_header]
        svg.instruct!
        svg.declare! :DOCTYPE, :svg, :PUBLIC, "-//W3C//DTD SVG 1.0//EN", "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd"
      end
      svg.svg(:xmlns => "http://www.w3.org/2000/svg", 'xmlns:xlink' => "http://www.w3.org/1999/xlink", :width => options[:size].first, :height => options[:size].last) {
        svg.g(:id => options[:graph_id]) {
          rendertime_renderer.components.each do |component|
            component.render(svg, 
                             bounds_for( options[:size], component.position, component.size ), 
                             options)
          end
        }
      }
      svg.target!
    end
809947
def links
      @links ||= if @breadcrumb_key.present?
        # Reload breadcrumbs configuration if needed
        Gretel::Crumbs.reload_if_needed

        # Get breadcrumb set by the `breadcrumb` method
        crumb = Gretel::Crumb.new(context, breadcrumb_key, *breadcrumb_args)

        # Links of first crumb
        links = crumb.links.dup

        # Get parent links
        links.unshift *parent_links_for(crumb)

        links
      else
        []
      end
    end
144856
void showCrumbs(boolean show) {

        if (show) {
            m_crumbs.removeStyleName(OpenCmsTheme.HIDDEN);
            CmsAppWorkplaceUi.get().enableGlobalShortcuts();
        } else {
            m_crumbs.addStyleName(OpenCmsTheme.HIDDEN);
            CmsAppWorkplaceUi.get().disableGlobalShortcuts();
        }
    }
808699
function render (file, options, callback) {
    debug('render', file, options)
    // load layouts
    var layouts = loadLayouts(options)
    // load partials
    var partials = loadPartials(options)
    // get template function
    var template = loadTemplate(file, options)
    // wait for all promises to resolve
    return Promise.all([
        layouts,
        partials,
        template,
    ])
    // once all promises resolved render template
    .then(all => {
        var layouts = all[0]
        var partials = all[1]
        var template = all[2]
        // render options
        var hbsOptions = {
            helpers: GLOBAL.helpers,
            partials: partials,
        }
        // render template
        var body = template(options, hbsOptions)
        // get layout from options or default layout
        var layout = options.layout || GLOBAL.defaultLayout
        // use layout if found
        if (layout && layouts[layout]) {
            // pass layout contents of template render along with other params
            options.body = body
            // render layout
            body = layouts[layout](options, hbsOptions)
        }
        // if callback is passed then call with result
        if (callback) {
            callback(null, body)
        }
        // otherwise resolve with result
        else {
            return body
        }
    })
}
343891
public function post_breadcrumbs( $post_id, $options = array() ) {

		global $post;

		// Default options
		$defaults = array(
			'shorten'			=> 30,		// shorten post titles
			'show_parents'		=> true,	// show parents posts
		);
		$options = wp_parse_args( $options, $defaults );

		// Start breadcrumbs
		$post_breadcrumbs = array();

		// Get post
		if ( $post = get_post( $post_id ) ) {

			// Current post
			$title = get_the_title();
			if ( empty( $title ) ) { // no title? use post type or post format name?
				if ( $post_format = get_post_format() ) { // show post format if have it
					$title = get_post_format_string( $post_format );
				} elseif ( $post_type_obj = get_post_type_object( get_post_type() ) ) { // otherwise show post type name
					$title = $post_type_obj->labels->singular_name;
				}
			}

				// Tidy the title
				$title = $this->tidy_title( $title, $options );

				// Add breadcrumb
				$this->add_breadcrumb( $post_breadcrumbs, array(
					$title,
					get_permalink()
				) );

			// Parent posts?
			if ( $options['show_parents'] && ! empty( $post->post_parent ) ) {

				$parent_post_breadcrumbs = array();

				// Traverse through parent posts
				$parent_post_id = $post->post_parent;
				while ( $parent_post_id ) { // keep moving down levels until there are no more parent posts

					$parent_post = get_post( $parent_post_id );
					$parent_post_id  = $parent_post->post_parent; // if this parent has a parent, while loop will continue

					$parent_post_breadcrumbs[] = array(
						$this->tidy_title( get_the_title( $parent_post->ID ), $options ),
						get_permalink( $parent_post->ID )
					);

				}

				// Reverse parent post array and merge into main breadcrumbs
				$this->add_breadcrumbs_array( $post_breadcrumbs, array_reverse( $parent_post_breadcrumbs ) );

			}

		}

		return apply_filters( 'ctc_post_breadcrumbs', $post_breadcrumbs, $post_id );

	}
521962
def render
      rendered_items = ''
      swiper_classes = 'swiper-container list-generated-swiper'
      list_items = list.list_items.to_a

      list_items.each do |list_item|
        rendered_items += render_item(list_item)
      end

      if opts[:html_classes].present?
        opts[:html_classes] += " #{swiper_classes}"
      else
        opts[:html_classes] = swiper_classes
      end

      rendered_items = [
        "<div class='swiper-wrapper'>#{rendered_items}</div>",
        "<div class='swiper-button-prev'></div>",
        "<div class='swiper-button-next'></div>",
        "<div class='swiper-pagination'></div>"
      ].join

      content_tag :div, rendered_items, html_options, false
    end
83946
def render_association(association_data, options={})
      hash = {}

      if association_data.is_a?(Hash)
        association_data.each do |association, association_options|
          data = render_association(association, options.merge(:include => association_options))
          hash.merge!(data) if data
        end
      elsif association_data.is_a?(Array)
        association_data.each do |option|
          data = render_association(option)
          hash.merge!(data) if data
        end
      else
        if options[:preload]
          includes = options[:preload] == true ? options[:include] : options[:preload]
        end

        if (object = fetch_association(association_data, includes))
          data = ScopedSerializer.for(object, options.merge(:associations => options[:include])).as_json
          hash.merge!(data) if data
        end
      end

      hash
    end
346939
public function renderBreadcrumbs($key)
    {
        if (config('sleeping_owl.breadcrumbs')) {
            $this->breadcrumbs()->setView(
                $this->getViewPath('_partials.breadcrumbs')
            );

            return $this->breadcrumbs()->renderIfExists($key);
        }
    }
645459
public function onComponentsList()
    {
        if (!Breadcrumbs::exists('modules')) {
            Breadcrumbs::register('modules', function($breadcrumbs) {
                $breadcrumbs->push('Modules', handles('antares::modules'));
            });
        }
        view()->share('breadcrumbs', Breadcrumbs::render('modules'));
    }
336628
function(view, childView, options) {
    var buffer = view.buffer;

    childView = this.createChildView(childView, options);
    view._childViews.push(childView);

    childView.renderToBuffer(buffer);

    view.propertyDidChange('childViews');

    return childView;
  }