Returns trail of breadcrumbs (vertical cut, excluding base level)
434640
def _get_trail(request, exclude_section=False):
    
    trail = []
    url = request.path
    while url:
        if url == '/':
            break
        if exclude_section and url in SECTIONS:
            break
        crumb = find_crumb(request, url)
        if not crumb:
            break
        trail.append(crumb)

        # go one level up
        url = urljoin(url, '..')

    trail.reverse()

    return trail
29373
public function Breadcrumbs()
    {
        $basePath = str_replace(Director::protocolAndHost(), '', Director::absoluteBaseURL());
        $relPath = parse_url(
            substr($_SERVER['REQUEST_URI'], strlen($basePath), strlen($_SERVER['REQUEST_URI'])),
            PHP_URL_PATH
        );
        $parts = explode('/', $relPath);
        $base = Director::absoluteBaseURL();
        $pathPart = "";
        $pathLinks = array();
        foreach ($parts as $part) {
            if ($part != '') {
                $pathPart .= "$part/";
                $pathLinks[] = "<a href=\"$base$pathPart\">$part</a>";
            }
        }
        return implode('&nbsp;&rarr;&nbsp;', $pathLinks);
    }
756928
public synchronized List<Breadcrumb> getBreadcrumbs() {
        if (breadcrumbs == null || breadcrumbs.isEmpty()) {
            return Collections.emptyList();
        }

        List<Breadcrumb> copyList = new ArrayList<>(breadcrumbs.size());
        copyList.addAll(breadcrumbs);
        return copyList;
    }
1291869
public function Breadcrumbs($maxDepth = 20)
    {
        $items = array();
        
        $ancestors = $this->getAncestors(true);

        if($ancestors->exists()) {
            $items[] = $this;

            foreach($ancestors as $item) {
                $items[] = $item;
            }
        }

        $template = new SSViewer('BreadcrumbsTemplate');

        return $template->process($this->customise(ArrayData::create(array(
            'Pages' => ArrayList::create(array_reverse($items))
        ))));
    }
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
561402
function getSegmentedSubPaths(paths) {
    let segments = new Map();

    // Get earliest Path in tree where paths intersect
    paths[0].getDeepestCommonAncestorFrom(
      paths,
      (lastCommon, index, ancestries) => {
        // found the LCA
        if (!lastCommon.isProgram()) {
          let fnParent;
          if (
            lastCommon.isFunction() &&
            t.isBlockStatement(lastCommon.node.body)
          ) {
            segments.set(lastCommon, paths);
            return;
          } else if (
            !(fnParent = getFunctionParent(lastCommon)).isProgram() &&
            t.isBlockStatement(fnParent.node.body)
          ) {
            segments.set(fnParent, paths);
            return;
          }
        }
        // Deopt and construct segments otherwise
        for (const ancestor of ancestries) {
          const fnPath = getChildFuncion(ancestor);
          if (fnPath === void 0) {
            continue;
          }
          const validDescendants = paths.filter(p => {
            return p.isDescendant(fnPath);
          });
          segments.set(fnPath, validDescendants);
        }
      }
    );
    return segments;
  }
239040
public function getBreadCrumb()
    {
        $paths = [];
        $path = [];

        $baseLanguageId = \OxidEsales\Eshop\Core\Registry::getLang()->getBaseLanguage();
        $path['title'] = \OxidEsales\Eshop\Core\Registry::getLang()->translateString('ADDRESS', $baseLanguageId, false);
        $path['link'] = $this->getLink();

        $paths[] = $path;

        return $paths;
    }
186991
def handle_page_crumb(func):
    
    @wraps(func)
    def wrapper(path, model, page, root_name):
        path = PAGE_REGEXP.sub('', path)
        breadcrumbs = func(path, model, root_name)
        if page:
            if page.number > 1:
                breadcrumbs[-1].url = path
                page_crumb = Crumb(_('Page %s') % page.number)
                breadcrumbs.append(page_crumb)
        return breadcrumbs
    return wrapper
386237
def zinnia_breadcrumbs(context, root_name='',
                       template='zinnia/tags/breadcrumbs.html',):
    
    path = context['request'].path
    context_object = get_context_first_object(
        context, ['object', 'category', 'tag', 'author'])
    context_page = context.get('page_obj')
    breadcrumbs = retrieve_breadcrumbs(
        path, context_object, context_page, root_name)

    return {'template': template,
            'breadcrumbs': breadcrumbs}
