laravel breadcrumbs

Introdução

Uma maneira simples no estilo Laravel de criar migalhas de pão.

Este projeto é o fork oficial do fantasticamente original Laravel Breadcrumbs de Dave James Miller e não teria sido possível sem um monte de colaboradores incríveis no primeiro dia. Obrigado a todos!

Índice

• Tabela de compatibilidade
• Começando
• Definindo Breadcrumbs
• Modelos personalizados
• Saída de pão ralado
• Dados Estruturados
• Pão ralado ligado à rota
• Uso Avançado
• Perguntas frequentes
• Solução de problemas
• Contribuindo
• Licença

Tabela de compatibilidade

Laravel	Pão ralado Laravel
11.x	9.x
10.x	9.x
9.x	9.x
8.x	9.x
7.x	8.x
6.x	8.x

Para versões mais antigas do Laravel, consulte o projeto GitHub original. Todas as tags foram espelhadas se você preferir fazer referência a este pacote, mas não fornecerão nenhuma diferença funcional.

Começando

1. Instale

composer require diglactic/laravel-breadcrumbs

2. Definir

Crie um arquivo chamado routes/breadcrumbs.php parecido com este:

 <?php // routes/breadcrumbs.php

// Note: Laravel will automatically resolve `Breadcrumbs::` without
// this import. This is nice for IDE syntax and refactoring.
use Diglactic  Breadcrumbs  Breadcrumbs ;

// This import is also not required, and you could replace `BreadcrumbTrail $trail`
//  with `$trail`. This is nice for IDE type checking and completion.
use Diglactic  Breadcrumbs  Generator as BreadcrumbTrail ;

// Home
Breadcrumbs:: for ( ' home ' , function ( BreadcrumbTrail $ trail ) {
    $ trail -> push ( ' Home ' , route ( ' home ' ));
});

// Home > Blog
Breadcrumbs:: for ( ' blog ' , function ( BreadcrumbTrail $ trail ) {
    $ trail -> parent ( ' home ' );
    $ trail -> push ( ' Blog ' , route ( ' blog ' ));
});

// Home > Blog > [Category]
Breadcrumbs:: for ( ' category ' , function ( BreadcrumbTrail $ trail , $ category ) {
    $ trail -> parent ( ' blog ' );
    $ trail -> push ( $ category -> title , route ( ' category ' , $ category ));
});

Consulte a seção Definindo Breadcrumbs para obter mais detalhes.

3. Estilo

Por padrão, uma lista de navegação do Bootstrap 5 será renderizada. Para alterar isso, inicialize o arquivo de configuração executando este comando:

php artisan vendor:publish --tag=breadcrumbs-config

Em seguida, abra config/breadcrumbs.php e edite esta linha:

 // config/breadcrumbs.php

' view ' => ' breadcrumbs::bootstrap5 ' ,

Os valores possíveis são:

• breadcrumbs::bootstrap5 – Bootstrap 5
• breadcrumbs::bootstrap4 – Bootstrap 4
• breadcrumbs::bulma – Bulma
• breadcrumbs::foundation6 – Fundação 6
• breadcrumbs::json-ld – Dados estruturados JSON-LD
• breadcrumbs::materialize – Materializar
• breadcrumbs::tailwind – Tailwind CSS
• breadcrumbs::uikit – UIkit
• Ou você pode especificar o caminho para uma visualização personalizada, como partials.breadcrumbs

Consulte a seção Modelos personalizados para obter mais detalhes.

Você também pode especificar uma visualização personalizada em tempo de execução.

4. Saída

Chame Breadcrumbs::render() na visualização de cada página, passando o nome da localização atual a ser usada e quaisquer parâmetros adicionais:

 {{-- resources/views/home.blade.php --}}
{{ Breadcrumbs :: render ( ' home ' ) } }

{{-- resources/views/categories/show.blade.php --}}
{{ Breadcrumbs :: render ( ' category ' , $category ) } }

Consulte a seção Produzindo Breadcrumbs para outras opções de saída e consulte Route-Bound Breadcrumbs para obter uma maneira de vincular nomes de breadcrumbs a nomes de rotas automaticamente.

Definindo Breadcrumbs

A localização atual geralmente corresponderá a ações ou tipos de página. Para cada localização atual, você especifica um nome, o título da localização atual e o URL ao qual vinculá-la. Como é provável que elas mudem dinamicamente, você faz isso em um encerramento e passa quaisquer variáveis ​​necessárias para o encerramento.

Os exemplos a seguir devem deixar isso claro:

Páginas estáticas

