laravel breadcrumbs

Introducción

Una forma sencilla al estilo Laravel de crear rutas de navegación.

Este proyecto es la bifurcación oficial del fantástico Laravel Breadcrumbs original de Dave James Miller y no habría sido posible sin un grupo de fantásticos colaboradores desde el primer día. ¡Gracias a todos!

Tabla de contenido

• Tabla de compatibilidad
• Empezando
• Definición de rutas de navegación
• Plantillas personalizadas
• Salida de rutas de navegación
• Datos estructurados
• Migas de pan con destino a la ruta
• Uso avanzado
• Preguntas frecuentes
• Solución de problemas
• Contribuyendo
• Licencia

Tabla de compatibilidad

Laravel	Pan rallado 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 versiones anteriores de Laravel, consulte el proyecto original de GitHub. Todas las etiquetas se han reflejado si prefiere hacer referencia a este paquete, pero no proporcionarán ninguna diferencia funcional.

Empezando

1. Instalar

composer require diglactic/laravel-breadcrumbs

2. Definir

Cree un archivo llamado routes/breadcrumbs.php que se vea así:

 <?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 la sección Definición de rutas de navegación para obtener más detalles.

3. Estilo

De forma predeterminada, se generará una lista de ruta de navegación de Bootstrap 5. Para cambiar esto, inicialice el archivo de configuración ejecutando este comando:

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

Luego, abra config/breadcrumbs.php y edite esta línea:

 // config/breadcrumbs.php

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

Los valores posibles son:

• breadcrumbs::bootstrap5 – Bootstrap 5
• breadcrumbs::bootstrap4 – Bootstrap 4
• breadcrumbs::bulma – Bulma
• breadcrumbs::foundation6 – Fundación 6
• breadcrumbs::json-ld – Datos estructurados JSON-LD
• breadcrumbs::materialize – Materializar
• breadcrumbs::tailwind – CSS de viento de cola
• breadcrumbs::uikit – UIkit
• O puede especificar la ruta a una vista personalizada, como partials.breadcrumbs

Consulte la sección Plantillas personalizadas para obtener más detalles.

También puede especificar una vista personalizada en tiempo de ejecución.

4. Salida

Llame Breadcrumbs::render() en la vista de cada página, pasándole el nombre de la ruta de navegación a usar y cualquier parámetro adicional:

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

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

Consulte la sección Generación de rutas de navegación para conocer otras opciones de salida y consulte Rutas de navegación vinculadas a rutas para conocer una forma de vincular nombres de rutas de navegación a nombres de rutas automáticamente.

Definición de rutas de navegación

Las rutas de navegación normalmente corresponderán a acciones o tipos de página. Para cada ruta de navegación, usted especifica un nombre, el título de la ruta de navegación y la URL a la que vincularla. Dado que es probable que cambien dinámicamente, esto se hace en un cierre y se pasan las variables que necesita al cierre.

Los siguientes ejemplos deberían dejarlo claro:

Páginas estáticas

La ruta de navegación más simple probablemente será su página de inicio, que se verá así:

 <?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 generar la URL, puede utilizar cualquiera de los métodos estándar de generación de URL de Laravel, que incluyen:

• url('path/to/route') ( URL::to() )
• secure_url('path/to/route')
• route('routename') o route('routename', 'param') o route('routename', ['param1', 'param2']) ( URL::route() )
• action('controller@action') ( URL::action() )
• O simplemente pase una URL de cadena ( 'http://www.example.com/' )

Este ejemplo se representaría así:

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

Y el resultado es este resultado:

Hogar

Enlaces para padres

Esta es otra página estática, pero con un enlace principal delante:

 <?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 llamando al cierre de la ruta de navegación home definida anteriormente.

Se representaría así:

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

Y el resultado es este resultado:

Inicio / Blog