297201
public function getBreadcrumbsData()
    {
        //ustawianie danych breadcrumbów
        return is_array($this->_breadcrumbsData) ? $this->_breadcrumbsData : ($this->_breadcrumbsData = self::$_navigation->getBreadcrumbs());
    }
292942
function getCrumbTrailXHTML( crumbs )
{
	var xhtml = '<span class="' + CSS_CLASS_TRAIL  + '">';
	xhtml += DISPLAY_PREPREND;

	for( var i = 0; i < crumbs.length; i++ )
	{
		xhtml += '<a href="' + crumbs[i][1] + '" class="' + CSS_CLASS_CRUMB + '">';
		xhtml += unescape( crumbs[i][0] ) + '</a>';
		if( i != (crumbs.length-1) )
		{
			xhtml += '<span class="' + CSS_CLASS_SEPARATOR + '">' + DISPLAY_SEPARATOR + '</span>';
		}
	}

	xhtml += DISPLAY_POSTPREND;
	xhtml += '</span>';

	return xhtml;
}
37501
public static function getFontAwesomeBreadcrumbNodes() {

        $breadcrumbNodes = [];

        $breadcrumbNodes[] = new BreadcrumbNode("label.edit_profile", "fa:user", "fos_user_profile_edit", NavigationInterface::NAVIGATION_MATCHER_ROUTER);
        $breadcrumbNodes[] = new BreadcrumbNode("label.show_profile", "fa:user", "fos_user_profile_show", NavigationInterface::NAVIGATION_MATCHER_ROUTER);
        $breadcrumbNodes[] = new BreadcrumbNode("label.change_password", "fa:lock", "fos_user_change_password", NavigationInterface::NAVIGATION_MATCHER_ROUTER);

        return $breadcrumbNodes;
    }
48962
def render(self):
        """"""
        breadcrumb_template = template.loader.get_template(self.template)
        extra_context = {"breadcrumb": self}
        return breadcrumb_template.render(extra_context, self.request)
451374
def find_paths_breadth_first(from_target, to_target, log):
  """"""
  log.debug('Looking for all paths from {} to {}'.format(from_target.address.reference(),
                                                         to_target.address.reference()))

  if from_target == to_target:
    yield [from_target]
    return

  visited_edges = set()
  to_walk_paths = deque([[from_target]])
  while len(to_walk_paths) > 0:
    cur_path = to_walk_paths.popleft()
    target = cur_path[-1]

    if len(cur_path) > 1:
      prev_target = cur_path[-2]
    else:
      prev_target = None
    current_edge = (prev_target, target)

    if current_edge not in visited_edges:
      for dep in target.dependencies:
        dep_path = cur_path + [dep]
        if dep == to_target:
          yield dep_path
        else:
          to_walk_paths.append(dep_path)
      visited_edges.add(current_edge)
290912
def _create_breadcrumbs(self, relpath):
    
    if relpath == '.':
      breadcrumbs = []
    else:
      path_parts = [os.path.basename(self._root)] + relpath.split(os.path.sep)
      path_links = ['/'.join(path_parts[1:i + 1]) for i, name in enumerate(path_parts)]
      breadcrumbs = [{'link_path': link_path, 'name': name}
                     for link_path, name in zip(path_links, path_parts)]
    return breadcrumbs
374884
def trace(self, context, obj):
		""""""
		
		root = obj
		
		if isroutine(obj):
			yield Crumb(self, root, endpoint=True, handler=obj, options=opts(obj))
			return
		
		for name, attr in getmembers(obj if isclass(obj) else obj.__class__):
			if name == '__getattr__':
				sig = signature(attr)
				path = '{' + list(sig.parameters.keys())[1] + '}'
				reta = sig.return_annotation
				
				if reta is not sig.empty:
					if callable(reta) and not isclass(reta):
						yield Crumb(self, root, path, endpoint=True, handler=reta, options=opts(reta))
					else:
						yield Crumb(self, root, path, handler=reta)
				
				else:
					yield Crumb(self, root, path, handler=attr)
				
				del sig, path, reta
				continue
			
			elif name == '__call__':
				yield Crumb(self, root, None, endpoint=True, handler=obj)
				continue
			
			if self.protect and name[0] == '_':
				continue
			
			yield Crumb(self, root, name,
					endpoint=callable(attr) and not isclass(attr), handler=attr, options=opts(attr))
676610
def parent_links_for(crumb)
      links = []
      while crumb = crumb.parent
        links.unshift *crumb.links
      end
      links
    end