A localização atual mais simples provavelmente será sua página inicial, que será mais ou menos assim:

 <?php // routes/breadcrumbs.php

use Diglactic  Breadcrumbs  Breadcrumbs ;
use Diglactic  Breadcrumbs  Generator as BreadcrumbTrail ;

Breadcrumbs:: for ( ' home ' , function ( BreadcrumbTrail $ trail ) {
     $ trail -> push ( ' Home ' , route ( ' home ' ));
});

Para gerar a URL, você pode usar qualquer um dos métodos padrão de geração de URL do Laravel, incluindo:

• url('path/to/route') ( URL::to() )
• secure_url('path/to/route')
• route('routename') ou route('routename', 'param') ou route('routename', ['param1', 'param2']) ( URL::route() )
• action('controller@action') ( URL::action() )
• Ou apenas passe um URL de string ( 'http://www.example.com/' )

Este exemplo seria renderizado assim:

 {{ Breadcrumbs :: render ( ' home ' ) } }

E resulte nesta saída:

Lar

Links pais

Esta é outra página estática, mas com um link pai antes dela:

 <?php // routes/breadcrumbs.php

use Diglactic  Breadcrumbs  Breadcrumbs ;
use Diglactic  Breadcrumbs  Generator as BreadcrumbTrail ;

Breadcrumbs:: for ( ' blog ' , function ( BreadcrumbTrail $ trail ) {
    $ trail -> parent ( ' home ' );
    $ trail -> push ( ' Blog ' , route ( ' blog ' ));
});

Funciona chamando o fechamento da trilha home definida acima.

Seria renderizado assim:

 {{ Breadcrumbs :: render ( ' blog ' ) } }

E resulte nesta saída:

Início / Blogue

Observe que os modelos padrão não criam um link para a última localização atual (aquela da página atual), mesmo quando uma URL é especificada. Você pode substituir isso criando seu próprio modelo – consulte Modelos personalizados para obter mais detalhes.

Títulos e links dinâmicos

Esta é uma página gerada dinamicamente extraída do banco de dados:

 <?php // routes/breadcrumbs.php

use App  Models  Post ;
use Diglactic  Breadcrumbs  Breadcrumbs ;
use Diglactic  Breadcrumbs  Generator as BreadcrumbTrail ;

Breadcrumbs:: for ( ' post ' , function ( BreadcrumbTrail $ trail , Post $ post ) {
    $ trail -> parent ( ' blog ' );
    $ trail -> push ( $ post -> title , route ( ' post ' , $ post ));
});

O objeto $post (provavelmente um modelo Eloquent, mas pode ser qualquer coisa) seria passado a partir da view:

 {{ Breadcrumbs :: render ( ' post ' , $post ) } }

Isso resulta nesta saída:

Início / Blog / Título da postagem

Você também pode encadear chamadas de método para $trail . Se você estiver usando PHP 7.4 e superior com suporte a função de seta, você pode preferir a seguinte sintaxe mais concisa:

Breadcrumbs:: for (
    ' post ' ,
    fn ( BreadcrumbTrail $ trail , Post $ post ) => $ trail
        -> parent ( ' blog ' )
        -> push ( $ post -> title , route ( ' post ' , $ post ))
);

Categorias aninhadas

Finalmente, se você tiver categorias aninhadas ou outros requisitos especiais, poderá chamar $trail->push() várias vezes:

 <?php // routes/breadcrumbs.php

use App  Models  Category ;
use Diglactic  Breadcrumbs  Breadcrumbs ;
use Diglactic  Breadcrumbs  Generator as BreadcrumbTrail ;

Breadcrumbs:: for ( ' category ' , function ( BreadcrumbTrail $ trail , Category $ category ) {
    $ trail -> parent ( ' blog ' );

    foreach ( $ category -> ancestors as $ ancestor ) {
        $ trail -> push ( $ ancestor -> title , route ( ' category ' , $ ancestor ));
    }

    $ trail -> push ( $ category -> title , route ( ' category ' , $ category ));
});

Alternativamente, você poderia criar uma função recursiva como esta:

 <?php // routes/breadcrumbs.php

use App  Models  Category ;
use Diglactic  Breadcrumbs  Breadcrumbs ;
use Diglactic  Breadcrumbs  Generator as BreadcrumbTrail ;

Breadcrumbs:: for ( ' category ' , function ( BreadcrumbTrail $ trail , Category $ category ) {
    if ( $ category -> parent ) {
        $ trail -> parent ( ' category ' , $ category -> parent );
    } else {
        $ trail -> parent ( ' blog ' );
    }

    $ trail -> push ( $ category -> title , route ( ' category ' , $ category -> slug ));
});

