laravel breadcrumbs
v9.0.0
Une manière simple de style Laravel de créer du fil d'Ariane.
Ce projet est le fork officiel du fantastiquement original Laravel Breadcrumbs de Dave James Miller et n'aurait pas été possible sans un groupe de contributeurs géniaux dès le premier jour. Merci à tous !
| Laravel | Fil d'Ariane 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 |
Pour les anciennes versions de Laravel, faites référence au projet GitHub d'origine. Toutes les balises ont été mises en miroir si vous préférez faire référence à ce package, mais n'apporteront aucune différence fonctionnelle.
composer require diglactic/laravel-breadcrumbs Créez un fichier appelé routes/breadcrumbs.php qui ressemble à ceci :
<?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 ));
});Voir la section Définir le fil d'Ariane pour plus de détails.
Par défaut, une liste de fils d'Ariane Bootstrap 5 sera affichée. Pour changer cela, initialisez le fichier de configuration en exécutant cette commande :
php artisan vendor:publish --tag=breadcrumbs-config Ensuite, ouvrez config/breadcrumbs.php et éditez cette ligne :
// config/breadcrumbs.php
' view ' => ' breadcrumbs::bootstrap5 ' ,Les valeurs possibles sont :
breadcrumbs::bootstrap5 – Bootstrap 5breadcrumbs::bootstrap4 – Bootstrap 4breadcrumbs::bulma – Bulmabreadcrumbs::foundation6 – Foundation 6breadcrumbs::json-ld – Données structurées JSON-LDbreadcrumbs::materialize – Matérialiserbreadcrumbs::tailwind – Tailwind CSSbreadcrumbs::uikit – UIkitpartials.breadcrumbsConsultez la section Modèles personnalisés pour plus de détails.
Vous pouvez également spécifier une vue personnalisée au moment de l'exécution.
Appelez Breadcrumbs::render() dans la vue de chaque page, en lui passant le nom du fil d'Ariane à utiliser et tous les paramètres supplémentaires :
{{-- resources/views/home.blade.php --}}
{{ Breadcrumbs :: render ( ' home ' ) } }
{{-- resources/views/categories/show.blade.php --}}
{{ Breadcrumbs :: render ( ' category ' , $category ) } }Consultez la section Sortie du fil d'Ariane pour d'autres options de sortie, et consultez Fil d'Ariane lié à un itinéraire pour savoir comment lier automatiquement les noms de fil d'Ariane aux noms de route.
Le fil d’Ariane correspondra généralement à des actions ou à des types de page. Pour chaque fil d'Ariane, vous spécifiez un nom, le titre du fil d'Ariane et l'URL vers laquelle le lier. Comme celles-ci sont susceptibles de changer dynamiquement, vous faites cela dans une fermeture et vous transmettez toutes les variables dont vous avez besoin dans la fermeture.
Les exemples suivants devraient le montrer clairement :
Le fil d’Ariane le plus simple sera probablement votre page d’accueil, qui ressemblera à ceci :
<?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 ' ));
});Pour générer l'URL, vous pouvez utiliser n'importe laquelle des méthodes standard de génération d'URL Laravel, notamment :
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() )'http://www.example.com/' )Cet exemple serait rendu comme ceci :
{{ Breadcrumbs :: render ( ' home ' ) } }Et cela donne ce résultat :
Maison
Il s'agit d'une autre page statique, mais avec un lien parent avant :
<?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 ' ));
}); Cela fonctionne en appelant la fermeture du fil d'Ariane home défini ci-dessus.
Cela serait rendu comme ceci :
{{ Breadcrumbs :: render ( ' blog ' ) } }Et cela donne ce résultat :
Accueil / Blogue
Notez que les modèles par défaut ne créent pas de lien vers le dernier fil d'Ariane (celui de la page actuelle), même lorsqu'une URL est spécifiée. Vous pouvez remplacer cela en créant votre propre modèle – voir Modèles personnalisés pour plus de détails.
Il s'agit d'une page générée dynamiquement extraite de la base de données :
<?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 ));
}); L'objet $post (probablement un modèle éloquent, mais pourrait être n'importe quoi) serait transmis depuis la vue :
{{ Breadcrumbs :: render ( ' post ' , $post ) } }Il en résulte cette sortie :
Accueil / Blog / Titre de l'article
Vous pouvez également enchaîner les appels de méthode à $trail . Si vous utilisez PHP 7.4 et versions ultérieures avec prise en charge des fonctions fléchées, vous préférerez peut-être la syntaxe suivante, plus concise :
Breadcrumbs:: for (
' post ' ,
fn ( BreadcrumbTrail $ trail , Post $ post ) => $ trail
-> parent ( ' blog ' )
-> push ( $ post -> title , route ( ' post ' , $ post ))
); Enfin, si vous avez des catégories imbriquées ou d'autres exigences particulières, vous pouvez appeler $trail->push() plusieurs fois :
<?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 ));
});Alternativement, vous pouvez créer une fonction récursive telle que celle-ci :
<?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 ));
});Les deux seraient rendus comme ceci :
{{ Breadcrumbs :: render ( ' category ' , $category ) } }Et cela donne ceci :
Accueil / Blog / Catégorie Grand-parent / Catégorie Parent / Titre de la catégorie
Pour personnaliser le HTML, créez votre propre fichier de vue semblable à celui-ci :
{{-- 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 >
@endunlessSi vous souhaitez travailler à partir d'un modèle intégré existant, exécutez la commande suivante :
php artisan vendor:publish --tag=breadcrumbs-views Cela copiera tous les modèles intégrés dans le répertoire resources/views/vendor/breadcrumbs/ de votre projet, vous permettant d'apporter des modifications directement.
La vue recevra une collection appelée $breadcrumbs .
Chaque fil d'Ariane est un objet avec les clés suivantes :
title – Le titre du fil d’Arianeurl – L'URL du fil d'Ariane, ou null si aucune n'a été donnée$data (voir Données personnalisées)Ensuite, mettez à jour votre fichier de configuration avec le nom de la vue personnalisée :
// config/breadcrumbs.php
' view ' => ' partials.breadcrumbs ' , // --> resources/views/partials/breadcrumbs.blade.php Alternativement, vous pouvez ignorer la vue personnalisée et appeler Breadcrumbs::generate() pour obtenir directement la collection de fils d'Ariane :
@foreach ( Breadcrumbs :: generate ( ' post ' , $post ) as $breadcrumb )
{{-- ... --}}
@endforeach Appelez Breadcrumbs::render() dans la vue de chaque page, en lui transmettant le nom du fil d'Ariane à utiliser et tous les paramètres supplémentaires.
{{ Breadcrumbs :: render ( ' home ' ) } }Ou avec un paramètre :
{{ Breadcrumbs :: render ( ' category ' , $category ) } } Pour afficher le fil d'Ariane sous forme de données structurées JSON-LD (généralement pour des raisons de référencement), utilisez Breadcrumbs::view() pour afficher le modèle breadcrumbs::json-ld en plus du modèle normal. Par exemple:
< html >
< head >
...
{{ Breadcrumbs :: view ( ' breadcrumbs::json-ld ' , ' category ' , $category ) } }
...
</ head >
< body >
...
{{ Breadcrumbs :: render ( ' category ' , $category ) } }
...
</ body >
</ html > (Remarque : si vous utilisez Laravel Page Speed, vous devrez peut-être désactiver le middleware TrimUrls .)
Pour spécifier une image, ajoutez-la au paramètre $data dans 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 )]);
});(Si vous préférez utiliser Microdata ou RDFa, vous devrez créer un modèle personnalisé.)
En utilisation normale, vous devez appeler Breadcrumbs::render($name, $params...) pour afficher le fil d'Ariane sur chaque page. Si vous préférez, vous pouvez nommer votre fil d'Ariane de la même manière que vos itinéraires et éviter cette duplication.
Assurez-vous que chacun de vos itinéraires a un nom.
<?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 ' );Pour plus de détails, consultez Routes nommées dans la documentation Laravel.
Pour chaque itinéraire, créez un fil d'Ariane avec le même nom et les mêmes paramètres. Par exemple:
<?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 ));
}); Pour ajouter un fil d'Ariane à une page 404 Not Found personnalisée, utilisez le nom errors.404 :
Breadcrumbs:: for ( ' errors.404 ' , function ( BreadcrumbTrail $ trail ) {
$ trail -> parent ( ' home ' );
$ trail -> push ( ' Page Not Found ' );
}); Appelez Breadcrumbs::render() sans aucun paramètre dans votre fichier de mise en page :
{{-- resources/views/app.blade.php --}}
{{ Breadcrumbs :: render () } } Cela affichera automatiquement le fil d’Ariane correspondant à l’itinéraire actuel. La même chose s'applique à Breadcrumbs::generate() et Breadcrumbs::view() :
Nous lancerons une InvalidBreadcrumbException si le fil d'Ariane n'existe pas, pour vous rappeler d'en créer un. Pour désactiver cela (par exemple si vous avez des pages sans fil d'Ariane), initialisez d'abord le fichier de configuration, si ce n'est pas déjà fait :
php artisan vendor:publish --tag=breadcrumbs-configOuvrez ensuite le fichier nouvellement créé et définissez cette valeur :
// config/breadcrumbs.php
' missing-route-bound-breadcrumb-exception ' => false, De même, pour éviter qu'il ne génère une UnnamedRouteException si la route actuelle n'a pas de nom, définissez cette valeur :
// config/breadcrumbs.php
' unnamed-route-exception ' => false,Laravel Breadcrumbs utilise la même liaison de modèle que le contrôleur. Par exemple:
<?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 ));
});Cela rend votre code moins verbeux et plus efficace en ne chargeant qu'une seule fois la publication depuis la base de données.
Pour plus de détails, voir Liaison de modèle de route dans la documentation Laravel.
Laravel crée automatiquement des noms de routes pour les contrôleurs ingénieux, par exemple photo.index , que vous pouvez utiliser lors de la définition de votre fil d'Ariane. Par exemple:
<?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 ));
});Pour plus de détails, consultez Contrôleurs de ressources dans la documentation Laravel.
(FAQ connexe : Pourquoi n'y a-t-il pas de méthode Breadcrumbs::resource() ?.)
Le deuxième paramètre de push() est facultatif, donc si vous voulez un fil d'Ariane sans URL, vous pouvez faire :
$ trail -> push ( ' Sample ' ); Dans ce cas, $breadcrumb->url sera null .
Les modèles Bootstrap par défaut fournis le rendent avec une classe CSS "active", la même que le dernier fil d'Ariane, car sinon, ils sont par défaut en texte noir et non gris, ce qui ne semble pas correct.
La méthode push() accepte un troisième paramètre facultatif, $data – un tableau de données associatives arbitraires à transmettre au fil d'Ariane, que vous pouvez utiliser dans votre modèle personnalisé.
Si vous souhaitez que chaque fil d'Ariane ait une icône, par exemple, vous pouvez faire :
$ trail -> push ( ' Home ' , ' / ' , [ ' icon ' => ' home.png ' ]); Les entrées du tableau $data seront fusionnées dans le fil d'Ariane en tant que propriétés.
< li >
< a href = " {{ $breadcrumb -> url } } " >
< img src = " /images/icons/ {{ $breadcrumb -> icon } } " >
{{ $breadcrumb -> title } }
</ a >
</ li > Remarque : n'utilisez pas les clés title ou url , car elles seront écrasées.
Vous pouvez enregistrer des rappels « avant » et « après » pour ajouter du fil d'Ariane au début/à la fin du parcours. Par exemple, pour ajouter automatiquement le numéro de la page actuelle à la fin :
<?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 }" );
}
}); Pour obtenir le dernier fil d'Ariane de la page en cours, utilisez Breadcrumb::current() . Par exemple, vous pouvez utiliser ceci pour afficher le titre de la page actuelle :
< title > {{ ( $breadcrumb = Breadcrumbs :: current ()) ? $breadcrumb -> title : ' Fallback Title ' } } </ title > Pour ignorer un fil d'Ariane, ajoutez 'current' => false au paramètre $data dans push() . Cela peut être utile pour ignorer le fil d'Ariane de pagination :
<?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 > Pour un filtrage plus avancé, utilisez plutôt Breadcrumbs::generate() et les méthodes de classe Collection de Laravel :
<?php
use Diglactic Breadcrumbs Breadcrumbs ;
$ current = Breadcrumbs:: generate ()-> where ( ' current ' , ' !== ' , false )-> last (); Vous pouvez utiliser Breadcrumbs::view() à la place de Breadcrumbs::render() pour afficher un modèle autre que celui par défaut :
{{ Breadcrumbs :: view ( ' partials.breadcrumbs2 ' , ' category ' , $category ) } } Ou vous pouvez remplacer le paramètre de configuration pour affecter tous les futurs appels render() :
<?php
use Illuminate Support Facades Config ;
Config:: set ( ' breadcrumbs.view ' , ' partials.breadcrumbs2 ' ); {{ Breadcrumbs :: render ( ' category ' , $category ) } } Ou vous pouvez appeler Breadcrumbs::generate() pour obtenir la collection de fils d'Ariane et charger la vue manuellement :
@include ( ' partials.breadcrumbs2 ' , [ ' breadcrumbs ' => Breadcrumbs :: generate ( ' category ' , $category )] ) Si vous appelez Breadcrumbs::render() ou Breadcrumbs::generate() sans paramètres, il utilisera le nom et les paramètres de la route actuelle par défaut (tels que renvoyés par la méthode Route::current() de Laravel).
Vous pouvez remplacer cela en appelant Breadcrumbs::setCurrentRoute($name, $param1, $param2...) .
Pour vérifier si un fil d'Ariane avec un nom donné existe, appelez Breadcrumbs::exists('name') , qui renvoie un booléen.
Si vous ne souhaitez pas utiliser routes/breadcrumbs.php , vous pouvez le modifier dans le fichier de configuration. Initialisez d'abord le fichier de configuration, si ce n'est pas déjà fait :
php artisan vendor:publish --tag=breadcrumbs-configMettez à jour cette ligne :
// config/breadcrumbs.php
' files ' => base_path ( ' routes/breadcrumbs.php ' ),Il peut s'agir d'un chemin absolu, comme ci-dessus, ou d'un tableau :
' files ' => [
base_path ( ' breadcrumbs/admin.php ' ),
base_path ( ' breadcrumbs/frontend.php ' ),
], Vous pouvez donc utiliser glob() pour rechercher automatiquement des fichiers à l'aide d'un caractère générique :
' files ' => glob ( base_path ( ' breadcrumbs/*.php ' )), Ou renvoyez un tableau vide [] pour désactiver le chargement.
Si vous créez votre propre package, chargez simplement votre fichier fil d'Ariane à partir de la méthode boot() de votre fournisseur de services :
use Illuminate Support ServiceProvider ;
class MyServiceProvider extends ServiceProvider
{
public function boot (): void
{
if ( class_exists ( ' Breadcrumbs ' )) {
require __DIR__ . ' /breadcrumbs.php ' ;
}
}
} Vous pouvez utiliser l'injection de dépendances pour accéder à l'instance Manager si vous préférez, au lieu d'utiliser la façade Breadcrumbs:: :
<?php
use Diglactic Breadcrumbs Manager ;
use Illuminate Support ServiceProvider ;
class MyServiceProvider extends ServiceProvider
{
public function boot ( Manager $ breadcrumbs ): void
{
$ breadcrumbs -> for (...);
}
} La classe Breadcrumbs Manager est macroable, vous pouvez donc ajouter vos propres méthodes. Par exemple:
<?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 > Pour des personnalisations plus avancées, vous pouvez sous-classer BreadcrumbsManager et/ou BreadcrumbsGenerator , puis mettre à jour le fichier de configuration avec le nouveau nom de classe :
// breadcrumbs/config.php
' manager-class ' => Diglactic Breadcrumbs Manager::class,
' generator-class ' => Diglactic Breadcrumbs Generator::class,Remarque : la syntaxe de configuration peut changer d'une version à l'autre.
Breadcrumbs::resource() ? Quelques personnes ont suggéré d'ajouter Breadcrumbs::resource() pour correspondre Route::resource() , mais personne n'a trouvé une bonne implémentation qui a) soit suffisamment flexible pour gérer les traductions, les ressources imbriquées, etc., et b ) n’est donc pas trop complexe.
Vous pouvez toujours créer le vôtre en utilisant Breadcrumbs::macro() . Voici un bon point de départ :
<?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 ' ); Notez que cela ne concerne pas les traductions ou les ressources imbriquées, et cela suppose que tous les modèles ont un attribut title (ce que les utilisateurs n'ont probablement pas). Adaptez-le comme bon vous semble.
composer update diglactic/laravel-breadcrumbs pour effectuer la mise à niveau.php artisan package:discover pour vous assurer que le fournisseur de services est détecté par Laravel. routes/breadcrumbs.php par défaut).dd(__FILE__) dans le fichier pour vous assurer qu'il est chargé.dd($files) dans ServiceProvider::registerBreadcrumbs() pour vérifier que le chemin est correct.php artisan config:clear (ou supprimez manuellement bootstrap/cache/config.php ) ou mettez à jour le chemin dans config/breadcrumbs.php .missing-route-bound-breadcrumb-exception sur false dans le fichier de configuration pour désactiver la vérification (mais vous ne serez pas averti si vous manquez des pages). php artisan config:clear (ou supprimez manuellement bootstrap/cache/config.php ) ou mettez à jour le chemin dans config/breadcrumbs.php . {{ Breadcrumbs::render() }} ou {{ Breadcrumbs::view() }} , pas @include() . Documentation : si vous pensez que la documentation peut être améliorée de quelque manière que ce soit, veuillez modifier ce fichier et faire une pull request.
Corrections de bugs : veuillez le corriger et ouvrir une pull request. (Voir ci-dessous pour des instructions plus détaillées.) Des points bonus si vous ajoutez un test unitaire pour vous assurer que cela ne se reproduise plus !
Nouvelles fonctionnalités : seules les fonctionnalités avec un cas d’utilisation clair et une API bien réfléchie seront acceptées. Ils doivent être documentés et inclure des tests unitaires. En cas de doute, effectuez une preuve de concept (soit du code, soit de la documentation) et ouvrez une pull request pour discuter des détails. (Conseil : si vous souhaitez qu'une fonctionnalité trop spécifique soit incluse par défaut, consultez Macros ou Utilisation avancée pour savoir comment les ajouter.)
Le moyen le plus simple de travailler sur Laravel Breadcrumbs est de dire à Composer de l'installer à partir des sources (Git) en utilisant l'option --prefer-source :
rm -rf vendor/diglactic/laravel-breadcrumbs
composer install --prefer-sourceEnsuite, extrayez la branche principale et créez votre propre branche locale sur laquelle travailler :
cd vendor/diglactic/laravel-breadcrumbs
git checkout -t origin/main
git checkout -b YOUR_BRANCHApportez maintenant vos modifications, y compris les tests unitaires et la documentation (le cas échéant). Exécutez les tests unitaires pour vous assurer que tout fonctionne toujours :
vendor/bin/phpunitValidez ensuite les modifications. Forkez le référentiel sur GitHub si vous ne l'avez pas déjà fait et transférez-y vos modifications :
git remote add YOUR_USERNAME [email protected]:YOUR_USERNAME/laravel-breadcrumbs.git
git push -u YOUR_USERNAME YOUR_BRANCHEnfin, accédez au référentiel sur GitHub et créez une pull request.
Pour utiliser votre propre fork dans un projet, mettez à jour le composer.json dans votre projet principal comme suit :
{
// ADD THIS:
"repositories" : [
{
"type" : "vcs" ,
"url" : "https://github.com/YOUR_USERNAME/laravel-breadcrumbs.git"
}
] ,
"require" : {
// UPDATE THIS:
"diglactic/laravel-breadcrumbs" : "dev-YOUR_BRANCH"
}
} Remplacez YOUR_USERNAME par votre nom d'utilisateur GitHub et YOUR_BRANCH par le nom de la branche (par exemple develop ). Cela indique à Composer d'utiliser votre référentiel au lieu de celui par défaut.
Pour exécuter les tests unitaires :
vendor/bin/phpunitPour exécuter les tests unitaires et reconstruire les instantanés :
vendor/bin/phpunit -d --update-snapshotsPour vérifier la couverture du code :
vendor/bin/phpunit --coverage-html test-coverage Ensuite, ouvrez test-coverage/index.html pour afficher les résultats. Soyez conscient des cas extrêmes de PHPUnit qui peuvent le rendre peu précis.
Les fichiers suivants devront être mis à jour pour exécuter des tests sur une nouvelle version de Laravel :
composer.json
laravel/framework (versions Laravel)php (version PHP minimale) tests.yml
jobs.phpunit.strategy.matrix.laravel (versions Laravel)jobs.phpunit.strategy.matrix.php (versions PHP)jobs.phpunit.strategy.matrix.exclude (combinaisons non prises en charge)Et la documentation suivante, si nécessaire :
README.md
UPGRADE.md
Laravel Breadcrumbs est un logiciel open source sous licence MIT.