Tenga en cuenta que las plantillas predeterminadas no crean un enlace para la última ruta de navegación (la de la página actual), incluso cuando se especifica una URL. Puede anular esto creando su propia plantilla; consulte Plantillas personalizadas para obtener más detalles.

Títulos y enlaces dinámicos.

Esta es una página generada dinámicamente extraída de la base de datos:

 <?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 ));
});

El objeto $post (probablemente un modelo elocuente, pero podría ser cualquier cosa) se pasaría desde la vista:

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

Resulta en esta salida:

Inicio / Blog / Título de la publicación

También puede encadenar llamadas a métodos a $trail . Si está utilizando PHP 7.4 y superior con soporte para la función de flecha, es posible que prefiera la siguiente sintaxis, más concisa:

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

Categorías anidadas

Finalmente, si tiene categorías anidadas u otros requisitos especiales, puede llamar $trail->push() varias veces:

 <?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, puedes crear una función 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 se representarían así:

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

Y resulta en esto:

Inicio / Blog / Categoría Abuelo / Categoría Principal / Título de la Categoría

Plantillas personalizadas

Crear una vista

Para personalizar el HTML, cree su propio archivo de vista similar al siguiente:

 {{-- 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

Si desea trabajar con una plantilla integrada existente, ejecute el siguiente comando:

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

Esto copiará todas las plantillas integradas en el directorio resources/views/vendor/breadcrumbs/ de su proyecto, lo que le permitirá realizar ediciones directamente.

Ver datos

La vista recibirá una colección llamada $breadcrumbs .

Cada ruta de navegación es un objeto con las siguientes claves:

• title : el título de la ruta de navegación
• url : la URL de ruta de navegación, o null si no se proporcionó ninguna
• Además de claves adicionales para cada elemento en $data (consulte Datos personalizados)

Actualiza la configuración

Luego, actualice su archivo de configuración con el nombre de la vista personalizada:

 // config/breadcrumbs.php

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

Saltándose la vista

Alternativamente, puede omitir la vista personalizada y llamar Breadcrumbs::generate() para obtener la colección de rutas de navegación directamente:

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

Salida de rutas de navegación

Llame Breadcrumbs::render() en la vista de cada página, pasándole el nombre de la ruta de navegación a usar y cualquier parámetro adicional.

Con hoja

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

O con un parámetro:

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

Datos estructurados

Para representar las rutas de navegación como datos estructurados JSON-LD (generalmente por razones de SEO), use Breadcrumbs::view() para representar la plantilla de breadcrumbs::json-ld además de la normal. Por ejemplo:

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

(Nota: si utiliza Laravel Page Speed, es posible que deba desactivar el middleware TrimUrls ).

Para especificar una imagen, agréguela al parámetro $data en 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 prefiere utilizar Microdatos o RDFa, deberá crear una plantilla personalizada).

Migas de pan con destino a la ruta

En uso normal, debe llamar Breadcrumbs::render($name, $params...) para representar las rutas de navegación en cada página. Si lo prefieres, puedes nombrar tus rutas de navegación igual que tus rutas y evitar esta duplicación.

Nombra tus rutas

Asegúrate de que cada una de tus rutas tenga un nombre.

 <?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 obtener más detalles, consulte Rutas con nombre en la documentación de Laravel.

Nombra tus rutas de navegación para que coincidan

Para cada ruta, cree una ruta de navegación con el mismo nombre y parámetros. Por ejemplo:

 <?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 agregar rutas de navegación a una página 404 No encontrada personalizada, use el nombre errors.404 :

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

Genera rutas de navegación en tu diseño

Llame Breadcrumbs::render() sin parámetros en su archivo de diseño:

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

{{ Breadcrumbs :: render () } }

Esto generará automáticamente rutas de navegación correspondientes a la ruta actual. Lo mismo se aplica a Breadcrumbs::generate() y Breadcrumbs::view() :

Excepciones de enlace de ruta

Lanzaremos una InvalidBreadcrumbException si la ruta de navegación no existe, para recordarle que debe crear una. Para desactivar esto (por ejemplo, si tiene algunas páginas sin rutas de navegación), primero inicialice el archivo de configuración, si aún no lo ha hecho:

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

Luego abra el archivo recién creado y establezca este valor:

 // config/breadcrumbs.php

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

De manera similar, para evitar que arroje una UnnamedRouteException si la ruta actual no tiene un nombre, establezca este valor:

 // config/breadcrumbs.php

' unnamed-route-exception ' => false,

Enlace del modelo de ruta

Laravel Breadcrumbs utiliza el mismo enlace de modelo que el controlador. Por ejemplo:

 <?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 ));
});