Ambos seriam renderizados assim:

 {{ Breadcrumbs :: render ( ' category ' , $category ) } }

E resulta nisso:

Home / Blog / Categoria Avós / Categoria Pai / Título da categoria

Modelos personalizados

Crie uma visualização

Para personalizar o HTML, crie seu próprio arquivo de visualização semelhante ao seguinte:

 {{-- resources/views/partials/breadcrumbs.blade.php --}}

@unless ( $breadcrumbs -> isEmpty () )
    < ol class = " breadcrumb " >
        @foreach ( $breadcrumbs as $breadcrumb )

            @if ( ! is_null ( $breadcrumb -> url ) && ! $loop -> last )
                < li class = " breadcrumb-item " >< a href = " {{ $breadcrumb -> url } } " > {{ $breadcrumb -> title } } </ a ></ li >
            @else
                < li class = " breadcrumb-item active " > {{ $breadcrumb -> title } } </ li >
            @endif

        @endforeach
    </ ol >
@endunless

Se você quiser trabalhar com um modelo integrado existente, execute o seguinte comando:

php artisan vendor:publish --tag=breadcrumbs-views

Isso copiará todos os modelos integrados no diretório resources/views/vendor/breadcrumbs/ do seu projeto, permitindo que você faça edições diretamente.

Ver dados

A visualização receberá uma coleção chamada $breadcrumbs .

Cada breadcrumb é um objeto com as seguintes chaves:

• title – O título da localização atual
• url – O URL de localização atual ou null se nenhum foi fornecido
• Além de chaves adicionais para cada item em $data (consulte Dados personalizados)

Atualize a configuração

Em seguida, atualize seu arquivo de configuração com o nome da visualização personalizada:

 // config/breadcrumbs.php

' view ' => ' partials.breadcrumbs ' , // --> resources/views/partials/breadcrumbs.blade.php

Ignorando a visualização

Alternativamente, você pode pular a visualização personalizada e chamar Breadcrumbs::generate() para obter a coleção de breadcrumbs diretamente:

 @foreach ( Breadcrumbs :: generate ( ' post ' , $post ) as $breadcrumb )
    {{-- ... --}}
@endforeach 

Saída de pão ralado

Chame Breadcrumbs::render() na visualização de cada página, passando o nome da localização atual a ser usada e quaisquer parâmetros adicionais.

Com lâmina

 {{ Breadcrumbs :: render ( ' home ' ) } }

Ou com um parâmetro:

 {{ Breadcrumbs :: render ( ' category ' , $category ) } } 

Dados Estruturados

Para renderizar breadcrumbs como dados estruturados JSON-LD (geralmente por motivos de SEO), use Breadcrumbs::view() para renderizar o modelo breadcrumbs::json-ld além do normal. Por exemplo:

< html >
    < head >
        ...
        {{ Breadcrumbs :: view ( ' breadcrumbs::json-ld ' , ' category ' , $category ) } }
        ...
    </ head >
    < body >
        ...
        {{ Breadcrumbs :: render ( ' category ' , $category ) } }
        ...
    </ body >
</ html >

(Observação: se você usar o Laravel Page Speed, pode ser necessário desabilitar o middleware TrimUrls .)

Para especificar uma imagem, adicione-a ao parâmetro $data em push() :

 <?php // routes/breadcrumbs.php

use App  Models  Post ;
use Diglactic  Breadcrumbs  Breadcrumbs ;
use Diglactic  Breadcrumbs  Generator as BreadcrumbTrail ;

Breadcrumbs:: for ( ' post ' , function ( BreadcrumbTrail $ trail , Post $ post ) {
    $ trail -> parent ( ' home ' );
    $ trail -> push ( $ post -> title , route ( ' post ' , $ post ), [ ' image ' => asset ( $ post -> image )]);
});

(Se preferir usar Microdata ou RDFa, você precisará criar um modelo personalizado.)

Pão ralado ligado à rota

No uso normal, você deve chamar Breadcrumbs::render($name, $params...) para renderizar a localização atual em cada página. Se preferir, você pode nomear sua localização atual da mesma forma que suas rotas e evitar essa duplicação.

Nomeie suas rotas

Certifique-se de que cada uma de suas rotas tenha um nome.

 <?php // routes/web.php

use Illuminate  Support  Facades  Route ;

// Home
Route:: name ( ' home ' )-> get ( ' / ' , ' HomeController@index ' );

// Home > [Post]
Route:: name ( ' post ' )-> get ( ' /post/{id} ' , ' PostController@show ' );

Para mais detalhes, veja Rotas Nomeadas na documentação do Laravel.

Dê um nome à sua localização atual para combinar

Para cada rota, crie uma localização atual com o mesmo nome e parâmetros. Por exemplo:

 <?php // routes/breadcrumbs.php

use App  Models  Post ;
use Diglactic  Breadcrumbs  Breadcrumbs ;
use Diglactic  Breadcrumbs  Generator as BreadcrumbTrail ;

// Home
Breadcrumbs:: for ( ' home ' , function ( BreadcrumbTrail $ trail ) {
     $ trail -> push ( ' Home ' , route ( ' home ' ));
});

// Home > [Post]
Breadcrumbs:: for ( ' post ' , function ( BreadcrumbTrail $ trail , Post $ post ) {
    $ trail -> parent ( ' home ' );
    $ trail -> push ( $ post -> title , route ( ' post ' , $ post ));
});

Para adicionar trilhas de navegação a uma página 404 Not Found personalizada, use o nome errors.404 :

Breadcrumbs:: for ( ' errors.404 ' , function ( BreadcrumbTrail $ trail ) {
    $ trail -> parent ( ' home ' );
    $ trail -> push ( ' Page Not Found ' );
});

Produza migalhas de pão em seu layout

Chame Breadcrumbs::render() sem parâmetros em seu arquivo de layout:

 {{-- resources/views/app.blade.php --}}

{{ Breadcrumbs :: render () } }

Isso gerará automaticamente trilhas correspondentes à rota atual. O mesmo se aplica a Breadcrumbs::generate() e Breadcrumbs::view() :

Exceções de vinculação de rota

Lançaremos uma InvalidBreadcrumbException se a localização atual não existir, para lembrá-lo de criar uma. Para desativar isso (por exemplo, se você tiver algumas páginas sem localização atual), primeiro inicialize o arquivo de configuração, se ainda não o fez:

php artisan vendor:publish --tag=breadcrumbs-config

Em seguida, abra o arquivo recém-criado e defina este valor:

 // config/breadcrumbs.php

' missing-route-bound-breadcrumb-exception ' => false,

Da mesma forma, para evitar que seja lançada uma UnnamedRouteException se a rota atual não tiver um nome, defina este valor:

 // config/breadcrumbs.php

' unnamed-route-exception ' => false,

Vinculação de modelo de rota

Laravel Breadcrumbs usa a mesma ligação de modelo que o controlador. Por exemplo:

 <?php // routes/web.php

use Illuminate  Support  Facades  Route ;

Route:: name ( ' post ' )-> get ( ' /post/{post} ' , ' PostController@show ' );

 <?php // app/Http/Controllers/PostController.php

use App  Http  Controllers  Controller ;
use App  Models  Post ;
use Illuminate  Contracts  View  View ;

class PostController extends Controller
{
    public function show ( Post $ post ): View // <-- Route bound model is injected here
    {
        return view ( ' post/show ' , [ ' post ' => $ post ]);
    }
}

 <?php // routes/breadcrumbs.php

use App  Models  Post ;
use Diglactic  Breadcrumbs  Breadcrumbs ;
use Diglactic  Breadcrumbs  Generator as BreadcrumbTrail ;

Breadcrumbs:: for ( ' post ' , function ( BreadcrumbTrail $ trail , Post $ post ) { // <-- The same Post model is injected here
    $ trail -> parent ( ' home ' );
    $ trail -> push ( $ post -> title , route ( ' post ' , $ post ));
});

Isso torna seu código menos detalhado e mais eficiente, carregando a postagem do banco de dados apenas uma vez.

Para mais detalhes veja Route Model Binding na documentação do Laravel.

Controladores engenhosos

O Laravel cria automaticamente nomes de rotas para controladores engenhosos, por exemplo photo.index , que você pode usar ao definir sua localização atual. Por exemplo:

 <?php // routes/web.php

use App  Http  Controllers  PhotoController ;
use Illuminate  Support  Facades  Route ;

Route:: resource ( ' photo ' , PhotoController::class);

 $ php artisan route:list