Esto hace que su código sea menos detallado y más eficiente al cargar la publicación desde la base de datos solo una vez.

Para obtener más detalles, consulte Enlace de modelo de ruta en la documentación de Laravel.

Controladores ingeniosos

Laravel crea automáticamente nombres de rutas para controladores ingeniosos, por ejemplo, photo.index , que puede usar al definir sus rutas de navegación. Por ejemplo:

 <?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 obtener más detalles, consulte Controladores de recursos en la documentación de Laravel.

(Preguntas frecuentes relacionadas: ¿Por qué no existe el método Breadcrumbs::resource()?).

Uso avanzado

Rutas de navegación sin URL

El segundo parámetro para push() es opcional, por lo que si desea una ruta de navegación sin URL, puede hacer:

 $ trail -> push ( ' Sample ' );

En este caso, $breadcrumb->url será null .

Las plantillas Bootstrap predeterminadas proporcionadas representan esto con una clase CSS de "activo", igual que la última ruta de navegación, porque de lo contrario, el texto predeterminado es negro, no gris, lo que no se ve bien.

Datos personalizados

El método push() acepta un tercer parámetro opcional, $data , una matriz de datos asociativos arbitrarios que se pasarán a la ruta de navegación, que puede usar en su plantilla personalizada.

Si desea que cada ruta de navegación tenga un ícono, por ejemplo, puede hacer lo siguiente:

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

Las entradas de la matriz $data se fusionarán en la ruta de navegación como propiedades.

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

Nota: no utilice las claves title o url , ya que se sobrescribirán.

Antes y después de las devoluciones de llamada

Puede registrar devoluciones de llamada "antes" y "después" para agregar rutas de navegación al inicio/final del recorrido. Por ejemplo, para agregar automáticamente el número de página actual al 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 }" );
    }
});

Obtener la ruta de navegación de la página actual

Para obtener la última ruta de navegación de la página actual, utilice Breadcrumb::current() . Por ejemplo, podrías usar esto para generar el título de la página actual:

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

Para ignorar una ruta de navegación, agregue 'current' => false al parámetro $data en push() . Esto puede resultar útil para ignorar las rutas de navegación de paginación:

 <?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 un filtrado más avanzado, utilice los métodos de clase Breadcrumbs::generate() y Collection de Laravel:

 <?php

use Diglactic  Breadcrumbs  Breadcrumbs ;

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

Cambiar vistas en tiempo de ejecución

Puedes usar Breadcrumbs::view() en lugar de Breadcrumbs::render() para representar una plantilla distinta a la predeterminada:

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

O puede anular la configuración para afectar todas las futuras llamadas render() :

 <?php

use Illuminate  Support  Facades  Config ;

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

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

O puede llamar a Breadcrumbs::generate() para obtener la colección de rutas de navegación y cargar la vista manualmente:

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

Anulación de la ruta "actual"

Si llama a Breadcrumbs::render() o Breadcrumbs::generate() sin parámetros, utilizará el nombre de la ruta actual y los parámetros de forma predeterminada (según lo devuelto por el método Route::current() de Laravel).

Puede anular esto llamando Breadcrumbs::setCurrentRoute($name, $param1, $param2...) .