+--------+----------+--------------------+---------------+-------------------------+------------+
| Domain | Method   | URI                | Name          | Action                  | Middleware |
+--------+----------+--------------------+---------------+-------------------------+------------+
|        | GET|HEAD | photo              | photo.index   | PhotoController@index   |            |
|        | GET|HEAD | photo/create       | photo.create  | PhotoController@create  |            |
|        | POST     | photo              | photo.store   | PhotoController@store   |            |
|        | GET|HEAD | photo/{photo}      | photo.show    | PhotoController@show    |            |
|        | GET|HEAD | photo/{photo}/edit | photo.edit    | PhotoController@edit    |            |
|        | PUT      | photo/{photo}      | photo.update  | PhotoController@update  |            |
|        | PATCH    | photo/{photo}      |               | PhotoController@update  |            |
|        | DELETE   | photo/{photo}      | photo.destroy | PhotoController@destroy |            |
+--------+----------+--------------------+---------------+-------------------------+------------+

 <?php // routes/breadcrumbs.php

use App  Models  Photo ;
use Diglactic  Breadcrumbs  Breadcrumbs ;
use Diglactic  Breadcrumbs  Generator as BreadcrumbTrail ;

// Photos
Breadcrumbs:: for ( ' photo.index ' , function ( BreadcrumbTrail $ trail ) {
    $ trail -> parent ( ' home ' );
    $ trail -> push ( ' Photos ' , route ( ' photo.index ' ));
});

// Photos > Upload Photo
Breadcrumbs:: for ( ' photo.create ' , function ( BreadcrumbTrail $ trail ) {
    $ trail -> parent ( ' photo.index ' );
    $ trail -> push ( ' Upload Photo ' , route ( ' photo.create ' ));
});

// Photos > [Photo Name]
Breadcrumbs:: for ( ' photo.show ' , function ( BreadcrumbTrail $ trail , Photo $ photo ) {
    $ trail -> parent ( ' photo.index ' );
    $ trail -> push ( $ photo -> title , route ( ' photo.show ' , $ photo ));
});

// Photos > [Photo Name] > Edit Photo
Breadcrumbs:: for ( ' photo.edit ' , function ( BreadcrumbTrail $ trail , Photo $ photo ) {
    $ trail -> parent ( ' photo.show ' , $ photo );
    $ trail -> push ( ' Edit Photo ' , route ( ' photo.edit ' , $ photo ));
});

Para mais detalhes veja Controladores de Recursos na documentação do Laravel.

(FAQ relacionada: Por que não existe o método Breadcrumbs::resource()?.)

Uso Avançado

Breadcrumbs sem URL

O segundo parâmetro para push() é opcional, então se você quiser uma localização atual sem URL, você pode fazer:

 $ trail -> push ( ' Sample ' );

Neste caso, $breadcrumb->url será null .

Os modelos padrão do Bootstrap fornecidos renderizam isso com uma classe CSS "ativa", a mesma da última localização atual, porque, caso contrário, o padrão é o texto preto e não cinza, o que não parece correto.

Dados personalizados

O método push() aceita um terceiro parâmetro opcional, $data – uma matriz de matriz associativa arbitrária de dados a ser passada para a localização atual, que você pode usar em seu modelo personalizado.

Se você quiser que cada localização atual tenha um ícone, por exemplo, você pode fazer:

 $ trail -> push ( ' Home ' , ' / ' , [ ' icon ' => ' home.png ' ]);

As entradas da matriz $data serão mescladas na trilha como propriedades.

< li >
    < a href = " {{ $breadcrumb -> url } } " >
        < img src = " /images/icons/ {{ $breadcrumb -> icon } } " >
        {{ $breadcrumb -> title } }
    </ a >
</ li >

Nota: não utilize as chaves title ou url , pois elas serão sobrescritas.

Antes e depois dos retornos de chamada

Você pode registrar retornos de chamada "antes" e "depois" para adicionar trilhas no início/fim da trilha. Por exemplo, para adicionar automaticamente o número da página atual no final:

 <?php // routes/breadcrumbs.php

use Diglactic  Breadcrumbs  Breadcrumbs ;
use Diglactic  Breadcrumbs  Generator as BreadcrumbTrail ;

Breadcrumbs:: after ( function ( BreadcrumbTrail $ trail ) {
    $ page = ( int ) request ( ' page ' , 1 );

    if ( $ page > 1 ) {
        $ trail -> push ( " Page { $ page }" );
    }
});

Obtendo a localização atual da página

Para obter a última localização atual da página atual, use Breadcrumb::current() . Por exemplo, você poderia usar isto para gerar o título da página atual:

< title > {{ ( $breadcrumb = Breadcrumbs :: current ()) ? $breadcrumb -> title : ' Fallback Title ' } } </ title >

Para ignorar uma localização atual, adicione 'current' => false ao parâmetro $data em push() . Isso pode ser útil para ignorar a localização atual da paginação:

 <?php // routes/breadcrumbs.php

use Diglactic  Breadcrumbs  Breadcrumbs ;
use Diglactic  Breadcrumbs  Generator as BreadcrumbTrail ;

Breadcrumbs:: after ( function ( BreadcrumbTrail $ trail ) {
    $ page = ( int ) request ( ' page ' , 1 );

    if ( $ page > 1 ) {
        $ trail -> push ( " Page { $ page }" , null , [ ' current ' => false ]);
    }
});

< title >
    {{ ( $breadcrumb = Breadcrumbs :: current ()) ? " $breadcrumb -> title – " : ' ' } }
    {{ ( $page = ( int ) request ( ' page ' )) > 1 ? " Page $page – " : ' ' } }
    Demo App
</ title >

Para uma filtragem mais avançada, use Breadcrumbs::generate() e os métodos da classe Collection do Laravel:

 <?php

use Diglactic  Breadcrumbs  Breadcrumbs ;

$ current = Breadcrumbs:: generate ()-> where ( ' current ' , ' !== ' , false )-> last ();

Alternando visualizações em tempo de execução

Você pode usar Breadcrumbs::view() no lugar de Breadcrumbs::render() para renderizar um modelo diferente do padrão:

 {{ Breadcrumbs :: view ( ' partials.breadcrumbs2 ' , ' category ' , $category ) } }

Ou você pode substituir a configuração para afetar todas as chamadas futuras render() :

 <?php

use Illuminate  Support  Facades  Config ;

Config:: set ( ' breadcrumbs.view ' , ' partials.breadcrumbs2 ' );

 {{ Breadcrumbs :: render ( ' category ' , $category ) } }

Ou você pode chamar Breadcrumbs::generate() para obter a coleção de breadcrumbs e carregar a visualização manualmente:

 @include ( ' partials.breadcrumbs2 ' , [ ' breadcrumbs ' => Breadcrumbs :: generate ( ' category ' , $category )] )

Substituindo a rota "atual"

Se você chamar Breadcrumbs::render() ou Breadcrumbs::generate() sem parâmetros, ele usará o nome da rota atual e os parâmetros por padrão (conforme retornado pelo método Route::current() do Laravel).

Você pode substituir isso chamando Breadcrumbs::setCurrentRoute($name, $param1, $param2...) .

Verificando se existe uma localização atual

Para verificar se existe uma localização atual com um determinado nome, chame Breadcrumbs::exists('name') , que retorna um booleano.

Definindo breadcrumbs em um arquivo diferente

Se você não quiser usar routes/breadcrumbs.php , você pode alterá-lo no arquivo de configuração. Primeiro inicialize o arquivo de configuração, se ainda não o fez:

php artisan vendor:publish --tag=breadcrumbs-config

Atualize esta linha:

 // config/breadcrumbs.php

' files ' => base_path ( ' routes/breadcrumbs.php ' ),

Pode ser um caminho absoluto, como acima, ou um array:

 ' files ' => [
    base_path ( ' breadcrumbs/admin.php ' ),
    base_path ( ' breadcrumbs/frontend.php ' ),
],

Então você pode usar glob() para encontrar arquivos automaticamente usando um curinga:

 ' files ' => glob ( base_path ( ' breadcrumbs/*.php ' )),

Ou retorne um array vazio [] para desabilitar o carregamento.

Definindo/usando breadcrumbs em outro pacote

Se você estiver criando seu próprio pacote, simplesmente carregue seu arquivo de localização atual do método boot() do seu provedor de serviços:

 use Illuminate  Support  ServiceProvider ;

class MyServiceProvider extends ServiceProvider
{
    public function boot (): void
    {
        if ( class_exists ( ' Breadcrumbs ' )) {
            require __DIR__ . ' /breadcrumbs.php ' ;
        }
    }
}

Injeção de dependência

Você pode usar injeção de dependência para acessar a instância Manager se preferir, em vez de usar a fachada Breadcrumbs::

 <?php

use Diglactic  Breadcrumbs  Manager ;
use Illuminate  Support  ServiceProvider ;

class MyServiceProvider extends ServiceProvider
{
    public function boot ( Manager $ breadcrumbs ): void
    {
        $ breadcrumbs -> for (...);
    }
}

Macros

A classe Breadcrumbs Manager é macro, então você pode adicionar seus próprios métodos. Por exemplo:

 <?php

use Diglactic  Breadcrumbs  Breadcrumbs ;

Breadcrumbs:: macro ( ' pageTitle ' , function () {
    $ title = ( $ breadcrumb = Breadcrumbs:: current ()) ? "{ $ breadcrumb -> title } – " : '' ;

    if (( $ page = ( int ) request ( ' page ' )) > 1 ) {
        $ title .= " Page $ page – " ;
    }

    return "{ $ title } - Demo App " ;
});