Comprobando si existe una ruta de navegación

Para comprobar si existe una ruta de navegación con un nombre determinado, llame Breadcrumbs::exists('name') , que devuelve un valor booleano.

Definir rutas de navegación en un archivo diferente

Si no desea utilizar routes/breadcrumbs.php , puede cambiarlo en el archivo de configuración. Primero inicialice el archivo de configuración, si aún no lo ha hecho:

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

Actualiza esta línea:

 // config/breadcrumbs.php

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

Puede ser una ruta absoluta, como arriba, o una matriz:

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

Entonces puedes usar glob() para buscar archivos automáticamente usando un comodín:

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

O devolver una matriz vacía [] para deshabilitar la carga.

Definir/usar rutas de navegación en otro paquete

Si está creando su propio paquete, simplemente cargue su archivo de ruta de navegación desde el método boot() de su proveedor de servicios:

 use Illuminate  Support  ServiceProvider ;

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

inyección de dependencia

Puede usar la inyección de dependencia para acceder a la instancia Manager si lo prefiere, en lugar de usar la fachada Breadcrumbs::

 <?php

use Diglactic  Breadcrumbs  Manager ;
use Illuminate  Support  ServiceProvider ;

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

macros

La clase Manager de rutas de navegación es macroable, por lo que puedes agregar tus propios métodos. Por ejemplo:

 <?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 >

Personalización avanzada

Para personalizaciones más avanzadas, puede crear una subclase BreadcrumbsManager y/o BreadcrumbsGenerator y luego actualizar el archivo de configuración con el nuevo nombre de clase:

 // breadcrumbs/config.php

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

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

Nota: la sintaxis de configuración puede cambiar entre versiones.

Preguntas frecuentes

¿Por qué no existe el método Breadcrumbs::resource() ?

Algunas personas han sugerido agregar Breadcrumbs::resource() para que coincida con Route::resource() , pero nadie ha encontrado una buena implementación que a) sea lo suficientemente flexible para manejar traducciones, recursos anidados, etc., yb ) no es demasiado complejo como resultado.

Siempre puedes crear el tuyo propio usando Breadcrumbs::macro() . He aquí un buen punto 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 ' );

Tenga en cuenta que esto no trata de traducciones ni recursos anidados, y supone que todos los modelos tienen un atributo title (que los usuarios probablemente no tengan). Adáptalo como mejor te parezca.

Solución de problemas

General

• Vuelve a leer las instrucciones y asegúrate de haber hecho todo correctamente.
• Comience con las opciones simples y solo use las opciones avanzadas (por ejemplo, rutas de navegación vinculadas) una vez que comprenda cómo funciona.

Clase 'Breadcrumbs' no encontrada

• Intente ejecutar composer update diglactic/laravel-breadcrumbs para actualizar.
• Intente ejecutar php artisan package:discover para asegurarse de que Laravel detecte el proveedor de servicios.

Ruta de navegación no encontrada con nombre...

• Asegúrese de registrar las rutas de navegación en el lugar correcto ( routes/breadcrumbs.php de forma predeterminada).
  • Intente poner dd(__FILE__) en el archivo para asegurarse de que esté cargado.
  • Intente poner dd($files) en ServiceProvider::registerBreadcrumbs() para verificar que la ruta sea correcta.
  • De lo contrario, intente ejecutar php artisan config:clear (o elimine manualmente bootstrap/cache/config.php ) o actualice la ruta en config/breadcrumbs.php .
• Asegúrese de que el nombre de la ruta de navegación sea correcto.
  • Si utiliza rutas de navegación vinculadas a rutas, asegúrese de que coincida exactamente con el nombre de la ruta.
• Para suprimir estos errores al utilizar rutas de navegación vinculadas (si no desea rutas de navegación en algunas páginas), haga lo siguiente:
  • Regístrelos con un cierre vacío (sin notificaciones/llamadas a los padres), o
  • Establezca missing-route-bound-breadcrumb-exception en false en el archivo de configuración para deshabilitar la verificación (pero no se le advertirá si se pierde alguna página).

ServiceProvider::registerBreadcrumbs(): Error en la apertura requerida...

• Asegúrese de que la ruta sea correcta.
• Si es así, verifique que la propiedad y los permisos del archivo sean correctos.
• De lo contrario, intente ejecutar php artisan config:clear (o elimine manualmente bootstrap/cache/config.php ) o actualice la ruta en config/breadcrumbs.php .

Variable indefinida: rutas de navegación

• Asegúrate de usar {{ Breadcrumbs::render() }} o {{ Breadcrumbs::view() }} , no @include() .

Contribuyendo

Documentación: si cree que la documentación se puede mejorar de alguna manera, edite este archivo y realice una solicitud de extracción.

Corrección de errores: corríjalo y abra una solicitud de extracción. (Consulte a continuación para obtener instrucciones más detalladas). Puntos de bonificación si agrega una prueba unitaria para asegurarse de que no vuelva a suceder.

Nuevas funciones: solo se aceptarán funciones con un caso de uso claro y una API bien considerada. Deben estar documentados e incluir pruebas unitarias. En caso de duda, haga una prueba de concepto (ya sea código o documentación) y abra una solicitud de extracción para discutir los detalles. (Consejo: si desea que una función sea demasiado específica para incluirse de forma predeterminada, consulte Macros o Uso avanzado para conocer formas de agregarlas).

Creando una solicitud de extracción

La forma más sencilla de trabajar en Laravel Breadcrumbs es decirle a Composer que lo instale desde el código fuente (Git) usando el indicador --prefer-source :

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

Luego, consulte la sucursal principal y cree su propia sucursal local en la que trabajar:

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

Ahora realice sus cambios, incluidas las pruebas unitarias y la documentación (si corresponde). Ejecute las pruebas unitarias para asegurarse de que todo siga funcionando:

vendor/bin/phpunit

Luego confirme los cambios. Bifurca el repositorio en GitHub si aún no lo has hecho y envíale tus cambios:

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

Finalmente, busque el repositorio en GitHub y cree una solicitud de extracción.

Usando tu tenedor en un proyecto

Para usar su propia bifurcación en un proyecto, actualice el composer.json en su proyecto principal de la siguiente manera:

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

Reemplace YOUR_USERNAME con su nombre de usuario de GitHub y YOUR_BRANCH con el nombre de la rama (por ejemplo, develop ). Esto le indica a Composer que use su repositorio en lugar del predeterminado.

Pruebas unitarias

Para ejecutar las pruebas unitarias:

vendor/bin/phpunit

Para ejecutar las pruebas unitarias y reconstruir instantáneas:

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

Para verificar la cobertura del código:

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

Luego abra test-coverage/index.html para ver los resultados. Tenga en cuenta los casos extremos en PHPUnit que pueden hacer que no sea del todo preciso.

Nueva versión de Laravel

Será necesario actualizar los siguientes archivos para ejecutar pruebas con una nueva versión de Laravel:

• composer.json

  • laravel/framework (versiones de Laravel)
  • php (versión mínima de PHP)
  • Otras dependencias (prefiero pasar a las versiones más altas disponibles que funcionan para todas las combinaciones de Laravel/PHP)

• tests.yml

  • jobs.phpunit.strategy.matrix.laravel (versiones Laravel)
  • jobs.phpunit.strategy.matrix.php (versiones PHP)
  • jobs.phpunit.strategy.matrix.exclude (combinaciones no admitidas)

Y la siguiente documentación, según sea necesario:

• README.md

  • Tabla de compatibilidad

• UPGRADE.md

  • Agregar una nueva sección que detalla cualquier cambio importante en el paquete

Licencia

Laravel Breadcrumbs es un software de código abierto con licencia MIT.