< title > {{ Breadcrumbs :: pageTitle () } } </ title >

Personalização avançada

Para personalizações mais avançadas, você pode subclassificar BreadcrumbsManager e/ou BreadcrumbsGenerator e atualizar o arquivo de configuração com o novo nome da classe:

 // breadcrumbs/config.php

' manager-class ' => Diglactic  Breadcrumbs Manager::class,

' generator-class ' => Diglactic  Breadcrumbs Generator::class,

Nota: a sintaxe de configuração pode mudar entre as versões.

Perguntas frequentes

Por que não existe o método Breadcrumbs::resource() ?

Algumas pessoas sugeriram adicionar Breadcrumbs::resource() para corresponder Route::resource() , mas ninguém criou uma boa implementação que a) seja flexível o suficiente para lidar com traduções, recursos aninhados, etc., e b ) não é excessivamente complexo como resultado.

Você sempre pode criar o seu próprio usando Breadcrumbs::macro() . Aqui está um bom ponto de partida:

 <?php // routes/breadcrumbs.php

use App  Models  SomeModel ;
use Diglactic  Breadcrumbs  Breadcrumbs ;
use Diglactic  Breadcrumbs  Generator as BreadcrumbTrail ;

Breadcrumbs:: macro ( ' resource ' , function ( string $ name , string $ title ) {
    // Home > Blog
    Breadcrumbs:: for ( "{ $ name } .index " , function ( BreadcrumbTrail $ trail ) use ( $ name , $ title ) {
        $ trail -> parent ( ' home ' );
        $ trail -> push ( $ title , route ( "{ $ name } .index " ));
    });

    // Home > Blog > New
    Breadcrumbs:: for ( "{ $ name } .create " , function ( BreadcrumbTrail $ trail ) use ( $ name ) {
        $ trail -> parent ( "{ $ name } .index " );
        $ trail -> push ( ' New ' , route ( "{ $ name } .create " ));
    });

    // Home > Blog > Post 123
    Breadcrumbs:: for ( "{ $ name } .show " , function ( BreadcrumbTrail $ trail , SomeModel $ model ) use ( $ name ) {
        $ trail -> parent ( "{ $ name } .index " );
        $ trail -> push ( $ model -> title , route ( "{ $ name } .show " , $ model ));
    });

    // Home > Blog > Post 123 > Edit
    Breadcrumbs:: for ( "{ $ name } .edit " , function ( BreadcrumbTrail $ trail , SomeModel $ model ) use ( $ name ) {
        $ trail -> parent ( "{ $ name } .show " , $ model );
        $ trail -> push ( ' Edit ' , route ( "{ $ name } .edit " , $ model ));
    });
});

Breadcrumbs:: resource ( ' blog ' , ' Blog ' );
Breadcrumbs:: resource ( ' photos ' , ' Photos ' );
Breadcrumbs:: resource ( ' users ' , ' Users ' );

Observe que isso não trata de traduções ou recursos aninhados e pressupõe que todos os modelos tenham um atributo title (o que os usuários provavelmente não têm). Adapte-o como achar melhor.

Solução de problemas

Em geral

• Releia as instruções e certifique-se de ter feito tudo corretamente.
• Comece com as opções simples e só use as opções avançadas (por exemplo, Route-Bound Breadcrumbs) depois de entender como funciona.

Classe 'Breadcrumbs' não encontrada

• Tente executar composer update diglactic/laravel-breadcrumbs para atualizar.
• Tente executar php artisan package:discover para garantir que o provedor de serviços seja detectado pelo Laravel.

Breadcrumb não encontrado com nome...

• Certifique-se de registrar a localização atual no lugar certo ( routes/breadcrumbs.php por padrão).
  • Tente colocar dd(__FILE__) no arquivo para ter certeza de que está carregado.
  • Tente colocar dd($files) em ServiceProvider::registerBreadcrumbs() para verificar se o caminho está correto.
  • Caso contrário, tente executar php artisan config:clear (ou exclua manualmente bootstrap/cache/config.php ) ou atualize o caminho em config/breadcrumbs.php .
• Certifique-se de que o nome da localização atual esteja correto.
  • Se estiver usando Breadcrumbs Route-Bound, certifique-se de que corresponda exatamente ao nome da rota.
• Para suprimir esses erros ao usar Breadcrumbs Route-Bound (se você não quiser Breadcrumbs em algumas páginas):
  • Registre-os com um fechamento vazio (sem chamadas push/pai) ou
  • Defina missing-route-bound-breadcrumb-exception como false no arquivo de configuração para desabilitar a verificação (mas você não será avisado se perder alguma página).

ServiceProvider::registerBreadcrumbs(): Falha na abertura necessária...

• Certifique-se de que o caminho esteja correto.
• Nesse caso, verifique se a propriedade e as permissões do arquivo estão corretas.
• Caso contrário, tente executar php artisan config:clear (ou exclua manualmente bootstrap/cache/config.php ) ou atualize o caminho em config/breadcrumbs.php .

Variável indefinida: breadcrumbs

• Certifique-se de usar {{ Breadcrumbs::render() }} ou {{ Breadcrumbs::view() }} , não @include() .

Contribuindo

Documentação: Se você acha que a documentação pode ser melhorada de alguma forma, edite este arquivo e faça uma solicitação pull.

Correções de bugs: corrija-o e abra uma solicitação pull. (Veja abaixo instruções mais detalhadas.) Pontos de bônus se você adicionar um teste de unidade para garantir que isso não aconteça novamente!

Novos recursos: somente recursos com um caso de uso claro e API bem considerada serão aceitos. Eles devem ser documentados e incluir testes unitários. Em caso de dúvida, faça uma prova de conceito (código ou documentação) e abra uma solicitação pull para discutir os detalhes. (Dica: se você quiser que um recurso muito específico seja incluído por padrão, consulte Macros ou Uso Avançado para saber como adicioná-los.)

Criando uma solicitação pull

A maneira mais fácil de trabalhar no Laravel Breadcrumbs é dizer ao Composer para instalá-lo a partir do código-fonte (Git) usando o sinalizador --prefer-source :

rm -rf vendor/diglactic/laravel-breadcrumbs
composer install --prefer-source

Em seguida, verifique o branch principal e crie seu próprio branch local para trabalhar:

 cd vendor/diglactic/laravel-breadcrumbs
git checkout -t origin/main
git checkout -b YOUR_BRANCH

Agora faça suas alterações, incluindo testes unitários e documentação (se apropriado). Execute os testes de unidade para ter certeza de que tudo ainda está funcionando:

vendor/bin/phpunit

Em seguida, confirme as alterações. Bifurque o repositório no GitHub, se ainda não o fez, e envie suas alterações para ele:

git remote add YOUR_USERNAME [email protected]:YOUR_USERNAME/laravel-breadcrumbs.git
git push -u YOUR_USERNAME YOUR_BRANCH

Por fim, navegue até o repositório no GitHub e crie uma solicitação pull.

Usando seu fork em um projeto

Para usar seu próprio fork em um projeto, atualize o composer.json em seu projeto principal da seguinte maneira:

 {
    // ADD THIS:
    "repositories" : [
        {
            "type" : "vcs" ,
            "url" : "https://github.com/YOUR_USERNAME/laravel-breadcrumbs.git"
        }
    ] ,
    "require" : {
        // UPDATE THIS:
        "diglactic/laravel-breadcrumbs" : "dev-YOUR_BRANCH"
    }
}

Substitua YOUR_USERNAME pelo seu nome de usuário do GitHub e YOUR_BRANCH pelo nome do branch (por exemplo, develop ). Isso diz ao Composer para usar seu repositório em vez do padrão.

Testes unitários

Para executar os testes de unidade:

vendor/bin/phpunit

Para executar os testes de unidade e reconstruir snapshots:

vendor/bin/phpunit -d --update-snapshots

Para verificar a cobertura do código:

vendor/bin/phpunit --coverage-html test-coverage

Em seguida, abra test-coverage/index.html para ver os resultados. Esteja ciente dos casos extremos no PHPUnit que podem torná-lo não muito preciso.

Nova versão do Laravel

Os seguintes arquivos precisarão ser atualizados para executar testes em uma nova versão do Laravel:

• composer.json

  • laravel/framework (versões Laravel)
  • php (versão mínima do PHP)
  • Outras dependências (prefira as versões mais recentes disponíveis que funcionam para todas as combinações Laravel/PHP)

• tests.yml

  • jobs.phpunit.strategy.matrix.laravel (versões Laravel)
  • jobs.phpunit.strategy.matrix.php (versões PHP)
  • jobs.phpunit.strategy.matrix.exclude (combinações não suportadas)

E a seguinte documentação, conforme necessário:

• README.md

  • Tabela de compatibilidade

• UPGRADE.md

  • Adicionar nova seção detalhando quaisquer alterações significativas no pacote

Licença

Laravel Breadcrumbs é um software de código aberto licenciado sob a licença MIT.