├── 3 ├── artisan │ ├── commands.md │ └── tasks.md ├── auth │ ├── config.md │ └── usage.md ├── bundles.md ├── cache │ ├── config.md │ └── usage.md ├── changes.md ├── config.md ├── contents.md ├── contrib │ ├── command-line.md │ ├── github.md │ └── tortoisegit.md ├── controleurs.md ├── database │ ├── config.md │ ├── eloquent.md │ ├── fluent.md │ ├── migrations.md │ ├── raw.md │ ├── redis.md │ └── schema.md ├── encryption.md ├── evenements.md ├── files.md ├── home.md ├── input.md ├── installation.md ├── ioc.md ├── loading.md ├── localization.md ├── logging.md ├── modeles.md ├── profiler.md ├── requests.md ├── routes.md ├── session │ ├── config.md │ └── usage.md ├── strings.md ├── testing.md ├── urls.md ├── validation.md └── vues │ ├── assets.md │ ├── formulaires.md │ ├── home.md │ ├── html.md │ ├── pagination.md │ └── templating.md ├── .gitignore ├── 4.0 ├── artisan.md ├── cache.md ├── commands.md ├── configuration.md ├── contributing.md ├── controllers.md ├── database.md ├── documentation.md ├── eloquent.md ├── errors.md ├── events.md ├── extending.md ├── facades.md ├── helpers.md ├── home.md ├── html.md ├── installation.md ├── introduction.md ├── ioc.md ├── lifecycle.md ├── localization.md ├── mail.md ├── migrations.md ├── packages.md ├── pagination.md ├── queries.md ├── queues.md ├── quick.md ├── redis.md ├── requests.md ├── responses.md ├── routing.md ├── schema.md ├── security.md ├── session.md ├── templates.md ├── testing.md └── validation.md ├── 4.1 ├── artisan.md ├── cache.md ├── commands.md ├── configuration.md ├── contributing.md ├── controllers.md ├── database.md ├── documentation.md ├── eloquent.md ├── errors.md ├── events.md ├── extending.md ├── facades.md ├── helpers.md ├── home.md ├── html.md ├── installation.md ├── introduction.md ├── ioc.md ├── license.md ├── lifecycle.md ├── localization.md ├── mail.md ├── migrations.md ├── packages.md ├── pagination.md ├── queries.md ├── queues.md ├── quick.md ├── readme.md ├── redis.md ├── releases.md ├── requests.md ├── responses.md ├── routing.md ├── schema.md ├── security.md ├── session.md ├── ssh.md ├── templates.md ├── testing.md ├── upgrade.md └── validation.md ├── 4.2 ├── artisan.md ├── billing.md ├── cache.md ├── commands.md ├── configuration.md ├── contributing.md ├── controllers.md ├── database.md ├── documentation.md ├── eloquent.md ├── errors.md ├── events.md ├── extending.md ├── facades.md ├── helpers.md ├── home.md ├── homestead.md ├── html.md ├── installation.md ├── introduction.md ├── ioc.md ├── license.md ├── lifecycle.md ├── localization.md ├── mail.md ├── migrations.md ├── packages.md ├── pagination.md ├── queries.md ├── queues.md ├── quick.md ├── readme.md ├── redis.md ├── releases.md ├── requests.md ├── responses.md ├── routing.md ├── schema.md ├── security.md ├── session.md ├── ssh.md ├── templates.md ├── testing.md ├── upgrade.md └── validation.md ├── README.md └── dev ├── artisan.md ├── cache.md ├── commands.md ├── configuration.md ├── contributing.md ├── controllers.md ├── database.md ├── documentation.md ├── eloquent.md ├── errors.md ├── events.md ├── extending.md ├── facades.md ├── helpers.md ├── home.md ├── html.md ├── installation.md ├── introduction.md ├── ioc.md ├── license.md ├── lifecycle.md ├── localization.md ├── mail.md ├── migrations.md ├── packages.md ├── pagination.md ├── queries.md ├── queues.md ├── quick.md ├── readme.md ├── redis.md ├── releases.md ├── requests.md ├── responses.md ├── routing.md ├── schema.md ├── security.md ├── session.md ├── ssh.md ├── templates.md ├── testing.md ├── upgrade.md └── validation.md /.gitignore: -------------------------------------------------------------------------------- 1 | *.sublime* 2 | .DS_Store 3 | -------------------------------------------------------------------------------- /3/artisan/commands.md: -------------------------------------------------------------------------------- 1 | # Commandes d'Artisan 2 | 3 | ## Au menu 4 | 5 | - [Aide](#help) 6 | - [Configuration de l'application](#application-configuration) 7 | - [Sessions en base de données](#sessions) 8 | - [Migrations](#migrations) 9 | - [Bundles](#bundles) 10 | - [Tâches](#tasks) 11 | - [Tests unitaires](#unit-tests) 12 | - [Routage](#routing) 13 | - [Clé d'application](#keys) 14 | - [Options en ligne de commandes](#cli-options) 15 | 16 | 17 | ## Aide 18 | 19 | Description | Commande 20 | ------------- | ------------- 21 | Affiche une liste de commandes disponibles. | `php artisan help:commands` 22 | 23 | 24 | ## Configuration de l'application [(Plus d'infos)](/3/install#basic-configuration) 25 | 26 | Description | Commande 27 | ------------- | ------------- 28 | Génère une clé d'application sécurisée. Cette clé ne sera générée que si le champs est vide dans le fichier **config/application.php**. | `php artisan key:generate` 29 | 30 | 31 | ## Sessions en base de données [(Plus d'infos)](/3/session/config#database) 32 | 33 | Description | Commande 34 | ------------- | ------------- 35 | Crée la table de sessions | `php artisan session:table` 36 | 37 | 38 | ## Migrations [(Plus d'infos)](/3/database/migrations) 39 | 40 | Description | Commande 41 | ------------- | ------------- 42 | Crée la table de migration | `php artisan migrate:install` 43 | Crée une migration | `php artisan migrate:make create_users_table` 44 | Crée une migration pour un bundle | `php artisan migrate:make bundle::tablename` 45 | Exécute les migrations en attente | `php artisan migrate` 46 | Exécute les migrations en attente de l'application | `php artisan migrate application` 47 | Exécute les migrations en attente d'un bundle | `php artisan migrate bundle` 48 | Annule la dernière opération de migration | `php artisan migrate:rollback` 49 | Annule toutes les opérations de migration | `php artisan migrate:reset` 50 | 51 | 52 | ## Bundles [(Plus d'infos)](/3/bundles) 53 | 54 | Description | Commande 55 | ------------- | ------------- 56 | Installe un bundle | `php artisan bundle:install eloquent` 57 | Mise à jour d'un bundle | `php artisan bundle:upgrade eloquent` 58 | Mise à jour de tous les bundles | `php artisan bundle:upgrade` 59 | Publie les assets d'un bundle | `php artisan bundle:publish bundle_name` 60 | Publie les assets de tous les bundles | `php artisan bundle:publish` 61 | 62 |
63 | > **Note:** Après l'avoir installé, vous devez [enregistrer le bundle](/3/bundles/#registering-bundles) 64 | 65 | 66 | ## Tâches [(Plus d'infos)](/3/artisan/tasks) 67 | 68 | Description | Commande 69 | ------------- | ------------- 70 | Appelle une tâche | `php artisan notify` 71 | Appelle une tâche avec arguments | `php artisan notify taylor` 72 | Appelle une une méthode spécifique d'une tâche | `php artisan notify:urgent` 73 | Appelle une tâche d'un bundle | `php artisan admin::generate` 74 | Appelle une méthode spécifique d'une tâche de bundle | `php artisan admin::generate:list` 75 | 76 | 77 | ## Test unitaires [(Plus d'infos)](/3/testing) 78 | 79 | Description | Commande 80 | ------------- | ------------- 81 | Exécute les tests de l'application | `php artisan test` 82 | Exécute les tests unitaires d'un bundle | `php artisan test bundle-name` 83 | 84 | 85 | ## Routage [(Plus d'infos)](/3/routing) 86 | 87 | Description | Commande 88 | ------------- | ------------- 89 | Appelle une route | `php artisan route:call get api/user/1` 90 | 91 |
92 | > **Note:** vous pouvez remplacer get par post, put... 93 | 94 | 95 | ## Clé d'application 96 | 97 | Description | Commande 98 | ------------- | ------------- 99 | Génère une clé d'application | `php artisan key:generate` 100 | 101 |
102 | > **Note:** Vous pouvez spécifier en paramètre alternatif, une longueur pour la clé. 103 | 104 | 105 | ## Options en ligne de commandes 106 | 107 | Description | Commande 108 | ------------- | ------------- 109 | Définition de l'environnement d'exécution | `php artisan foo --env=local` 110 | Définition de la base de données par défaut | `php artisan foo --database=sqlitename` 111 | -------------------------------------------------------------------------------- /3/artisan/tasks.md: -------------------------------------------------------------------------------- 1 | # Tasks 2 | 3 | ## Au menu 4 | 5 | - [Les bases](#the-basics) 6 | - [Création et exécution de tâches](#creating-tasks) 7 | - [Tâches de bundles](#bundle-tasks) 8 | - [Options de la ligne de commandes](#cli-options) 9 | 10 | 11 | ## Les bases 12 | 13 | L'outil en ligne de commande de Laravel s'appelle Artisan. Artisan peut être utilisé pour exécuter des tâches comme des migrations, des tâches programmées, tests unitaires, ou ce que vous voulez. 14 | 15 | 16 | ## Création & exécution de tâches 17 | 18 | Pour créer une tâche, créez une nouvelle classe dans le dossier **application/tasks**. Le nom de la classe doit finir par "_Task", et doit avoir au minimum une méthode "run" : 19 | 20 | #### Création d'une tâche : 21 | 22 | class Notify_Task { 23 | 24 | public function run($arguments) 25 | { 26 | // faire quelque chose d'incroyable ! 27 | } 28 | 29 | } 30 | 31 | Maintenant vous pouvez exécuter la méthode "run" via la ligne de commande. Vous pouvez aussi passer des arguments : 32 | 33 | #### Appel de la tâche en ligne de commande: 34 | 35 | php artisan notify 36 | 37 | #### Appel de la tâche en lui passant un argument : 38 | 39 | php artisan notify taylor 40 | 41 | #### Appel de la tâche depuis l'application : 42 | 43 | Command::run(array('notify')); 44 | 45 | #### Appel de la tâche depuis l'application avec des arguments : 46 | 47 | Command::run(array('notify', 'taylor')); 48 | 49 | Souvenez-vous, vous pouvez appeler une méthode spécifique de votre classe. Ajoutons une méthode "urgent" à la classe Notify_Task : 50 | 51 | #### Ajout d'une méthode à notre tâche : 52 | 53 | class Notify_Task { 54 | 55 | public function run($arguments) 56 | { 57 | // Do awesome notifying... 58 | } 59 | 60 | public function urgent($arguments) 61 | { 62 | // This is urgent! 63 | } 64 | 65 | } 66 | 67 | Maintenant nous pouvons appeler la méthode "urgent" : 68 | 69 | #### Appel d'une méthode spécifique : 70 | 71 | php artisan notify:urgent 72 | 73 | 74 | ## Tâches de bundle 75 | 76 | Pour créer une tâche pour un bundle, préfixez le nom de votre tâche avec le nom de votre bundle. Donc si votre bundle s'appelle "admin", une tâche ressemblera à cela : 77 | 78 | #### Création d'une tâche qui appartient à un bundle : 79 | 80 | class Admin_Generate_Task { 81 | 82 | public function run($arguments) 83 | { 84 | // faire un truc d'admin 85 | } 86 | 87 | } 88 | 89 | Pour lancer votre tâche, utilisez un double deux points ( :: ) pour indiquer le bundle, comme d'habitude avec Laravel : 90 | 91 | #### Exécute une tâche d'un bundle : 92 | 93 | php artisan admin::generate 94 | 95 | #### Exécute une méthode précise d'une tâche d'un bundle: 96 | 97 | php artisan admin::generate:list 98 | 99 | 100 | ## Options de la ligne de commande 101 | 102 | #### Définition de l'environnement : 103 | 104 | php artisan foo --env=local 105 | 106 | #### Définition de la base de donnée utilisée : 107 | 108 | php artisan foo --database=sqlite 109 | -------------------------------------------------------------------------------- /3/auth/config.md: -------------------------------------------------------------------------------- 1 | # Configuration de l'authentification 2 | 3 | ## Au menu 4 | 5 | - [Les bases](#the-basics) 6 | - [Le driver d'authentification](#driver) 7 | - [Le champ de login](#username) 8 | - [Modèle d'Table d'authentification](#model) 9 | - [Table d'Table d'authentification](#table) 10 | 11 | 12 | ## Les bases 13 | 14 | La plupart des applications interactives permettent aux utilisateurs de se connecter et de se déconnecter. Laravel fournit une classe simple pour vous aider à valider les informations d'authentification de l'utilisateur et retrouver ses informations dans la base de donnée. 15 | 16 | Pour commencer, regardons le fichier **application/config/auth.php**. La configuration de l'authentification contient quelques options basiques pour vous aider à commencer avec l'authentification. 17 | 18 | 19 | ## Le driver de Table d'authentification 20 | 21 | La table d'authentification de Laravel est basée sur des drivers, cela signifie que la responsabilité de retrouver l'utilisateur qui tente de se connecter est de la responsabilité de divers drivers. Deux sont inclus avec Laravel : Eloquent et Fluent, mais libre à vous d'écrire le vôtre si vous le souhaitez ! 22 | 23 | Le driver **Eloquent** utilise l'ORM Eloquent pour charger l'utilisateur de l'application, et est le driver par défaut dans Laravel. Le driver **Fluent** utilise *fluent query builder* pour charger les utilisateurs. 24 | 25 | 26 | ## Le champ de login 27 | 28 | La seconde option dans le fichier de configuration détermine quel champ dans votre table en base de données doit être utilisé en tant que "login". Cela sera souvent un champs du type "email" ou "username" ou encore "login" dans votre table "users". 29 | 30 | 31 | ## Modèle de Table d'authentification 32 | 33 | Si vous utilisez le driver **Eloquent**, cette option détermine quel modèle doit être utilisé pour charger les utilisateurs. 34 | 35 | 36 | ## Table de Table d'authentification 37 | 38 | Lorsque vous utilisez le driver **Fluent**, cela détermine quelle table contient vos utilisateurs. -------------------------------------------------------------------------------- /3/auth/usage.md: -------------------------------------------------------------------------------- 1 | # Utilisation de l'authentification 2 | 3 | ## Au menu 4 | 5 | - [Salage & cryptage](#hash) 6 | - [Connexion](#login) 7 | - [Protection de routes](#filter) 8 | - [Obtenir des infos sur l'utilisateur connecté](#user) 9 | - [Déconnexion](#logout) 10 | 11 | > **Note:** Avant d'utiliser la classe Auth, vous devez [configurer un driver de sessions](/3/session/config). 12 | 13 | 14 | ## Salage & chiffage Hashing 15 | 16 | Si vous utilisez la classe Auth, nous vous recommandons fortement de crypter et salé vos mots de passe. 17 | 18 | Le salage et le cryptage se font en utilisant la classe **Hash** qui utilise **bcrypt**. Jetez un oeil à cet exemple : 19 | 20 | $password = Hash::make('secret'); 21 | 22 | La méthode **make** retournera une chaine cryptée de 60 caractères. 23 | 24 | Vous pouvez comparer une chaine cryptée et une non cryptée avec la méthode **check** de la classe **Hash** : 25 | 26 | if (Hash::check('secret', $hashed_value)) 27 | { 28 | return 'Le mot de passe est valide !'; 29 | } 30 | 31 | 32 | ## Connexion 33 | 34 | Connecter un utilisateur sur votre application est simple : il suffit d'utiliser la méthode **attempt** de la classe Auth. Passez simplement un tableau avec le nom d'utilisateur et le mot de passe, et le tour est joué. Les informations sont placées dans un tableau, car ce moyen de transport des données est très flexible, et permettra à certains drivers d'utiliser d'autre types de données. La méthode attempt retournera **true** si les informations sont valides. Sinon, elle retournera en tout logique false : 35 | 36 | $credentials = array('username' => 'exemple@gmail.com', 'password' => 'secret'); 37 | 38 | if (Auth::attempt($credentials)) 39 | { 40 | return Redirect::to('user/profile'); 41 | } 42 | 43 | Si les informations sont valides, l'ID de l'utilisateur sera stocké en sessions et l'utilisateur sera considéré comme connecté pour les prochaines requêtes sur votre application. 44 | 45 | Pour savoir si un utilisateur est connecté, utilisez la méthode **check** : 46 | 47 | if (Auth::check()) 48 | { 49 | return "Vous êtes connecté !"; 50 | } 51 | 52 | Utilisez la méthode **login** pour connecter un utilisateur sans utiliser ses identifiants, juste avec son id : 53 | 54 | Auth::login($user->id); 55 | 56 | Auth::login(15); 57 | 58 | 59 | ## Protection de routes 60 | 61 | C'est une chose très commune de limiter l'accès à certaines parties du site aux anonymes. Avec Laravel, cela peut être fait très facilement en utilisant le [filtre auth](/3/routes#filters). Si l'utilisateur est connecté, la requête continue son exécution, sinon il sera redirigé vers la [route nommée](/3/routes#named-routes) "login". 62 | 63 | Pour protéeger une route, attachez simplement le filtre **auth** : 64 | 65 | Route::get('admin', array('before' => 'auth', function() {})); 66 | 67 | > **Note:** Vous êtes libre de gérer le filtre auth à votre guise. Le comportement par défaut se trouve dans le fichier **application/routes.php**. 68 | 69 | 70 | ## Obtenir des infos sur l'utilisateur connecté 71 | 72 | Lorsqu'un utilisateur est connecté, la méthode **user** vous retournera ses informations : 73 | 74 | return Auth::user()->email; 75 | 76 | > **Note:** Si l'utilisateur n'est pas connecté, la méthode **user** retourne NULL. 77 | 78 | 79 | ## Déconnexion 80 | 81 | Pour déconnecter un utilisateur : 82 | 83 | Auth::logout(); 84 | 85 | Cette méthode supprime le Used ID de la session, l'utilisateur sera considéré comme déconnecter lors des requêtes futures. 86 | 87 | -------------------------------------------------------------------------------- /3/cache/config.md: -------------------------------------------------------------------------------- 1 | # Cache Configuration 2 | 3 | ## Au menu 4 | 5 | - [Les bases](#the-basics) 6 | - [Base de données](#database) 7 | - [Memcached](#memcached) 8 | - [Redis](#redis) 9 | - [Cache Keys](#keys) 10 | - [In-Memory Cache](#memory) 11 | 12 | 13 | ## Les bases 14 | 15 | Imaginez que votre application affiche les dix chansons les plus populaires pour vos visiteurs. Avez-vous vraiment besoin de remonter ces 10 chansons chaque fois que quelqu'un visite votre site ? Et si vous les stockiez pour 10 minutes, ou même une heure, vous permettant d'accélérer fortement votre application ? Le système de cache de Laravel le fait simplement. 16 | 17 | Laravel propose cinq drivers de cache par défaut : 18 | 19 | - Système de fichier 20 | - Base de données 21 | - Memcached 22 | - APC 23 | - Redis 24 | - Memory (Tableaux) 25 | 26 | Par défaut, Laravel est configuré pour utiliser le driver **file** comme système de cache. C'est disponible de suite sans configuration. Ce système stocke les éléments à mettre en cache comme des fichiers dans le répertoire **cache**. Si vous êtes satisfait par ce driver, aucune autre configuration n'est requise. Vous êtes prêt à l'utiliser. 27 | 28 | > **Note:** Avant d'utiliser le système de cache par fichiers, soyez sûr que le répertoire **storage/cache** est en mode écriture. 29 | 30 | 31 | ## Base de données 32 | 33 | Le driver de cache par la base de données utilise une table de base de données donnée comme un simple stockage clé-valeur. Pour commencer, réglez d'abord le nom de la table de base de données dans le fichier **application/config/cache.php** : 34 | 35 | 'database' => array('table' => 'laravel_cache'), 36 | 37 | Ensuite, créez la table dans votre base de données. La table doit avoir trois colonnes : 38 | 39 | - key (varchar) 40 | - value (text) 41 | - expiration (integer) 42 | 43 | C'est tout. Une fois votre configuration et votre table configurées, vous pouvez commencer à faire du cache ! 44 | 45 | 46 | ## Memcached 47 | 48 | [Memcached](http://memcached.org) est un système d'usage général servant à gérer la mémoire cache distribuée, gérant les données et les objets en RAM, utilisé par des sites comme Wikipedia et Facebook. Avant d'utiliser le driver Memcached de Laravel, vous devrez installer et configurer Memcached et l'extension PHP Memcache sur votre serveur. 49 | 50 | Une fois que Memcached est installé sur votre serveur, vous devez modifier l'option **driver** dans le fichier **application/config/cache.php** : 51 | 52 | 'driver' => 'memcached' 53 | 54 | Ensuite, ajoutez vos serveurs Memcached dans le tableau **servers** : 55 | 56 | 'servers' => array( 57 | array('host' => '127.0.0.1', 'port' => 11211, 'weight' => 100), 58 | ) 59 | 60 | 61 | ## Redis 62 | 63 | [Redis](http://redis.io) est un système de gestion de base de données clef-valeur scalable, très hautes performances, sur la mouvance NoSQL, pouvant contenir [strings](http://redis.io/topics/data-types#strings), [hashes](http://redis.io/topics/data-types#hashes), [lists](http://redis.io/topics/data-types#lists), [sets](http://redis.io/topics/data-types#sets), et [sorted sets](http://redis.io/topics/data-types#sorted-sets). 64 | 65 | Avant d'utiliser le driver de cache pour Redis, vous devez [configurer vos serveurs Redis](/3/database/redis#config). Maintenant vous pouvez modifier l'option **driver** du fichier **application/config/cache.php** : 66 | 67 | 'driver' => 'redis' 68 | 69 | 70 | ### Cache Keys 71 | 72 | Pour éviter les collisions de nommage avec d'autres applications utilisant APC, Redis ou un serveur Memcached, Laravel fait précéder une **key** à chaque élément stocké dans le cache utilisé par ces drivers. Soyez libre de modifier cette valeur : 73 | 74 | 'key' => 'laravel' 75 | 76 | 77 | ### In-Memory Cache 78 | 79 | Le driver de cache "memory" ne met pas vraiment en cache n'importe quoi sur le disque dur. Il maintient simplement un tableau interne des données en cache pour la requête courante. C'est parfait pour des tests unitaires de votre application indépendamment des mécanismes de stockage. Il ne doit jamais être utilisé comme driver de cache "réel". 80 | -------------------------------------------------------------------------------- /3/cache/usage.md: -------------------------------------------------------------------------------- 1 | # Cache Usage 2 | 3 | ## Au menu 4 | 5 | - [Storing Items](#put) 6 | - [Retrieving Items](#get) 7 | - [Removing Items](#forget) 8 | 9 | 10 | ## Storing Items 11 | 12 | Storing items in the cache is simple. Simply call the **put** method on the Cache class: 13 | 14 | Cache::put('name', 'Taylor', 10); 15 | 16 | The first parameter is the **key** to the cache item. You will use this key to retrieve the item from the cache. The second parameter is the **value** of the item. The third parameter is the number of **minutes** you want the item to be cached. 17 | 18 | You may also cache something "forever" if you do not want the cache to expire: 19 | 20 | Cache::forever('name', 'Taylor'); 21 | 22 | > **Note:** It is not necessary to serialize objects when storing them in the cache. 23 | 24 | 25 | ## Retrieving Items 26 | 27 | Retrieving items from the cache is even more simple than storing them. It is done using the **get** method. Just mention the key of the item you wish to retrieve: 28 | 29 | $name = Cache::get('name'); 30 | 31 | By default, NULL will be returned if the cached item has expired or does not exist. However, you may pass a different default value as a second parameter to the method: 32 | 33 | $name = Cache::get('name', 'Fred'); 34 | 35 | Now, "Fred" will be returned if the "name" cache item has expired or does not exist. 36 | 37 | What if you need a value from your database if a cache item doesn't exist? The solution is simple. You can pass a closure into the **get** method as a default value. The closure will only be executed if the cached item doesn't exist: 38 | 39 | $users = Cache::get('count', function() {return DB::table('users')->count();}); 40 | 41 | Let's take this example a step further. Imagine you want to retrieve the number of registered users for your application; however, if the value is not cached, you want to store the default value in the cache using the **remember** method: 42 | 43 | $users = Cache::remember('count', function() {return DB::table('users')->count();}, 5); 44 | 45 | Let's talk through that example. If the **count** item exists in the cache, it will be returned. If it doesn't exist, the result of the closure will be stored in the cache for five minutes **and** be returned by the method. Slick, huh? 46 | 47 | Laravel even gives you a simple way to determine if a cached item exists using the **has** method: 48 | 49 | if (Cache::has('name')) 50 | { 51 | $name = Cache::get('name'); 52 | } 53 | 54 | 55 | ## Removing Items 56 | 57 | Need to get rid of a cached item? No problem. Just mention the name of the item to the **forget** method: 58 | 59 | Cache::forget('name'); -------------------------------------------------------------------------------- /3/config.md: -------------------------------------------------------------------------------- 1 | # Configuration 2 | 3 | ## Au menu 4 | 5 | - [Les bases](#the-basics) 6 | - [Obtention d'options](#retrieving-options) 7 | - [Définition d'options](#setting-options) 8 | 9 | 10 | ## Les bases 11 | 12 | Parfois vous devez obtenir et définir des options lors de l'exécution de votre application. Pour cela, utilisez la classe **Config**, qui utilise la syntaxe "point" pour accéder aux fichiers de configuration et à leurs éléments. 13 | 14 | 15 | ## Obtention d'options 16 | 17 | #### Retourne une option de configuration : 18 | 19 | $value = Config::get('application.url'); 20 | 21 | #### Retourne une valeur par défaut si l'option de configuration n'existe pas : 22 | 23 | $value = Config::get('application.timezone', 'UTC'); 24 | 25 | #### Retourne un tableau avec toutes les valeurs de configuration : 26 | 27 | $options = Config::get('database'); 28 | 29 | 30 | ## Définition d'options 31 | 32 | #### Définit une option de configuration : 33 | 34 | Config::set('cache.driver', 'apc'); 35 | -------------------------------------------------------------------------------- /3/contrib/github.md: -------------------------------------------------------------------------------- 1 | # Laravel on GitHub 2 | 3 | ## Au menu 4 | 5 | - [Les bases](#the-basics) 6 | - [Repositories](#repositories) 7 | - [Branches](#branches) 8 | - [Pull Requests](#pull-requests) 9 | 10 | 11 | ## Les bases 12 | 13 | Because Laravel's development and source control is done through GitHub, anyone is able to make contributions to it. Anyone can fix bugs, add features or improve the documentation. 14 | 15 | After submitting proposed changes to the project, the Laravel team will review the changes and make the decision to commit them to Laravel's core. 16 | 17 | 18 | ## Repositories 19 | 20 | Laravel's home on GitHub is at [github.com/laravel](https://github.com/laravel). Laravel has several repositories. For basic contributions, the only repository you need to pay attention to is the **laravel** repository, located at [github.com/laravel/laravel](https://github.com/laravel/laravel). 21 | 22 | 23 | ## Branches 24 | 25 | The **laravel** repository has multiple branches, each serving a specific purpose: 26 | 27 | - **master** - This is the Laravel release branch. Active development does not happen on this branch. This branch is only for the most recent, stable Laravel core code. When you download Laravel from [laravel.com](http://laravel.com/), you are downloading directly from this master branch. *Do not make pull requests to this branch.* 28 | - **develop** - This is the working development branch. All proposed code changes and contributions by the community are pulled into this branch. *When you make a pull request to the Laravel project, this is the branch you want to pull-request into.* 29 | 30 | Once certain milestones have been reached and/or Taylor Otwell and the Laravel team is happy with the stability and additional features of the current development branch, the changes in the **develop** branch are pulled into the **master** branch, thus creating and releasing the newest stable version of Laravel for the world to use. 31 | 32 | 33 | ## Pull Requests 34 | 35 | [GitHub pull requests](https://help.github.com/articles/using-pull-requests) are a great way for everyone in the community to contribute to the Laravel codebase. Found a bug? Just fix it in your fork and submit a pull request. This will then be reviewed, and, if found as good, merged into the main repository. 36 | 37 | In order to keep the codebase clean, stable and at high quality, even with so many people contributing, some guidelines are necessary for high-quality pull requests: 38 | 39 | - **Branch:** Unless they are immediate documentation fixes relevant for old versions, pull requests should be sent to the `develop` branch only. Make sure to select that branch as target when creating the pull request (GitHub will not automatically select it.) 40 | - **Documentation:** If you are adding a new feature or changing the API in any relevant way, this should be documented. The documentation files can be found directly in the core repository. 41 | - **Unit tests:** To keep old bugs from re-appearing and generally hold quality at a high level, the Laravel core is thoroughly unit-tested. Thus, when you create a pull request, it is expected that you unit test any new code you add. For any bug you fix, you should also add regression tests to make sure the bug will never appear again. If you are unsure about how to write tests, the core team or other contributors will gladly help. 42 | 43 | *Further Reading* 44 | 45 | - [Contributing to Laravel via Command-Line](/3/contrib/command-line) 46 | - [Contributing to Laravel using TortoiseGit](/3/contrib/tortoisegit) 47 | -------------------------------------------------------------------------------- /3/database/config.md: -------------------------------------------------------------------------------- 1 | # Database Configuration 2 | 3 | ## Au menu 4 | 5 | - [Démarrage rapide avec SQLite](#quick) 6 | - [Configuration des autres types de base de données](#server) 7 | - [Définir le nom des connexions par défaut](#default) 8 | - [Surcharge des options PDO](#options) 9 | 10 | Laravel supporte d'origine les bases de données suivantes : 11 | 12 | - MySQL 13 | - PostgreSQL 14 | - SQLite 15 | - SQL Server 16 | 17 | Toutes les options de configuration des bases de données se trouvent dans le fichier **application/config/database.php**. 18 | 19 | 20 | ## Démarrage rapide avec SQLite 21 | 22 | [SQLite](http://sqlite.org) est une base de donnée géniale, nécessitant zéro configuration. Par défaut, Laravel est configuré pour utiliser MySQL. Pour passer à SQLite, changez l'option **default** et mettez : sqlite. Voilà c'est tout, vous n'avez rien d'autre à changer. 23 | 24 | Bien sûr, si vous souhaitez que votre base de donnée ne s'appelle pas "application", vous pouvez modifier l'option 'database' du fichier **application/config/database.php** : 25 | 26 | 'sqlite' => array( 27 | 'driver' => 'sqlite', 28 | 'database' => 'your_database_name', 29 | 'prefix' => '' 30 | ) 31 | 32 | Si votre application reçoit moins de 100 000 hits par jour, SQLite est une bonne solution pour la production. Sinon, pensez à MySQL ou PostgreSQL. 33 | 34 | 35 | ## Configuration des autres types de base de données 36 | 37 | Si vous utilisez MySQL, SQL Server, ou PostgreSQL, vous aurez besoin de modifier les options de configuration dans **application/config/database.php**. Dans le fichier de configuration, vous trouverez des exemples de configuration pour chacun de ces SGBDR. Changez simplement les options nécessaires pour votre serveur. 38 | 39 | 40 | ## Définir le nom des connexions par défaut 41 | 42 | Comme vous avez pu le remarquer, chaque connexion définie dans le fichier **application/config/database.php** a un nom. Par défaut, il y a quatres connexions définies : **sqlite**, **mysql**, **sqlsrv**, et **pgsql**. Vous êtes libre de changer ces noms de connexion. La connexion par défaut est spécifiée via l'option **default** : 43 | 44 | 'default' => 'sqlite' 45 | 46 | La connexion par défaut sera toujours utilisée par le [Fluent query builder](/3/database/fluent). Si vous devez changer la connexion par défaut pour une requête, utilisez la méthode `Config::set`. 47 | 48 | 49 | ## Surcharge des options PDO 50 | 51 | La classe Connector (**laravel/database/connectors/connector.php**) a un lot d'attributs PDO définis qui peuvent être surchargés dans le tableau de configuration de chaque système. Par exemple, l'un des attributs par défaut est de forcer le nom des colonnes en minuscule (**PDO::CASE_LOWER**) même s'ils sont définis en majuscule ou en camelCase dans la table. Par conséquent, les variables des objets générés ne seront accessibles qu'en minuscule. 52 | Voici un exemple de configuration du système MySQL avec des attributs PDO ajoutés : 53 | 54 | 'mysql' => array( 55 | 'driver' => 'mysql', 56 | 'host' => 'localhost', 57 | 'database' => 'database', 58 | 'username' => 'root', 59 | 'password' => '', 60 | 'charset' => 'utf8', 61 | 'prefix' => '', 62 | PDO::ATTR_CASE => PDO::CASE_LOWER, 63 | PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, 64 | PDO::ATTR_ORACLE_NULLS => PDO::NULL_NATURAL, 65 | PDO::ATTR_STRINGIFY_FETCHES => false, 66 | PDO::ATTR_EMULATE_PREPARES => false, 67 | ), 68 | 69 | Plus d'informations à propos des attributs de connexion PDO peuvent être trouvés [dans le manuel PHP](http://php.net/manual/fr/pdo.setattribute.php). 70 | -------------------------------------------------------------------------------- /3/database/migrations.md: -------------------------------------------------------------------------------- 1 | # Migrations 2 | 3 | ## Au menu 4 | 5 | - [Les bases](#the-basics) 6 | - [Préparation de la base de données](#prepping-your-database) 7 | - [Créer une migration](#creating-migrations) 8 | - [Lancer une migration](#running-migrations) 9 | - [Marche arrière](#rolling-back) 10 | 11 | 12 | ## Les bases 13 | 14 | Pensez aux migrations comme un type de contrôle de version pour votre base de données. Disons que vous travaillez en équipe, et que vous avez une base de donnée locale pour le développement. Votre pote Eric fait un changement dans la base de données et vérifie que son code utilise la colonne nouvellement créée. Vous récuperez le nouveau code source, et là rien ne marche, car vous n'avez pas la nouvelle colonne. Que faire ? Les migrations sont la solution. Creusons un peu le sujet pour comprendre comment les utiliser. 15 | 16 | 17 | ## Préparation de la base de données 18 | 19 | Avant d'utiliser les migrations, vous devez effectuer une opération. Laravel utilise une table spéciale pour garder une trace des migrations qui ont déjà été exécutées. Pour créer cette table, utilisez Artisan en ligne de commande : 20 | 21 | **Crée la table de migration de Laravel :** 22 | 23 | php artisan migrate:install 24 | 25 | 26 | ## Créer une migration 27 | 28 | Vous pouvez facilement créer une des migrations avec Artisan. Une simple commande suffit : 29 | 30 | **Création d'une migration** 31 | 32 | php artisan migrate:make create_users_table 33 | 34 | Maintenant, direction le dossier **application/migrations**. Vous trouverez notre nouveau fichier de migration ! Le nom de ce fichier contient un timestamp, cela permet à Laravel d'exécuter les fichiers dans l'ordre de création. 35 | 36 | Vous pouvez également créer des migrations pour un bundle : 37 | 38 | **Crée une migration pour un bundle :** 39 | 40 | php artisan migrate:make bundle::create_users_table 41 | 42 | *Voir aussi:* 43 | 44 | - [Schema Builder](/3/database/schema) 45 | 46 | 47 | ## Lancer une migration 48 | 49 | **Exécute toutes les migrations pour l'application et les bundles :** 50 | 51 | php artisan migrate 52 | 53 | **Exécute toutes les migrations pour l'application :** 54 | 55 | php artisan migrate application 56 | 57 | **Exécute toutes les migrations pour les bundles :** 58 | 59 | php artisan migrate bundle 60 | 61 | 62 | ## Marche arrière 63 | 64 | Lorsque vous effectuez un retour en arrière, Laravel défait entièrement toute la dernière opération de migration. Donc si votre migration était en réalité un lot de 122 migrations, les 122 seront défaites. 65 | 66 | **Annulation de la dernière migration :** 67 | 68 | php artisan migrate:rollback 69 | 70 | **Annulation de toutes les migrations :** 71 | 72 | php artisan migrate:reset 73 | -------------------------------------------------------------------------------- /3/database/raw.md: -------------------------------------------------------------------------------- 1 | # Requêtes brutes 2 | 3 | ## Au menu 4 | 5 | - [Les bases](#the-basics) 6 | - [Autres méthodes de requêtes](#other-query-methods) 7 | - [Utiliser directement PDO](#pdo-connections) 8 | 9 | 10 | ## Les bases 11 | 12 | La méthode **query** est utilisée pour exécuter des requêtes SQL brutes sur votre base de données. 13 | 14 | #### Sélection d'enregistrement depuis la base de données : 15 | 16 | $users = DB::query('select * from users'); 17 | 18 | #### Sélection d'enregistrement depuis la base de données utilisant des paramètres : 19 | 20 | $users = DB::query('select * from users where name = ?', array('test')); 21 | 22 | #### Insertion d'une ligne dans la base 23 | 24 | $success = DB::query('insert into users values (?, ?)', $bindings); 25 | 26 | #### Mise à jour des enregistrements d'une table, et retour du nombre de lignes affectées : 27 | 28 | $affected = DB::query('update users set name = ?', $bindings); 29 | 30 | #### Suppression de lignes d'une table et obtention du nombre de lignes supprimées : 31 | 32 | $affected = DB::query('delete from users where id = ?', array(1)); 33 | 34 | 35 | ## Autres méthodes de requêtes 36 | 37 | Larvel fournit quelques autres méthodes pour rendre le requêtage plus simple : 38 | 39 | #### Exécute une requête SELECT et obtient uniquement le premier résultat : 40 | 41 | $user = DB::first('select * from users where id = 1'); 42 | 43 | #### Exécute une requête et obtient la valeur d'une seule colonne : 44 | 45 | $email = DB::only('select email from users where id = 1'); 46 | 47 | 48 | ## Utiliser directement PDO 49 | 50 | Si vous souhaitez utiliser directement la connexion PDO, voici comment faire : 51 | 52 | #### Obtient la connexion PDO pour une base de données : 53 | 54 | $pdo = DB::connection('sqlite')->pdo; 55 | 56 | > **Note:** Si aucun nom de connexion n'est spécifiée, alors la connexion **default** sera utilisée. 57 | -------------------------------------------------------------------------------- /3/database/redis.md: -------------------------------------------------------------------------------- 1 | # Redis 2 | 3 | ## Au menu 4 | 5 | - [Les bases](#the-basics) 6 | - [Configuration](#config) 7 | - [Utilisation](#usage) 8 | 9 | 10 | ## Les bases 11 | 12 | [Redis](http://redis.io) est un stockage clé/value open-source avancé. Nous en parlons souvent comme un serveur de structure de données car les clés peuvent contenir des [strings](http://redis.io/topics/data-types#strings), des [hashes](http://redis.io/topics/data-types#hashes), [lists](http://redis.io/topics/data-types#lists), [sets](http://redis.io/topics/data-types#sets), et des [sorted sets](http://redis.io/topics/data-types#sorted-sets). 13 | 14 | 15 | ## Configuration 16 | 17 | La configuration de Redis pour votre application se fait dans le fichier **application/config/database.php**. Dans ce fichier, vous trouverez un tableau **redis** qui contient les serveurs Redis utilisés par votre application : 18 | 19 | 'redis' => array( 20 | 'default' => array('host' => '127.0.0.1', 'port' => 6379), 21 | ), 22 | 23 | La configuration du serveur par défaut devrait suffire pour le développement. Cependant, vous êtes libre de modifier ce tableau selon votre environnement. Donnez simplement un nom à chaque serveur, précisez une adresse et un port. 24 | 25 | 26 | ## Utilisation 27 | 28 | Vous recevrez une instance de Redis en appellant la méthode **db** de la classe **Redis** : 29 | 30 | $redis = Redis::db(); 31 | 32 | Cela vous donnera une instance du serveur Redis par **default**. Vous pouvez passer le nom du serveur à la méthode **db** pour obtenir une instance de Redis définie dans votre fichier de configuration : 33 | 34 | $redis = Redis::db('redis_2'); 35 | 36 | Bien ! Maintenant que nous avons une instance du client Redis, nous pouvons exécuter une [commande Redis](http://redis.io/commands). Laravel utilise des méthodes magiques pour passer les commandes au serveur : 37 | 38 | $redis->set('name', 'Taylor'); 39 | 40 | $name = $redis->get('name'); 41 | 42 | $values = $redis->lrange('names', 5, 10); 43 | 44 | 45 | Les arguments de la commande sont simplement passés à la méthode magique. Vous pouvez ne pas utiliser les méthodes magiques, en utilisant la méthode **run** : 46 | 47 | $values = $redis->run('lrange', array(5, 10)); 48 | 49 | Vous souhaitez exécuter le plus simplement possible des commandes sur le serveur par défaut ? Vous pouvez utiliser simplement les méthodes magiques directement sur la classe **Redis** : 50 | 51 | Redis::set('name', 'Taylor'); 52 | 53 | $name = Redis::get('name'); 54 | 55 | $values = Redis::lrange('names', 5, 10); 56 | 57 | > **Note:** Des drivers Redis pour le [cache](/3/cache/config#redis) et les [sessions](/3/session/config#redis) sont inclus avec Laravel. 58 | -------------------------------------------------------------------------------- /3/encryption.md: -------------------------------------------------------------------------------- 1 | # Chiffrement 2 | 3 | ## Au menu 4 | 5 | - [Les bases](#the-basics) 6 | - [Chiffrage d'une chaîne](#encrypt) 7 | - [Decrypting A String](#decrypt) 8 | 9 | 10 | ## Les bases 11 | 12 | La classe **Crypter** de Laravel fournit une interface simple pour gérer du chiffrement sécurisé. Par défaut, la classe Crypter fournit la possibilité de chiffrer et déchiffrer des données avec AES-256 grâce à l'extension PHP mcrypt. 13 | 14 | > **Note:** N'oubliez pas d'installer l'extension mcrypt sur votre serveur. 15 | 16 | 17 | ## Chiffrage d'une chaîne 18 | 19 | #### Chiffre une chaîne donnée : 20 | 21 | $encrypted = Crypter::encrypt($value); 22 | 23 | 24 | ## Déchiffrage d'une chaîne 25 | 26 | #### Déchiffre une chaîne donnée: 27 | 28 | $decrypted = Crypter::decrypt($encrypted); 29 | 30 | > **Note:** Il est important de noter que cette méthode ne peut déchiffrer que des chaînes qui ont été chiffrées avec **votre** application key. 31 | -------------------------------------------------------------------------------- /3/evenements.md: -------------------------------------------------------------------------------- 1 | # Evénements 2 | 3 | ## Au menu 4 | 5 | - [Les bases](#the-basics) 6 | - [Lancer un événement](#firing-events) 7 | - [Ecouter un événement](#listening-to-events) 8 | - [Queue d'événements](#queued-events) 9 | - [Les événements Laravel](#laravel-events) 10 | 11 | 12 | ## Les bases 13 | 14 | Les événements peuvent fournir un bon moyen de construire une application découplée, et autoriser des plugins à intéragir avec le coeur de votre application, sans en modifier le code. 15 | 16 | 17 | ## Lancer un événement 18 | 19 | Pour lancer un événement, dites juste à la méthode **fire** de la classe **Event** l'événement que vous souhaitez lancer : 20 | 21 | #### Lance un événement : 22 | 23 | $responses = Event::fire('loaded'); 24 | 25 | Remarquez que nous avons assigné le résultat de la méthode **fire** à une variable. Cette méthode retournera un tableau qui contiendra les réponses de tous les "écouteurs" d'événement. 26 | 27 | Pour lancer un événement et obtenir uniquement la première réponse, il vous faudra utiliser ~~la force~~ la méthode **first** : 28 | 29 | #### Lance un événement et obtient la première réponse : 30 | 31 | $response = Event::first('loaded'); 32 | 33 | > **Note:** La méthode **first** va tout de même exécuter tous les "écoutera" qui gèrent cet événement, mais il retournera que la première réponse. 34 | 35 | La méthode **Event::until** va exécuter tous les gestionnaires d'événements jusqu'à ce qu'une réponse différente de null lui soit retournée. 36 | 37 | #### Lance un événement jusqu'à une réponse différente de null : 38 | 39 | $response = Event::until('loaded'); 40 | 41 | 42 | ## Ecouter un événement 43 | 44 | A quoi bon lancer des événements si personne ne les écoute ? Enregistrer un écouteur d'événement qui sera appelé quand un événement est déclenché : 45 | 46 | #### Enregistre un écouteur d'événement : 47 | 48 | Event::listen('loaded', function() 49 | { 50 | // I'm executed on the "loaded" event! 51 | }); 52 | 53 | La fonction anonyme fournie à la méthode sera exécutée chaque fois que l'événement "loader" sera lancé. 54 | 55 | 56 | ## Queue d'événements 57 | 58 | Vous avez la possibilité avec Laravel de créer une queue, une salle d'attente d'événements, et de les lancer plus tard. Cela est possible grâce aux méthodes `queue` et `flush`. Premièrement, mettons un événement dans une queue avec un identifiant unique : 59 | 60 | #### Enregistrer une événement délayé : 61 | 62 | Event::queue('foo', $user->id, array($user)); 63 | 64 | Cette méthode accepte trois paramètres. Le premier est le nom de la queue, le second est un identifiant unique pour cet événement, et le troisième est un tableau avec les données à passer au videur de queue. 65 | 66 | Maintenant, enregistrer un déclencheur pour la queue `foo` : 67 | 68 | #### Enregistre un videur de queue d'événements : 69 | 70 | Event::flusher('foo', function($key, $user) 71 | { 72 | // 73 | }); 74 | 75 | Notez que le videur de queue d'événements reçoit deux arguments. Le premier est l'identifiant unique de l'événement en queue, qui dans notre cas sera l'identifiant de l'utilisateur. Le second ( et les suivants en général ) correspond à l'argument passé lors de l'enregistrement de l'événement dans la queue. 76 | 77 | Pour finir, nous pouvons déclencher notre videur et lancer tous les événements grâce à la méthode `flush` : 78 | 79 | Event::flush('foo'); 80 | 81 | 82 | ## Les événements Laravel 83 | 84 | Il y a plusieurs événements qui sont lancés par le coeur du framework Laravel, les voici : 85 | 86 | #### Événement lancé quand un bundle est démarré : 87 | 88 | Event::listen('laravel.started: bundle', function() {}); 89 | 90 | #### Événement lancé quand une requête sur la base de donnée est exécutée : 91 | 92 | Event::listen('laravel.query', function($sql, $bindings, $time) {}); 93 | 94 | #### Événement lancé juste avant que la réponse ne soit envoyée au navigateur: 95 | 96 | Event::listen('laravel.done', function($response) {}); 97 | 98 | #### Événement lancé quand un message est loggué avec la classe Log: 99 | 100 | Event::listen('laravel.log', function($type, $message) {}); 101 | -------------------------------------------------------------------------------- /3/files.md: -------------------------------------------------------------------------------- 1 | # Travail avec des fichiers 2 | 3 | ## Au menu 4 | 5 | - [Lecture](#get) 6 | - [Écriture](#put) 7 | - [Suppression](#delete) 8 | - [Upload d'un fichier](#upload) 9 | - [Extension d'un fichier](#ext) 10 | - [Vérifier le type d'un fichier](#is) 11 | - [Obtention du type MIME](#mime) 12 | - [Copie de dossier](#cpdir) 13 | - [Suppression de dossier](#rmdir) 14 | 15 | 16 | ## Lecture 17 | 18 | #### Obtient le contenu d'un fichier : 19 | 20 | $contents = File::get('chemin/vers/fichier'); 21 | 22 | 23 | ## Écriture 24 | 25 | #### Ecrit dans un fichier : 26 | 27 | File::put('chemin/vers/fichier', 'contenu du fichier'); 28 | 29 | #### Ajout dans un fichier : 30 | 31 | File::append('chemin/vers/fichier', 'ajout au fichier'); 32 | 33 | 34 | ## Suppression 35 | 36 | #### Supprime un fichier : 37 | 38 | File::delete('chemin/vers/fichier'); 39 | 40 | 41 | ## Upload d'un fichier 42 | 43 | #### Déplace un fichier du tableau $_FILE vers un emplacement permanent : 44 | 45 | Input::upload('picture', 'chemin/vers/img', 'fichier.ext'); 46 | 47 | > **Note:** Vous pouvez facilement valider l'image mise en ligne grâce à la [classe Validator](/3/validation). 48 | 49 | 50 | ## Extension d'un fichier 51 | 52 | #### Obtient l'extension d'un fichier : 53 | 54 | File::extension('picture.png'); 55 | 56 | 57 | ## Vérifier le type d'un fichier 58 | 59 | #### Détermine si un fichier est du type donné : 60 | 61 | if (File::is('jpg', 'chemin/vers/fichier.jpg')) 62 | { 63 | // 64 | } 65 | 66 | La méthode **is** ne regarde pas uniquement l'extension. Elle vérifie aussi le type MIME grâce à l'extension Fileinfo de PHP. 67 | 68 | > **Note:** Vous pouvez passer n'importe quelle extension définie dans le fichier **application/config/mimes.php** à la méthode **is**. 69 | > **Note:** L'extension PHP Fileinfo est requise pour cette fonctionnalité. Plus d'information sur la [page Fileinfo de PHP.net](http://php.net/manual/fr/book.fileinfo.php). 70 | 71 | 72 | ## Obtention du type MIME 73 | 74 | #### Obtient le type MIME associé à une extension : 75 | 76 | echo File::mime('gif'); // retourne 'image/gif' 77 | 78 | > **Note:** Cette méthode retourne simplement le type MIME défini dans le fichier **application/config/mimes.php**. 79 | 80 | 81 | ## Copie de dossier 82 | 83 | #### Copie récursivement un dossier vers une emplacement donné : 84 | 85 | File::cpdir($dossier, $destination); 86 | 87 | 88 | ## Suppression de dossier 89 | 90 | #### Supprime récursivement un dossier : 91 | 92 | File::rmdir($dossier); 93 | -------------------------------------------------------------------------------- /3/ioc.md: -------------------------------------------------------------------------------- 1 | # Conteneur IoC 2 | 3 | - [Définition](/3/ioc#definition) 4 | - [Objets enregistrés](/3/ioc#register) 5 | - [Résolution d'objets](/3/ioc#resolve) 6 | 7 | 8 | ## Définition 9 | 10 | Un conteneur IoC est une voie simple de manager la création d'objets. Vous pouvez l'utiliser pour définir la création d'objets complexes, vous permettant de les résoudre tout au long de votre application en utilisant une simple ligne de code. Vous pouvez également l'utiliser pour "injecter" des dépendances dans vos classes et les contrôleurs. 11 | 12 | Les conteneurs IoC aide à concevoir votre application de façon plus flexible et testable. Depuis que vous pouvez enregistrer des implémentations alternatives d'une interface avec le conteneur, vous pouvez isoler le code que vous testez à partir des dépendances externes en utilisant [stubs et mocks](http://martinfowler.com/articles/mocksArentStubs.html). 13 | 14 | 15 | ## Objets enregistrés 16 | 17 | #### Enregistrez un résolveur dans le conteneur IoC : 18 | 19 | IoC::register('mailer', function() 20 | { 21 | $transport = Swift_MailTransport::newInstance(); 22 | 23 | return Swift_Mailer::newInstance($transport); 24 | }); 25 | 26 | Bien ! Maintenant que nous avons enregistré un résolveur pour SwiftMailer dans notre conteneur. Mais, si nous ne voulons pas que le conteneur ne crée une nouvelle instance "mailer" tout le temps que quand nous en avons besoin ? Peut-être que nous voulons juste que le conteneur retourne la même instance après que l'instance initiale ait été créée. Dites juste au conteneur que l'objet doit être un singleton : 27 | 28 | #### Enregistrez un singleton dans le conteneur : 29 | 30 | IoC::singleton('mailer', function() 31 | { 32 | // 33 | }); 34 | 35 | Vous pouvez aussi enregistrer une instance d'objet existant comme un singleton dans le conteneur. 36 | 37 | #### Enregistrez une instance existante dans le conteneur : 38 | 39 | IoC::instance('mailer', $instance); 40 | 41 | 42 | ## Résolution d'objets 43 | 44 | Maintenant que vous avez enregistré SwiftMailer dans le conteneur, nous pouvons le résoudre en utilisant la méthode **resolve** sur la classe **IoC** : 45 | 46 | $mailer = IoC::resolve('mailer'); 47 | 48 | > **Note:** Vous pouvez aussi [enregistrer les contrôleurs dans le conteneur](/3/controllers#dependency-injection). 49 | -------------------------------------------------------------------------------- /3/loading.md: -------------------------------------------------------------------------------- 1 | # Autoloading 2 | 3 | ## Au menu 4 | 5 | - [Les bases](#the-basics) 6 | - [Enregistrement de répértoires](#directories) 7 | - [Enregistrement d'une table de correspondance](#mappings) 8 | - [Enregistrement de namespaces](#namespaces) 9 | 10 | 11 | ## Les bases 12 | 13 | L'autoloading vous autorise à utiliser des classes sans avoir à les **inclure** explicitement. Les seules classes chargées sont celles que vous utilisez lors d'une requête sur votre application, vous pouvez donc développer en utilisant ces classes sans avoir à les inclure manuellement. 14 | 15 | Par défaut, les dossiers **models** et **libraries** sont enregistrés avec l'autoloader, dans le fichier **application/start.php**. Le chargeur de classes utilise le nom de fichier pour détecter où se trouvent les classes. La convention de nommage indique que le nom du fichier doit être en minuscule. Ainsi, si vous avez un modèle User dans votre dossier models, ce dernier doit résider dans un fichier nommé user.php. Lorsqu'une classe se trouve dans un sous-répertoire, donnez à votre classe un namespace qui correspond à son arborescence. Par exemple, une classe "Entities\User" se trouvera dans le fichier "entities/user.php", à l'intérieur du dossier models. 16 | 17 | 18 | ## Enregistrement de répertoires 19 | 20 | Comme vu ci-dessus, les dossiers models et libraries sont enregistrés par l'autoloader par défaut ; cependant, si vous souhaitez enregistrer un dossier qui respecte la convention de nommage de fichier décrite précédemment, vous pouvez le faire de la manière suivante : 21 | 22 | #### Enregistre des dossiers avec l'autoloader: 23 | 24 | Autoloader::directories(array( 25 | path('app').'entities', 26 | path('app').'repositories', 27 | )); 28 | 29 | 30 | ## Enregistrement d'une table de correspondance 31 | 32 | Parfois vous voudrez faire correspondre manuellement une classe à un fichier. Cette technique est la plus performante : 33 | 34 | #### Enregistrement d'une classe associée à son chemin: 35 | 36 | Autoloader::map(array( 37 | 'User' => path('app').'models/user.php', 38 | 'Contact' => path('app').'models/contact.php', 39 | )); 40 | 41 | 42 | ## Enregistrement de namespaces 43 | 44 | Beaucoup de bibliothèques tierces utilisent le standard PSR-0. Le PSR-0 dit que le nom de la classe doit correspondre au nom du fichier, et que le chemin vers ce fichier est indiqué par son namespace. Si vous utilisez une bibliothèque PSR-0, enregistrez simplement le namespace de base et le chemin pour y accéder : 45 | 46 | #### Enregistre un namespace avec l'autoloader: 47 | 48 | Autoloader::namespaces(array( 49 | 'Doctrine' => path('libraries').'Doctrine', 50 | )); 51 | 52 | Avant que les namespaces ne soient disponibles en PHP, beaucoup de projets utilisaient des underscores pour indiquer la structure des répertoires. Si vous utilisez une de ces libraries, vous pouvez également utiliser l'autoloader. Par exemple, si vous utilisez SwiftMailer, vous avez remarqué que toutes les classes commencent par "Swift_". Nous allons enregistrer "Swift" avec l'autoloader, en tant que base d'un projet utilisant les underscores. 53 | 54 | #### Enregistre un projet "underscoré" avec l'autoloader: 55 | 56 | Autoloader::underscored(array( 57 | 'Swift' => path('libraries').'SwiftMailer', 58 | )); 59 | -------------------------------------------------------------------------------- /3/localization.md: -------------------------------------------------------------------------------- 1 | # Traduction & Localisation 2 | 3 | ## Au menu 4 | 5 | - [Les bases](#the-basics) 6 | - [Retrouver une ligne de langue](#get) 7 | - [Utilisation de jokers](#replace) 8 | 9 | 10 | ## Les bases 11 | 12 | La localisation est le processus de traduction de votre application en différentes langues. La classe **Lang** fournit un mécanisme simple pour vous aider à organiser et à retrouver le texte de votre application multilingue. 13 | 14 | Tous les fichiers de langue de votre application se trouvent dans le dossier **application/language**. Dans ce dossier, vous devrez créer un dossier pour chaque langue que votre application supportera. Par exemple, si votre application supporte l'anglais et le français, vous devrez créer un dossier **en** et un dossier **fr**. 15 | 16 | Laravel est fourni avec une liste relativement bien fournie de dossiers de langues, pour le support des messages d'erreur. 17 | 18 | Chaque dossier de langue peut contenir plusieurs fichiers de langue. Et dans chaque fichier se trouve un tableau de chaînes dans cette langue. En fait, les fichiers de langue ont la même structure que les fichier de configuration. Par exemple dans le dossier **application/language/fr**, vous pourriez créer un fichier **marketing.php** qui ressemblerait à cela : 19 | 20 | #### Crée un fichier de langue : 21 | 22 | return array( 23 | 24 | 'welcome' => 'Bienvenue sur notre site !', 25 | 26 | ); 27 | 28 | Ensuite, vous créeriez un fichier **marketing.php** dans le dossier **application/language/en**. Il ressemblerait à cela : 29 | 30 | return array( 31 | 32 | 'welcome' => 'Welcome to our website!', 33 | 34 | ); 35 | 36 | Bien ! Maintenant vous êtes prêt à commencer à mettre en place vos dossiers et fichiers de langue, continuons à "localiser" ! 37 | 38 | 39 | ## Retrouver une ligne de langue 40 | 41 | #### Retourne une ligne de langue: 42 | 43 | echo Lang::line('marketing.welcome')->get(); 44 | 45 | #### Retourne une ligne de langue en utilisant l'helper "__" ( deux underscores ): 46 | 47 | echo __('marketing.welcome'); 48 | 49 | Remarquez comment le point est utiliser pour séparer "marketing" et "welcome". Le texte avant le point correspond au fichier de langue, tandis que le texte après le point correspond à une clé inscrite dans ce fichier. 50 | 51 | Pour obtenir une ligne dans une langue précise, passez l'abbréviation de cette langue à la méthode `get` : 52 | 53 | #### Retourne une ligne de langue dans une langue donnée : 54 | 55 | echo Lang::line('marketing.welcome')->get('en'); 56 | 57 | 58 | ## Utilisation de jokers 59 | 60 | Maintenant, travaillons sur notre message de bienvenue. Ce dernier est très générique. Trop générique. Pourquoi ne pas placer le nom de l'utilisateur si ce dernier est connecté ? Pour ce faire, nous pouvons placer un joker dans notre ligne de langue. Les jokers sont précédés par le caractère ':' : 61 | 62 | #### Crée une ligne de langage avec un joker : 63 | 64 | 'welcome_connected' => 'Bienvenue sur notre site, :nom!' 65 | 66 | #### Retourne une ligne de langue avec une valeur : 67 | 68 | echo Lang::line('marketing.welcome_connected', array('nom' => 'Julien'))->get(); 69 | 70 | #### Retourne une ligne de langue avec une valeur en utilisant "__": 71 | 72 | echo __('marketing.welcome', array('nom' => 'Julien')); 73 | -------------------------------------------------------------------------------- /3/logging.md: -------------------------------------------------------------------------------- 1 | # Erreurs & Logging 2 | 3 | ## Au menu 4 | 5 | - [Configuration basique](#basic-configuration) 6 | - [Logging](#logging) 7 | - [La classe Logger](#the-logger-class) 8 | 9 | 10 | ## Configuration basique 11 | 12 | Toutes les options de configuration qui concernent les erreurs et le logging se trouvent dans le fichier **application/config/errors.php**. Jetons y un oeil. 13 | 14 | ### Erreurs ignorées 15 | 16 | L'option **ignore** contient un tableau des niveaux d'erreur qui doivent être ignorés par Laravel. Par "ignoré", nous voulons dire que nous n'arrêterons pas l'exécution d'un script pour ces erreurs. Cependant, elles seront logguées si le logging est activé. 17 | 18 | ### Détails d'erreurs 19 | 20 | L'option détail **detail** indique si le framework doit afficher le messge d'erreur et la pile de suivi quand une erreur se produit. En développement, vous pouvez le mettre à **true**, cependant en production, placez celà à **false**. Lorsqu'il est à false, la vue située dans le fichier **application/views/error/500.php** sera affichée. Elle contient un message d'erreur générique. 21 | 22 | 23 | ## Logging 24 | 25 | Pour activer le logging, placez l'option **log** à true dans le fichier de configuration **errors.php**. Quand le log est actif, la fonction anonyme contenue dans l'élément **logger** du fichier de configuration sera executé lorsqu'une erreur surgit. Cela vous donne une flexibilité totale sur la manière dont les erreurs doivent être logguées. Vous pouvez par exemple envoyer un email à l'équipe de développement ! 26 | 27 | Par défaut, les fichiers de logs sont stockés dans le répertoire **storage/logs**, et un nouveau fichier de log est créé chaque jour. Cela empêche d'avoir de gros fichiers de logs avec trop de messages. 28 | 29 | 30 | ## La classe Logger 31 | 32 | Vous pouvez si vous le souhaitez utiliser la classe **Log** de Laravel pour debugguer, ou juste logguer des messages d'information. Voici comment l'utiliser : 33 | 34 | #### Ecriture d'un message dans le log : 35 | 36 | Log::write('info', 'Ceci est un message informel'); 37 | 38 | #### Utilisation de la méthode magique pour spécifier le type de message: 39 | 40 | Log::info('Ceci est un message informel'); 41 | -------------------------------------------------------------------------------- /3/modeles.md: -------------------------------------------------------------------------------- 1 | # Modèles & bibliothèque 2 | 3 | ## Au menu 4 | 5 | - [Modèles](#models) 6 | - [Bibliothèque](#libraries) 7 | - [Auto-Loading](#auto-loading) 8 | 9 | 10 | ## Modèles 11 | 12 | Les modèles sont le cœur de votre application. Votre logique applicative et vos vues sont juste les moyens par lesquels l'utilisateur interagit avec vos modèles. Il est responsable du traitement des données, des interactions avec la base de données, etc. Il contient également les règles métiers. 13 | 14 | *Quelques exemples de fonctionnalités qui doivent se trouver dans un modèle:* 15 | 16 | - Interaction avec la base de données 17 | - Lecture et écriture dans un fichier 18 | - Interaction avec des Web Services 19 | 20 | Prenons l'exemple d'un blog. Vous aurez certainement un modèle "Post". Les utilisateurs voudraient pouvoir poster des commentaires, alors vous aurez un modèle "Comment". Si vous gérez des utilisateurs, alors il vous faudra également un modèle "User". Vous comprenez le principe ? 21 | 22 | 23 | ## Bibliothèque 24 | 25 | Les bibliothèques sont de classes qui exécutent des tâches qui ne sont pas spécifiques à votre application. Par exemple, vous pourriez avoir une bibliothèque qui convertit du code HTML en PDF. Cette tâche n'est pas spécifique à votre application, alors il faut la considérer comme une bibliothèque. 26 | 27 | Créer une bibliothèque, c'est simplement créer une classe et la stocker dans le dossier **libraries**. Dans l'exemple suivant, nous allons créer une bibliothèque avec une méthode qui écrit à l'écran le texte qui lui aura été fourni. Nous créons le fichier **printer.php** dans le dossier **libraries** avec le code suivant : 28 | 29 | 41 | ## Auto Loading 42 | 43 | Les bibliothèques et les modèles sont vraiment faciles à utiliser grâce à l'auto-loader de Laravel. Pour en apprendre plus sur l'auto-loader, regardez la [documentation de l'Autoloading](/3/loading). 44 | -------------------------------------------------------------------------------- /3/profiler.md: -------------------------------------------------------------------------------- 1 | # Profiler 2 | 3 | ## Au menu 4 | - [Autoriser le Profiler](#enable) 5 | - [Logging vers le Profiler](#logging) 6 | - [Timers et Benchmarking](#timers) 7 | 8 | 9 | ## Autoriser le Proiler 10 | 11 | Pour autoriser le profiler, vous devez éditer **application/config/application.php** et mettre l'option profiler **true**. 12 | 13 | 'profiler' => true, 14 | 15 | Cela attachera le profiler à **toutes** les réponses de votre installation Laravel. 16 | 17 | **Note:** Notez qu'un problème peut se présenter si vous générez des fichiers JSON. En effet, le profiler viendra s'introduire dans votre flux de sortie et votre fichier JSON sera alors invalide. 18 | 19 | 20 | ## Logging vers le Proiler 21 | 22 | Quand le profiler est activé, alors les messages que vous logguez seront affichés dans la partie dédié au log de ce dernier. 23 | 24 | #### Logging vers le profiler: 25 | 26 | Profiler::log('info', 'Log some information to the profiler'); 27 | 28 | 29 | ## Timers et Benchmarking 30 | 31 | Chronométrer et tester les performances de votre application est simple avec la fonction ```tick()``` du profiler. Cela vous permet de définir un jeu de différents timers et vous montrera les résultats à la fin de l'exécution de votre application. 32 | 33 | Chaque timer peut avoir son propre nom. Chaque timer avec un nom identique à un timer précédent fait alors partie de son cycle de vie. 34 | 35 | #### Utilisation du ticker par défaut 36 | 37 | Profiler::tick(); 38 | Profiler::tick(); 39 | 40 | #### Utilisation de plusieurs tickers nommés 41 | 42 | Profiler::tick('myTimer'); 43 | Profiler::tick('nextTimer'); 44 | Profiler::tick('myTimer'); 45 | Profiler::tick('nextTimer'); 46 | 47 | #### Utilisation d'un ticker nommé avec une méthode de callback 48 | Profiler::tick('myTimer', function($timers) { 49 | echo "I'm inside the timer callback!"; 50 | }); 51 | -------------------------------------------------------------------------------- /3/requests.md: -------------------------------------------------------------------------------- 1 | # Requêtes 2 | 3 | ## Au menu 4 | 5 | - [Travail avec les URI](#working-with-the-uri) 6 | - [Autres helpers de requpetes](#other-request-helpers) 7 | 8 | 9 | ## Travail avec les URI 10 | 11 | #### Obtient l'URI courant de la requête : 12 | 13 | echo URI::current(); 14 | 15 | #### Obtient un segment spécifique de l'URI : 16 | 17 | echo URI::segment(1); 18 | 19 | #### Retourne une valeur par défaut si un segment n'existe pas : 20 | 21 | echo URI::segment(10, 'Foo'); 22 | 23 | #### Obtient l'URL complète, y compris la query string : 24 | 25 | echo URI::full(); 26 | 27 | Si vous souhaitez déterminer si l'URI de la requête est une chaine de caractères donnée ou commence par une chaine de caractères donnée, alors vous pouvez utiliser la méthode **is** pour faire cela : 28 | 29 | #### Détermine si l'URI est "home" : 30 | 31 | if (URI::is('home')) 32 | { 33 | // The current URI is "home"! 34 | } 35 | 36 | #### Détermine si l'URI commence par "docs/*" : 37 | 38 | if (URI::is('docs/*')) 39 | { 40 | // The current URI begins with "docs/*"! 41 | } 42 | 43 | 44 | ## Autres helpers de requêtes 45 | 46 | #### Retourne le verbe HTTP utilisé (GET, POST, ...) 47 | 48 | echo Request::method(); 49 | 50 | #### accès au tableau global $_SERVER : 51 | 52 | echo Request::server('http_referer'); 53 | 54 | #### Retourne l'adresse IP du client : 55 | 56 | echo Request::ip(); 57 | 58 | #### Détermine si la requête utilise HTTPS : 59 | 60 | if (Request::secure()) 61 | { 62 | // This request is over HTTPS! 63 | } 64 | 65 | #### Détermine si la requête courante est une requête AJAX : 66 | 67 | if (Request::ajax()) 68 | { 69 | // This request is using AJAX! 70 | } 71 | 72 | #### Détermine si la requête courrant se fait via Artisan : 73 | 74 | if (Request::cli()) 75 | { 76 | // This request came from the CLI! 77 | } 78 | -------------------------------------------------------------------------------- /3/session/usage.md: -------------------------------------------------------------------------------- 1 | # Utilisation des sessions 2 | 3 | ## Au menu 4 | 5 | - [Stockage d'éléments](#put) 6 | - [Récupération d'éléments](#get) 7 | - [Suppression d'élément](#forget) 8 | - [Flashage d'élément](#flash) 9 | - [Régénération de l'ID de session](#regeneration) 10 | 11 | 12 | ## Stockage d'éléments 13 | 14 | Pour stocker des éléments dans la session, utilisez la méthode **put** de la classe **Session** : 15 | 16 | Session::put('name', 'Taylor'); 17 | 18 | le premier paramètre est la **clé** de l'élément de session. le second paramètre est la **valeur** associée à la clé. 19 | 20 | 21 | ## Récupération d'éléments 22 | 23 | Vous pouvez utiliser la méthode **get** sur la classe Session pour récuperer un élément dans la session, incluant les données flashées. Passez ensuite la clé dont la valeur associée vous interesse : 24 | 25 | $name = Session::get('name'); 26 | 27 | Par défaut, NULL sera retourné si l'élément n'existe pas dans la session. Pour définir un paramètre par défaut, passez en second argument une chaîne de caractères, ou alors une fonction anonyme : 28 | 29 | $name = Session::get('name', 'Fred'); 30 | 31 | $name = Session::get('name', function() {return 'Fred';}); 32 | 33 | Maintenant, "Fred" sera retourné si l'élément ayant pour clé "name" n'existe pas. 34 | 35 | Laravel fournit une manière simple de savoir si un élément existe en sessions avec la méthode **has** : 36 | 37 | if (Session::has('name')) 38 | { 39 | $name = Session::get('name'); 40 | } 41 | 42 | 43 | ## Suppression d'élément 44 | 45 | Pour supprimer un élément, utilisez la méthode **forget** : 46 | 47 | Session::forget('name'); 48 | 49 | Et pour les supprimer tous, la méthode **flush** est la méthode qu'il vous faut : 50 | 51 | Session::flush(); 52 | 53 | 54 | ## Flashage d'élément 55 | 56 | La méthode **flash** stocke un élément dans la session, qui expirera lors de la prochaine requête. C'est utile pour stocker des données temporaires, telles que des messages d'erreurs : 57 | 58 | Session::flash('status', 'Welcome Back!'); 59 | 60 | Les données flashées qui devraient être effacées lors de la requête en cours, peuvent être reflasher grâce à la méthode **reflash** pour tous les éléments, ou **keep** préciser les éléments à conserver : 61 | 62 | #### Renouvelle le flash de toutes les données : 63 | 64 | Session::reflash(); 65 | 66 | #### Renouvelle un seul élément du flash : 67 | 68 | Session::keep('status'); 69 | 70 | #### Renouvelle plusieurs éléments du flash : 71 | 72 | Session::keep(array('status', 'other_item')); 73 | 74 | 75 | ## Régénération de l'ID de session 76 | 77 | Pour regénérer l'ID d'une session, utilisez simplement la méthode **regenerate**, et un nouvel ID de session aléatoire sera attribué à la session : 78 | 79 | Session::regenerate(); -------------------------------------------------------------------------------- /3/strings.md: -------------------------------------------------------------------------------- 1 | # Travailler sur des chaînes de caractères 2 | 3 | ## Au menu 4 | 5 | - [Gestion de la casse](#capitalization) 6 | - [Limite de mots & des caractères](#limits) 7 | - [Génération de chaîne aléatoires](#random) 8 | - [Singulier & pluriel](#singular-and-plural) 9 | - [Slugs](#slugs) 10 | 11 | 12 | ## Gestion de la casse 13 | 14 | La classe **Str** fournit des raccourcis intelligents vers des fonctions PHP, afin de faciliter la mise en majuscule, minuscule, et en mode "titre" ( première lettres de chaque mot en majuscule ). Ces méthodes sont plus intelligentes que les fonctions [strtoupper](http://php.net/manual/fr/function.strtoupper.php), [strtolower](http://php.net/manual/fr/function.strtolower.php), et [ucwords](http://php.net/manual/fr/function.ucwords.php) car ils gèrent l'UTF-8 si l'extension [multi-byte string](http://php.net/manual/fr/book.mbstring.php) PHP est installée. Pour les utiliser, passez juste une chaîne aux méthodes : 15 | 16 | echo Str::lower('Je suis une chaîne.'); 17 | // je suis une chaîne. 18 | 19 | echo Str::upper('Je suis une chaîne.'); 20 | // JE SUIS UNE CHAÎNE. 21 | 22 | echo Str::title('Je suis une chaîne.'); 23 | // Je Suis Une Chaîne. 24 | 25 | 26 | ## Limite de mots & des caractères 27 | 28 | #### Limite le nombre de caractères dans un chaîne : 29 | 30 | echo Str::limit("Lorem ipsum dolor sit amet", 10); 31 | // Lorem ipsu... 32 | 33 | echo Str::limit_exact("Lorem ipsum dolor sit amet", 10); 34 | // Lorem i... 35 | 36 | > **Note** : cette méthode reçoit un troisième argument, qui est une fin personnalisée. La valeur par défaut est "...". La différence entre limit et limit_exact est que `limit($string,10)` fera au total 13 caractères (avec les ...), tandis que `limit_exact($string, 10)` n'en fera que 10. 37 | 38 | #### Limite le nombre de mots dans un chaîne : 39 | 40 | echo Str::words("Lorem ipsum dolor sit amet", 3); 41 | // Lorem ipsum dolor... 42 | 43 | 44 | ## Génération de chaînes aléatoires 45 | 46 | #### Génère une chaîne alpha-numérique : 47 | 48 | echo Str::random(32); 49 | 50 | #### Génère une chaîne avec uniquement des lettres : 51 | 52 | echo Str::random(32, 'alpha'); 53 | 54 | 55 | ## Singulier & pluriel 56 | 57 | La classe String est capable de transformer vos chaînes du singulier vers le pluriel, et vice versa. 58 | 59 | #### Obtient le pluriel d'un mot : 60 | 61 | echo Str::plural('user'); 62 | // users 63 | 64 | #### Obtient le singulier d'un mot : 65 | 66 | echo Str::singular('users'); 67 | // user 68 | 69 | #### Obtient le pluriel d'un mot si le second argument est plus grand que "un" : 70 | 71 | echo Str::plural('comment', count($comments)); 72 | 73 | 74 | ## Slugs 75 | 76 | #### Génération d'un slug : 77 | 78 | return Str::slug('My First Blog Post!'); 79 | // my-first-blog-post 80 | 81 | #### Génération d'un slug en utilisant un séparateur donné : 82 | 83 | return Str::slug('My First Blog Post!', '_'); 84 | // my_first_blog_post 85 | 86 | -------------------------------------------------------------------------------- /3/testing.md: -------------------------------------------------------------------------------- 1 | # Tests unitaires 2 | 3 | ## Au menu 4 | 5 | - [Les bases](#the-basics) 6 | - [Création d'une classe de tests](#creating-test-classes) 7 | - [Exécution de tests](#running-tests) 8 | - [Appel d'un contrôleur depuis un test](#calling-controllers-from-tests) 9 | 10 | 11 | ## Les bases 12 | 13 | Les tests unitaires servent à tester votre code et vérifier qu'il fonctionne correctement. En fait, certains affirment qu'il faut d'abord écrire les tests et ensuite écrire votre code, afin qu'il réponde positivement aux tests. Laravel fournit une intégration de la bibliothèque la plus utilisé en PHP : [PHPUnit](http://www.phpunit.de/manual/current/fr/), ce qui rend facile le démarrage rapide de l'écriture test ! Le framework Laravel lui même a des centaines de tests unitaires. 14 | 15 | 16 | ## Création d'une classe de tests 17 | 18 | Tous les tests de notre application se trouveront dans le dossier **application/tests**. Dans ce dossier existe un fichier fourni de base avec Laravel : **example.test.php**. C'est un fichier de test très basique. Ouvrez le et observez son contenu : 19 | 20 | assertTrue(true); 32 | } 33 | 34 | } 35 | 36 | Prenez note également que l'extension du fichier est **.test.php**. Cela indique à Laravel que ce fichier doit être considéré comme un cas de test lorsque vous exécuterez vos tests. Les fichiers dans ce dossier qui ne finissent pas par .test.php ne seront pas considérés. 37 | 38 | Si vous écrivez des tests pour un bundle, alors placez le dans un dossier **tests** à la racine de votre bundle. Laravel va gérer le reste ! 39 | 40 | Pour plus d'informations concernant la création de cas de tests, lisez la [documentation de PHPUnit](http://www.phpunit.de/manual/current/fr/). 41 | 42 | 43 | ## Exécution de tests 44 | 45 | Pour exécuter vos tests, vous pouvez utiliser Artisan : 46 | 47 | #### Exécution des tests de l'application via Artisan : 48 | 49 | php artisan test 50 | 51 | #### Exécution des test d'un bundle : 52 | 53 | php artisan test bundle-name 54 | 55 | 56 | ## Appel d'un contrôleur depuis un test 57 | 58 | Voici un exemple qui illustre comment vous pouvez appeler vos contrôleurs depuis vos tests : 59 | 60 | #### Appel d'un contrôleur depuis un test : 61 | 62 | $response = Controller::call('home@index', $parameters); 63 | 64 | #### Résolution d'une instance d'un contrôleur depuis un test : 65 | 66 | $controller = Controller::resolve('application', 'home@index'); 67 | 68 | > **Note:** Les filtres d'action de votre contrôleur seront exécutés lorsque vous utilisez `Controller::call`. 69 | -------------------------------------------------------------------------------- /3/urls.md: -------------------------------------------------------------------------------- 1 | # Génération d'URLs 2 | 3 | ## Au menu 4 | 5 | - [Les bases](#the-basics) 6 | - [URLs vers une route](#urls-to-routes) 7 | - [URLs vers une action de contrôleur](#urls-to-controller-actions) 8 | - [URLs vers un asset](#urls-to-assets) 9 | - [Helpers d'URL](#url-helpers) 10 | 11 | 12 | ## Les bases 13 | 14 | #### Retourne l'URL de l'application : 15 | 16 | $url = URL::base(); 17 | 18 | #### Retourne une URL relative à la base de l'application : 19 | 20 | $url = URL::to('user/profile'); 21 | 22 | #### Génére une URL HTTPS : 23 | 24 | $url = URL::to_secure('user/login'); 25 | 26 | #### Retourne l'URL courante : 27 | 28 | $url = URL::current(); 29 | 30 | #### Retourne l'URL courante, avec les query string: 31 | 32 | $url = URL::full(); 33 | 34 | 35 | ## URLs vers une route 36 | 37 | #### Génération d'une URL vers une route nommée : 38 | 39 | $url = URL::to_route('profile'); 40 | 41 | Vous devrez parfois fournir à une route des arguments, pour ce faire, passez les en tant que tableau en second argument : 42 | #### Génère une URL vers une route nommée avec des arguments : 43 | 44 | $url = URL::to_route('profile', array($username)); 45 | 46 | *Voir aussi:* 47 | 48 | - [Route nommées](/3/routes#named-routes) 49 | 50 | 51 | ## URLs vers une action de contrôleur 52 | 53 | #### Génère une URL vers une action de contrôleur : 54 | 55 | $url = URL::to_action('user@profile'); 56 | 57 | #### Génère une URL vers une action de contrôleur avec des paramètres : 58 | 59 | $url = URL::to_action('user@profile', array($username)); 60 | 61 | 62 | ## URLs vers une langue différente 63 | 64 | #### Génère une url vers la même page dans une langue différente : 65 | 66 | $url = URL::to_language('fr'); 67 | 68 | #### Génère une url vers la page d'accueil dans une langue différente : 69 | 70 | $url = URL::to_language('fr', true); 71 | 72 | 73 | ## URLs vers des assets 74 | 75 | Les URLs générées pour les assets ne contiendront pas l'option de configuration **application.index**. 76 | 77 | #### Génère une URL d'un asset : 78 | 79 | $url = URL::to_asset('js/jquery.js'); 80 | 81 | 82 | ## URL Helpers 83 | 84 | Il y a plusieurs fonctions globales pour générer des URLs, afin de vous rendre la vie plus simple et votre code plus propre : 85 | 86 | #### Génère une URL relative à la base de l'application : 87 | 88 | $url = url('user/profile'); 89 | 90 | #### Génère une URL vers un asset : 91 | 92 | $url = asset('js/jquery.js'); 93 | 94 | #### Génère une URL vers une route nommée : 95 | 96 | $url = route('profile'); 97 | 98 | #### Génère une URL vers une route nommée avec des arguments : 99 | 100 | $url = route('profile', array($username)); 101 | 102 | #### Génère une URL vers une action de contrôleur : 103 | 104 | $url = action('user@profile'); 105 | 106 | #### Génère une URL vers une action de contrôleur avec des arguments : 107 | 108 | $url = action('user@profile', array($username)); 109 | -------------------------------------------------------------------------------- /3/vues/assets.md: -------------------------------------------------------------------------------- 1 | # Management des assets 2 | 3 | ## Au menu 4 | 5 | - [Enregistrement d'assets](#registering-assets) 6 | - [Écriture des assets](#dumping-assets) 7 | - [Gestion des dépendances](#asset-dependencies) 8 | - [Conteneur d'assets](#asset-containers) 9 | - [Assets de bundle](#bundle-assets) 10 | 11 | 12 | ## Enregistrement d'assets 13 | 14 | La classe **Asset** fournit une manière simple de gérer le CSS et le Javascript utilisés par votre application. Pour enregistrer un asset, appelez simplement la méthode **add** de la classe **Asset** : 15 | 16 | #### Enregistrement d'un asset : 17 | 18 | Asset::add('jquery', 'js/jquery.js'); 19 | 20 | La méthode **add** accepte trois paramètres. Le premier est le nom de l'asset, le second est le chemin de l'asset relatif au dossier **public**, et le troisième est une liste des dépendances de l'asset ( nous y reviendrons plus tard ). Remarquez que nous n'avons pas indiqué à la méthode s'il s'agissait d'un fichier Javascript ou CSS. En fait, la méthode *add** regardera l'extension du fichier pour déterminer son type. 21 | 22 | 23 | ## Écriture des assets 24 | 25 | Quand vous serez prêt à écrire les liens des assets enregistrés dans votre vue, utilisez les méthodes **styles** et **scripts** de la classe Asset : 26 | 27 | #### Écriture des assets dans une vue : 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | ## Dépendances des assets 36 | 37 | Vous pouvez spécifié lors de l'ajout d'un asset que ce dernier à des dépendances. Cela signifie que dans votre vue, les dépendances devront être affichées de manière prioritaires par rapport à ce dernier. La gestion de dépendances ne pourrait être plus simple qu'avec Laravel. Vous vous souvenez du name que vous avez donné à votre asset ? Vous pouvez le passer en tant que troisième argument de la fonction **add** pour déclarer une dépendance : 38 | 39 | #### Enregistrement d'un asset qui a une dépendance : 40 | 41 | Asset::add('jquery-ui', 'js/jquery-ui.js', 'jquery'); 42 | 43 | Dans cet exemple, nous enregistrons l'asset **jquery-ui** et nous indiquons que ce dernier est dépendant de jquery. jQuery sera donc toujours déclaré dans notre vue **avant** jQuery UI. Besoin de déclarer plus d'une dépendance ? Pas de problème : 44 | 45 | #### Enregistrement d'un asset qui a de multiples dépendances : 46 | 47 | Asset::add('jquery-ui', 'js/jquery-ui.js', array('first', 'second')); 48 | 49 | 50 | ## Conteneur d'assets 51 | 52 | Pour augmenter le temps de réponse, les règles de bonnes pratiques nous indiquent qu'il faut écrire les fichiers javascript en bas du document HTML. Mais, comment faire si nous devons inclure certains fichiers dans la tête du document ? La classe Asset fournie une manière simple de gérer des conteneurs. Appelez simplement la méthode **container** sur la classe Asset et passez lui en argument un nom. Vous pouvez ajouter autant d'assets que vous le désirez à un conteneur, de la manière suivante : 53 | 54 | #### Ajout d'un asset dans le conteneur d'assets footer : 55 | 56 | Asset::container('footer')->add('example', 'js/example.js'); 57 | 58 | #### Affichage des assets de type Javascript du conteneur 'footer' : 59 | 60 | echo Asset::container('footer')->scripts(); 61 | 62 | 63 | ## Assets de bundle 64 | 65 | Avant d'apprendre comment ajouter et afficher les assets d'un bundle, vous devriez lire la documentation sur [la création et la publication d'assets de bundle](/3/bundles#bundle-assets). 66 | 67 | Lorsque vous enregistrez des assets, le chemin est relatif au dossier **public**. Cependant, ceci n'est pas pratique lorsque l'on gère des assets de bundle, puisqu'ils se trouvent dans le dossier **public/bundles**. Laravel est là pour vous rendre la tache plus facile ! Vous pouvez créer un conteneur qui gérera les assets d'un de vos bundles : 68 | 69 | #### Précise que le conteneur foo gère les assets du bundle admin: 70 | 71 | Asset::container('foo')->bundle('admin'); 72 | 73 | Maintenant, vous pouvez utiliser des chemins relatifs au dossier public du bundle, Laravel génèrera les chemins corrects. 74 | -------------------------------------------------------------------------------- /3/vues/pagination.md: -------------------------------------------------------------------------------- 1 | # Pagination 2 | 3 | ## Au menu 4 | 5 | - [Les bases](#the-basics) 6 | - [Utilisation du Query Builder](#using-the-query-builder) 7 | - [Ajout de paramètres aux liens de pagination](#appending-to-pagination-links) 8 | - [Création d'un paginateur manuellement](#creating-paginators-manually) 9 | - [Appliquer un style à la pagination](#pagination-styling) 10 | 11 | 12 | ## Les bases 13 | 14 | Le paginateur de Laravel est conçu pour réduire la charge de l'implémentation de la pagination. 15 | 16 | 17 | ## Utilisation du Query Builder 18 | 19 | Parcourons un exemple complet d'utilisation de la pagination en utilisant le [Fluent Query Builder](/3/database/fluent): 20 | 21 | #### Obtenir le résultat paginé d'une requête : 22 | 23 | $orders = DB::table('orders')->paginate($nb_par_page); 24 | 25 | Vous pouvez également passer un tableau optionnel avec les colonnes de la table que vous souhaitez sélectionner dans votre requête : 26 | 27 | $orders = DB::table('orders')->paginate($nb_par_page, array('id', 'name', 'created_at')); 28 | 29 | #### Affiche le résultat dans une vue : 30 | 31 | results as $order): ?> 32 | id; ?> 33 | 34 | 35 | #### Génération des liens de pagination : 36 | 37 | links(); ?> 38 | 39 | la méthodes **links** va créer une liste de pages très plaisantes, qui pourrait ressembler à cela : 40 | 41 | Précédente 1 2 ... 24 25 26 27 28 29 30 ... 78 79 Suivante 42 | 43 | Le paginateur va automatiquement déterminer sur quelle page vous vous trouvez, et mettre à jour le résultat et les liens. 44 | 45 | Il est également possible d'avoir uniquement des liens "suivante" et "précédente" : 46 | 47 | #### Génération de liens "Suivante" et "Précédente" : 48 | 49 | previous().' '.$orders->next(); ?> 50 | 51 | *Voir aussi:* 52 | 53 | - *[Fluent Query Builder](/3/database/fluent)* 54 | 55 | 56 | ## Ajout de paramètres aux liens de pagination 57 | 58 | Vous pouvez ajouter plusieurs éléments aux liens de pagination, telle que la colonne sur laquelle s'effectue le tri. 59 | 60 | #### Ajout du critère de tri aux liens de pagination : 61 | 62 | appends(array('sort' => 'votes'))->links(); 63 | 64 | Les URLs ressembleront alors à quelque chose comme ça : 65 | 66 | http://exemple.fr/something?page=2&sort=votes 67 | 68 | 69 | ## Création d'un paginateur manuellement 70 | 71 | Vous pouvez créer une instance de la classe Paginator afin de gérer vous même une pagination, sans utiliser le Query Builder. Voici comment faire : 72 | 73 | #### Creation d'un paginateur : 74 | 75 | $orders = Paginator::make($orders, $total, $nb_par_page); 76 | 77 | 78 | ## Appliquer un style à la pagination 79 | 80 | Tous les éléments peuvent être stylisé grâce aux classes. Voici un exemple de code HTML généré par la méthode links() : 81 | 82 | 107 | 108 | Quand vous êtes sur la première page de résultat, le lien "Précédente" sera désactivé. A l'inverse, quand vous serez sur la dernière page, le lien "Suivante" sera désactivé. Cela se traduit par l'ajout de la classe "disabled". Voici le code HTML généré : 109 | 110 |
  • Précédente
    • 111 | -------------------------------------------------------------------------------- /4.0/artisan.md: -------------------------------------------------------------------------------- 1 | # Artisan CLI 2 | 3 | - [Introduction](#introduction) 4 | - [Utilisation](#usage) 5 | 6 | 7 | ## Introduction 8 | 9 | Artisan est le nom de l'interface en ligne de commande présente dans Laravel. Elle fournit un ensemble de commandes puissantes et utilisables pendant le développement des applications. Cette interface est basée sur le puissant composant Console de Symfony. 10 | 11 | 12 | ## Utilisation 13 | 14 | La commande `list` permet de visualiser la liste exhaustive des commandes disponibles dans Artisan : 15 | 16 | **Afficher la liste des commandes disponibles** 17 | 18 | php artisan list 19 | 20 | De plus, chaque commande possède un écran d'aide décrivant les arguments et les options disponibles. Insérer le terme `help` avant le nom d'une commande permet d'afficher cet écran d'aide : 21 | 22 | **Afficher l'écran d'aide d'une commande** 23 | 24 | php artisan help migrate 25 | 26 | Vous pouvez indiquer l'environnement devant être utilisé pour l'exécution d'une commande à l'aide de l'option `--env` : 27 | 28 | **Indiquer l'environnement d'exécution** 29 | 30 | php artisan migrate --env=local 31 | 32 | Vous pouvez aussi afficher la version de votre installation Laravel à l'aide de l'option `--version` : 33 | 34 | **Afficher la version de Laravel** 35 | 36 | php artisan --version 37 | -------------------------------------------------------------------------------- /4.0/cache.md: -------------------------------------------------------------------------------- 1 | # Cache 2 | 3 | - [Configuration](#configuration) 4 | - [Utilisation](#cache-usage) 5 | - [Incrémenter et Décrémenter](#increments-and-decrements) 6 | - [Sections de cache](#cache-sections) 7 | - [Cache de base en données](#database-cache) 8 | 9 | 10 | ## Configuration 11 | 12 | Laravel fournit une API unique pour différents gestionnaires de cache. La configuration du cache est située dans le fichier `app/config/cache.php`. Dans ce fichier, vous devez indiquer le driver à utiliser par défaut dans votre application. Laravel supporte les célèbres gestionnaires de cache [Memcached](http://memcached.org) et [Redis](http://redis.io). 13 | 14 | De plus, le fichier de configuration du cache fournit diverses options. Consultez ces options, elles sont documentées directement dans le fichier de configuration. Par défaut, Laravel est configuré pour utiliser le gestionnaire de cache `file` qui enregistre les objets sérialisés dans des fichiers. Pour les applications de grande envergure, il est recommandé d'utiliser un cache mémoire comme Memcached ou APC. 15 | 16 | 17 | ## Utilisation 18 | 19 | **Stocker une variable dans le cache** 20 | 21 | Cache::put('key', 'value', $minutes); 22 | 23 | **Stocker un élément dans le cache s'il n'existe pas** 24 | 25 | Cache::add('key', 'value', $minutes); 26 | 27 | **Lire une variable dans le cache** 28 | 29 | $value = Cache::get('key'); 30 | 31 | **Lire une variable ou retourner une valeur par défaut** 32 | 33 | $value = Cache::get('key', 'default'); 34 | 35 | $value = Cache::get('key', function() { return 'default'; }); 36 | 37 | **Stocker une variable dans le cache de manière permanente** 38 | 39 | Cache::forever('key', 'value'); 40 | 41 | Lors de la lecture d'une variable dans le cache, si vous souhaitez enregistrer une valeur par défaut dans le cas où la variable n'existe pas, utilisez la méthode `Cache::remember` : 42 | 43 | $value = Cache::remember('users', $minutes, function() 44 | { 45 | return DB::table('users')->get(); 46 | }); 47 | 48 | Vous pouvez aussi combiner les méthodes `remember` et `forever` : 49 | 50 | $value = Cache::rememberForever('users', function() 51 | { 52 | return DB::table('users')->get(); 53 | }); 54 | 55 | Notez que les variables mises en cache étant sérialisées, n'importe quel type de variable peut être mis en cache. 56 | 57 | **Supprimer une variable du cache** 58 | 59 | Cache::forget('key'); 60 | 61 | 62 | ## Incrémenter et Décrémenter 63 | 64 | Tous les drivers sauf `file` et `database` supportent les opérations `increment` et `decrement` : 65 | 66 | **Incrémentage d'une valeur** 67 | 68 | Cache::increment('key'); 69 | 70 | Cache::increment('key', $amount); 71 | 72 | **Décrémentage d'une valeur** 73 | 74 | Cache::decrement('key'); 75 | 76 | Cache::decrement('key', $amount); 77 | 78 | 79 | ## Sections de cache 80 | 81 | > **Note:** Les sections de cache ne sont pas supportés lorsque vous utilisez les drivers de cache `file` ou `database`. 82 | 83 | Les sections de cache vous permettent de grouper des éléments de même nature dans le cache, et également de vider la section d'un coup. Pour accéder à une section, utilisez la méthode `section` : 84 | 85 | **Accès à une section de cache** 86 | 87 | Cache::section('people')->put('John', $john, $minutes); 88 | 89 | Cache::section('people')->put('Anne', $anne, $minutes); 90 | 91 | Vous pouvez également accéder aux éléments de la section, et utilisez les autres méthodes tel que `increment` et `decrement`: 92 | 93 | **Accès à un élément d'une section** 94 | 95 | $anne = Cache::section('people')->get('Anne'); 96 | 97 | Vous povuez vider tous les éléments d'un section : 98 | 99 | Cache::section('people')->flush(); 100 | 101 | 102 | ## Cache de base de données 103 | 104 | Pour utiliser le driver de cache `database`, vous devez créer une table destinée à stocker les variables de cache. Voici un exemple de création d'une telle table : 105 | 106 | Schema::create('cache', function($t) 107 | { 108 | $t->string('key')->unique(); 109 | $t->text('value'); 110 | $t->integer('expiration'); 111 | }); 112 | -------------------------------------------------------------------------------- /4.0/contributing.md: -------------------------------------------------------------------------------- 1 | # Apporter sa contribution à Laravel 2 | 3 | - [Introduction](#introduction) 4 | - [Les requêtes Pull](#pull-requests) 5 | - [Guide de développement](#coding-guidelines) 6 | 7 | 8 | ## Introduction 9 | 10 | Laravel est un logiciel open source, ce qui signifie que tout un chacun peut contribuer à son développement et à son amélioration. Le code source de Laravel est actuellement disponible sur le site [Github](https://github.com/laravel), lequel fournit une méthode simple permettant de créer une branche du projet et d'intégrer vos contributions. 11 | 12 | 13 | ## Les requêtes Pull 14 | 15 | Le développement de nouvelles fonctionnalités et les corrections d'anomalies nécessitent des requêtes `pull` différentes. Avant d'envoyer une requête `pull` pour une nouvelle fonctionnalité, vous devez créer un cas (menu `Issues` du site Github) et inclure le terme `[Proposal]` dans le titre. La proposition doit décrire la nouvelle fonctionnalité y compris des éléments d'implémentation. Après examen, la proposition sera acceptée ou rejetée. Une fois la proposition acceptée, une requête `pull` doit être créée pour implémenter la nouvelle fonctionnalité. Toute requête `pull` ne respectant pas ce protocole sera immédiatement close. 16 | 17 | Dans le cas des corrections d'anomalies, des requêtes `pull` doivent être envoyées sans proposition préalable dans un cas Github. Si vous estimez détenir la solution en termes de correction d'une anomalie recensée sur le site Github, merci de joindre un commentaire détaillant la correction proposée. 18 | 19 | Les rapports de bugs et demandes de modification de la documentation peuvent aussi être proposés via Github dans le [dépôt de la documentation](https://github.com/laravel/docs). 20 | 21 | ### Les demandes de fonctionnalité 22 | 23 | Si vous avez une idée de fonctionnalité que vous aimeriez voir être ajoutée à Laravel, créez un cas Github et incluez le terme `[Request]` dans le titre. Cette fonctionnalité sera analysée par une personne de l'équipe de développement. 24 | 25 | 26 | ## Guide de développement 27 | 28 | Laravel adopte les standards de codage [PSR-0](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-0.md) et [PSR-1](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-1-basic-coding-standard.md). Les standards suivants doivent également être pris en compte : 29 | 30 | - les namespace doivent être déclarés sur une même ligne de la même manière que ` 10 | ## Configuration 11 | 12 | La connexion à une base de données et l'exécution d'une requête sont extrêmement simples à mettre en oeuvre avec Laravel. Configurer l'accès à la base de données s'effectue dans le fichier `app/config/database.php`. Les connexions et celle à utiliser par défaut peuvent être définies dans ce fichier. Le fichier contient des exemples pour tous les gestionnaires de base de données supportés. 13 | 14 | Au début de l'année 2013, Laravel supporte MySQL, Postgres, SQLite et SQL Server. 15 | 16 | 17 | ## Exécuter des requêtes 18 | 19 | Une fois la connexion configurée, vous pouvez exécuter des requêtes à l'aide de la classe `DB`. 20 | 21 | **Exécuter une commande Select** 22 | 23 | $results = DB::select('select * from users where id = ?', array(1)); 24 | 25 | La méthode `select` retourne un tableau de lignes. 26 | 27 | **Exécuter une commande Insert** 28 | 29 | DB::insert('insert into users (id, name) values (?, ?)', array(1, 'Dayle')); 30 | 31 | **Exécuter une commande Update** 32 | 33 | DB::update('update users set votes = 100 where name = ?', array('John')); 34 | 35 | **Exécuter une commande Delete** 36 | 37 | DB::delete('delete from users'); 38 | 39 | > **Remarque:** Les commandes `update` et `delete` retournent le nombre de lignes affectées par l'opération. 40 | 41 | **Exécuter une requête quelconque** 42 | 43 | DB::statement('drop table users'); 44 | 45 | Vous pouvez écouter pour des événements de requêtes en utilisant la méthode `DB::listen` : 46 | 47 | **Ecoute d'événements de requêtes** 48 | 49 | DB::listen(function($sql, $bindings, $time) 50 | { 51 | // 52 | }); 53 | 54 | 55 | ## Transactions sur la base de données 56 | 57 | Pour exécuter une liste d'opérations durant une transaction, vous pouvez utiliser la méthode `transaction` : 58 | 59 | DB::transaction(function() 60 | { 61 | DB::table('users')->update(array('votes' => 1)); 62 | 63 | DB::table('posts')->delete(); 64 | }); 65 | 66 | 67 | ## Accéder aux connexions 68 | 69 | Lorsque plusieurs connexions sont ouvertes, vous pouvez accéder à la connexion de votre choix à l'aide de la méthode `DB::connection` : 70 | 71 | $users = DB::connection('foo')->select(...); 72 | 73 | Parfois vous pourriez avoir besoin de vous reconnecter à une base de données : 74 | 75 | DB::reconnect('foo'); 76 | 77 | 78 | ## Log de requête 79 | 80 | Par défaut, Laravel tient un journal de log de toutes les requêtes qui ont été lancées pour la requête courante. Toutefois, dans certains cas, comme lors de l'insertion d'un grand nombre de lignes, cela peut entrainer une augmentation excessive de l'utilisation de la mémoire par l'application. Pour désactiver le journal de log, vous pouvez utiliser la méthode `disableQueryLog` : 81 | 82 | DB::connection()->disableQueryLog(); 83 | 84 | Pour récupérer les requêtes exécutées dans un tableau, vous pouvez utiliser la méthode `getQueryLog` : 85 | 86 | $queries = DB::getQueryLog(); -------------------------------------------------------------------------------- /4.0/documentation.md: -------------------------------------------------------------------------------- 1 | 2 | ### Préface 3 | - [Introduction](/4.0/introduction) 4 | - [Démarage rapide](/4.0/quick) 5 | - [Contribuer à Laravel](/4.0/contributing) 6 | 7 | ### Premiers pas 8 | - [Installation](/4.0/installation) 9 | - [Configuration](/4.0/configuration) 10 | - [Cycle de vie d'une requête](/4.0/lifecycle) 11 | - [Le routage](/4.0/routing) 12 | - [Requêtes et entrées](/4.0/requests) 13 | - [Les vues et les réponses](/4.0/responses) 14 | - [Les contrôleurs](/4.0/controllers) 15 | - [Les erreurs et la journalisation](/4.0/errors) 16 | 17 | ### Aller plus loin 18 | - [La gestion du cache](/4.0/cache) 19 | - [Les événements](/4.0/events) 20 | - [Étendre le Framework](/4.0/extending) 21 | - [Facades](/4.0/facades) 22 | - [Formulaires & HTML](/4.0/html) 23 | - [Helpers](/4.0/helpers) 24 | - [Le conteneur de dépendances](/4.0/ioc) 25 | - [Traduction & Localisation](/4.0/localization) 26 | - [Email](/4.0/mail) 27 | - [Développement de packages](/4.0/packages) 28 | - [La pagination](/4.0/pagination) 29 | - [Les files de travaux](/4.0/queues) 30 | - [La sécurité](/4.0/security) 31 | - [Les sessions](/4.0/session) 32 | - [Les templates](/4.0/templates) 33 | - [Les tests unitaires](/4.0/testing) 34 | - [La validation](/4.0/validation) 35 | 36 | ### Base de données 37 | - [Les bases de données](/4.0/database) 38 | - [Query Builder](/4.0/queries) 39 | - [L'ORM Eloquent](/4.0/eloquent) 40 | - [Le constructeur de schéma](/4.0/schema) 41 | - [Les migrations et la population](/4.0/migrations) 42 | - [Redis](/4.0/redis) 43 | 44 | ### Artisan CLI 45 | - [Présentation](/4.0/artisan) 46 | - [Développement de commandes](/4.0/commands) 47 | -------------------------------------------------------------------------------- /4.0/home.md: -------------------------------------------------------------------------------- 1 | # Documentation de Laravel v4 2 | 3 | La documentation est **en cours de traduction**. Vous pouvez y contribuer sur le dépôt github suivant : 4 | 5 | [https://github.com/laravel-france/laravel-france-doc/](https://github.com/laravel-france/laravel-france-doc/) 6 | 7 | Les pages non traduites ou partiellement traduites sont marquées d'un (en). -------------------------------------------------------------------------------- /4.0/installation.md: -------------------------------------------------------------------------------- 1 | # Installation 2 | 3 | - [Installation de Composer](#install-composer) 4 | - [Installation de Laravel](#install-laravel) 5 | - [Prérequis](#server-requirements) 6 | - [Configuration](#configuration) 7 | - [Permissions](#permissions) 8 | - [Des URLs propres](#pretty-urls) 9 | 10 | 11 | ## Installation de Composer 12 | 13 | Laravel utilise [Composer](http://getcomposer.org) pour gérer ses dépendances. Premièrement, téléchargez une copie de `composer.phar`. Une fois que vous avez l'archive PHAR, vous pouvez soit la laisser dans le dossier local de votre projet, soit la déplacer vers `usr/local/bin` pour l'utiliser de manière globale sur votre système. Sur Windows, vous pouvez utiliser l'installeur de Composer [pour Windows](https://getcomposer.org/Composer-Setup.exe). 14 | 15 | 16 | ## Installation de Laravel 17 | 18 | ### Via Laravel Installer 19 | 20 | D'abord, téléchargez [l'archive PHAR de Laravel installer](http://laravel.com/laravel.phar). Pour des raisons pratique, nous vous conseillons de renommer le fichier en `laravel` et de le déplacer dans `/usr/local/bin`. Une fois installé, la simple commande `laravel new` vous créera une installation fraiche de Laravel dans le dossier spécifié. Par exemple, `laravel new blog` créera un dossier `blog` qui contiendra une installation fraiche de Laravel avec toutes les dépendances installées. Cette méthode est plus rapide que celle via Composer 21 | 22 | ### Via Composer Create-Project 23 | 24 | Vous pouvez également installer Laravel en exécutant la commande `create-project` de composer dans votre terminal : 25 | 26 | composer create-project laravel/laravel --prefer-dist 27 | 28 | ### Via un téléchargement 29 | 30 | Une fois que Composer est installé, téléchargez la [dernière version](https://github.com/laravel/laravel/archive/master.zip) du framework, et extrayez son contenu dans un dossier sur votre serveur. Ensuite, à la racine de votre application Laravel, lancez la commande `php composer.phar install` pour installer toutes les dépendances du framework. Ce process requis que git soit installé sur le serveur pour terminer l'installation. 31 | 32 | Si vous souhaitez mettre à jour le framework Laravel, vous pouvez exécuter la commande `php composer.phar update`. 33 | 34 | 35 | ## Prérequis 36 | 37 | Le framework Laravel a quelques prérequis système : 38 | 39 | - PHP >= 5.3.7 40 | - L'extension PHP MCrypt 41 | 42 | > Quant à PHP 5.5, certaines distributions d'OS peuvent requérir l'installation manuelle de l'extension PHP JSON. Pour Ubuntu, la commande est `apt-get install php5-json`. 43 | 44 | 45 | ## Configuration 46 | 47 | Laravel n'a presque pas besoin de configuration pour fonctionner. En fait, vous êtes libre de commencer à développer ! Cependant, vous devriez au minimum jeter un oeil au fichier `app/config/app.php` et à sa documentation. Il contient plusieurs options comme `timezone` et `locale` que vous pourriez vouloir changer pour votre application. 48 | 49 | 50 | ### Permissions 51 | 52 | Laravel peut avoir besoin que le serveur web ait un accès en écriture sur les dossiers à l'intérieur de `app/storage`. 53 | 54 | 55 | ### Chemins 56 | 57 | Plusieurs chemins des dossiers du Framework sont configurables. Pour changer leurs positions, regardez le fichier `bootstrap/paths.php`. 58 | 59 | 60 | ## Des URLs propres 61 | 62 | Le framework est fourni avec un fichier `public/.htaccess` qui est utilisé pour autoriser les URLs sans `index.php`. Si vous utilisez Apache pour servir votre application Laravel, veuillez vous assurer que le module `mod_rewrite` est actif. 63 | 64 | Si le fichier `.htaccess` fourni avec Laravel ne fonctionne pas, essayez celui ci : 65 | 66 | Options +FollowSymLinks 67 | RewriteEngine On 68 | 69 | RewriteCond %{REQUEST_FILENAME} !-d 70 | RewriteCond %{REQUEST_FILENAME} !-f 71 | RewriteRule ^ index.php [L] 72 | -------------------------------------------------------------------------------- /4.0/introduction.md: -------------------------------------------------------------------------------- 1 | # Introduction 2 | 3 | - [Où débuter](#where-to-start) 4 | - [Philosophie de Laravel](#laravel-philosophy) 5 | - [Ressources additionnelles](#additional-resources) 6 | - [Equipe de développement](#development-team) 7 | 8 | 9 | ## Où débuter 10 | 11 | Apprendre un nouveau framework peut être intimidant, mais aussi excitant. Pour faciliter votre transition, nous avons essayé de créer une documentation concise et très claire pour Laravel. Voici quelques recommandations de ce qu'il faut lire en premier : 12 | 13 | - [Installation](/4.0/installation) et [configuration](/4.0/configuration). 14 | - [Routage](/4.0/routing) 15 | - [Requêtes et entrées](/4.0/requests) 16 | - [Vues et Réponses](/4.0/responses) 17 | - [Contrôleurs](/4.0/controllers) 18 | 19 | Après avoir lu tous ces documents, vous devriez avoir une bonne connaissance sur le système basique requête / réponse dans Laravel. Ensuite, vous pouvez lire sur [la configuration de votre base de données](/4.0/database), le [Query Builder](/4.0/queries), et [l'ORM Eloquent](/4.0/eloquent). Ou, vous pouvez lire sur [l'authentification et la sécurité](4/security), de sorte que vous pouvez commencer à enregistrer des gens dans votre application. 20 | 21 | 22 | ## Philosophie de Laravel 23 | 24 | Laravel est un framework web dont la syntaxe est expressive et élégante. Le développement doit être plaisant, créatif et épanouissant. Laravel tente d'alléger le développement en facilitant les tâches communes à la majorité des applications web telles que l'authentification, le routage, les sessions et la gestion de cache. 25 | 26 | Laravel a pour objectif de rendre le développement agréable tout en permettant de développer des fonctionnalités adaptées. Des développeurs heureux produisent du code meilleur. Pour cela, nous avons tenté de combiner le meilleur de ce que nous avons trouvé dans d'autres frameworks web, incluant les frameworks d'autres langages comme Ruby On Rails, ASP.NET et Sinatra. 27 | 28 | Laravel est accessible, puissant, fournissant des outils puissants pour des applications larges et robustes. Un superbe conteneur d'inversion de contrôle, un système de migration expressif, et un support pour l'intégration de tests unitaires vous donnent les outils nécessaires pour construire n'importe quelle application que vous devez réaliser. 29 | 30 | 31 | ## Ressources additionnelles 32 | 33 | Une des meilleurs façons d'apprendre Laravel est de lire sa documentation de bout en bout. Ce guide détaille tous les aspects du framework et la manière de les mettre en oeuvre dans vos applications. 34 | 35 | Par ailleurs, jetez un coup d'oeil aux [livres sur Laravel](http://wiki.laravel.io/Books). Ces ouvrages constituent de bon compléments pour l'apprentissage du framework. 36 | 37 | - [Code Bright](https://leanpub.com/codebright) par Dayle Rees 38 | - [Laravel Testing Decoded](https://leanpub.com/laravel-testing-decoded) par Jeffrey Way 39 | - [Laravel: From Apprentice To Artisan](https://leanpub.com/laravel) par Taylor Otwell 40 | - [Implementing Laravel](https://leanpub.com/implementinglaravel) par Chris Fidao 41 | - [Getting Stuff Done With Laravel 4](https://leanpub.com/gettingstuffdonelaravel) par Chuck Heintzelman 42 | - [Laravel 4 Cookbook](https://leanpub.com/laravel4cookbook) par Christopher Pitt 43 | - [Laravel in Action](http://www.manning.com/surguy/) par Maks Surguy 44 | 45 | 46 | ## Equipe de développement 47 | 48 | Laravel a été créé par [Taylor Otwell](https://github.com/taylorotwell), qui continue de diriger le développement du framework. D'autres membres proéminents de la communauté et contributeurs incluant [Dayle Rees](https://github.com/daylerees), [Shawn McCool](https://github.com/ShawnMcCool), [Jeffrey Way](https://github.com/JeffreyWay), [Jason Lewis](https://github.com/jasonlewis), [Ben Corlett](https://github.com/bencorlett), [Franz Liedke](https://github.com/franzliedke), [Dries Vints](https://github.com/driesvints), [Mior Muhammad Zaki](https://github.com/crynobone), et [Phil Sturgeon](https://github.com/philsturgeon). 49 | -------------------------------------------------------------------------------- /4.0/localization.md: -------------------------------------------------------------------------------- 1 | # Traduction & Localisation 2 | 3 | - [Introduction](#introduction) 4 | - [Fichiers de langues](#language-files) 5 | - [Utilisation basique](#basic-usage) 6 | - [Plurialisation](#pluralization) 7 | - [Localisation de la validation](#validation) 8 | 9 | 10 | ## Introduction 11 | 12 | La classe `Lang` fournit une manière efficace de retrouver des chaînes de caractères de différentes langues, vous permettant de supporter facilement plusieurs langues au sein de votre application. 13 | 14 | 15 | ## Fichiers de langues 16 | 17 | Les chaînes de langues sont stockées dans des fichiers à l'intérieur du dossier `app/lang`. Dans ce dossier, il doit y avoir un dossier pour chaque langue supportée par votre application. 18 | 19 | /app 20 | /lang 21 | /en 22 | messages.php 23 | /fr 24 | messages.php 25 | 26 | Les fichiers de langues sont simplements des tableaux avec des clés. Par exemple: 27 | 28 | **Fichier de langue d'exemple** 29 | 30 | 'Bienvenue sur notre application' 34 | ); 35 | 36 | La langue par défaut est définie dans le fichier de configuration `app/config/app.php`. Vous pouvez changer la langue durant l'exécution grâce à la méthode `App::setLocale` : 37 | 38 | **Changement de langue durant l'exécution** 39 | 40 | App::setLocale('fr'); 41 | 42 | 43 | ## Utilisation basique 44 | 45 | **Retrouve une ligne depuis un fichier de traduction** 46 | 47 | echo Lang::get('messages.welcome'); 48 | 49 | Le premier segment passé à la méthode `get` est le nom du fichier de traduction, dans notre cas il s'agit de 'messages'. La seconde partie est le nom de la ligne qui doit être retrouvée, dans notre cas 'welcome'. 50 | 51 | > **Note*: Si la ligne n'existe pas dans le fichier, la clé sera renvoyée par la méthode `get`. 52 | 53 | Vous pouvez aussi utiliser la fonction `trans`, qui est un alias de la méthode `Lang::get`. 54 | 55 | echo trans('messages.welcome'); 56 | 57 | **Ligne de traduction variable** 58 | 59 | Vous pouvez placer une variable dans votre ligne de langue : 60 | 61 | 'welcome' => 'Bienvenue, :name', 62 | 63 | Ensuite, passez un tableau de correspondance en tant que second argument à la méthode `Lang::get` : 64 | 65 | echo Lang::get('messages.welcome', array('name' => 'Dayle')); 66 | 67 | **Determine si un fichier de traduction contient une ligne** 68 | 69 | if (Lang::has('messages.welcome')) 70 | { 71 | // la ligne est trouvée 72 | } 73 | 74 | 75 | ## Plurialisation 76 | 77 | Pluralisation est un problème complexe, étant donné que les règles ne sont pas les mêmes selon les langues. Vous pouvez gérer cela facilement dans vos fichiers de langues. En utilisant le caractère '|', vous pouvez séparer le singulier et le pluriel d'une chaîne : 78 | 79 | 'pommes' => 'Il y a une pomme|Il y a plusieurs pommes', 80 | 81 | Ensuite, vous utiliserez la méthode `Lang::choice` pour retrouver cette ligne: 82 | 83 | echo Lang::choice('messages.apples', 10); 84 | 85 | Etant donné que le traducteur de Laravel utilise le composant Translation de Symfony, vous pouvez créer des règles de plurialisation très explicites facilement : 86 | 87 | 'apples' => '{0} Il n\'y en a pas|[1,19] Il y en a quelques une|[20,Inf] Il y en a beaucoup', 88 | 89 | 90 | ## Localisation de la validation 91 | 92 | Pour la localisation des messages et erreurs de la validation, veuillez jetez un oeil sur la documentation de Validation. 93 | -------------------------------------------------------------------------------- /4.0/pagination.md: -------------------------------------------------------------------------------- 1 | # La pagination 2 | 3 | - [Configuration](#configuration) 4 | - [Utilisation](#usage) 5 | - [Ajout de paramètres sur les liens de pagination](#appending-to-pagination-links) 6 | 7 | 8 | 9 | ## Configuration 10 | 11 | Dans d'autres frameworks, mettre en place une pagination peut être difficile. Laravel facilite cette tâche. Il suffit de valoriser l'option `pagination` du fichier `app/config/view.php` avec la vue à utiliser pour créer des liens de pagination. Par défaut, Laravel inclut deux vues. 12 | 13 | La vue `pagination::slider` a pour fonction de produire une restitution élaborée d'une série de liens sur la page courante tandis que la vue `pagination::simple` affiche les boutons "précédent" et "suivant". **Ces deux vues sont compatibles avec Twitter Bootstrap.** 14 | 15 | 16 | ## Utilisation 17 | 18 | Il existe plusieurs manières de paginer des éléments. La plus simple est d'utiliser la méthode `paginate` du requêteur ou d'un modèle Eloquent. 19 | 20 | **Paginer le résultat d'une requête de base de données** 21 | 22 | $users = DB::table('users')->paginate(15); 23 | 24 | Vous pouvez aussi paginer un modèle [Eloquent](/4.0/eloquent) : 25 | 26 | **Paginer un modèle Eloquent** 27 | 28 | $allUsers = User::paginate(15); 29 | 30 | $someUsers = User::where('votes', '>', 100)->paginate(15); 31 | 32 | L'argument transmis à la méthode `paginate` est le nombre d'éléments à afficher par page. Vous pouvez placer les éléments à afficher dans une vue et créer les liens de pagination à l'aide de la méthode `links` : 33 | 34 |
    35 | 36 | name; ?> 37 | 38 |
    39 | 40 | links(); ?> 41 | 42 | Créer un système de pagination est aussi simple que cela ! Notez qu'il n'est pas nécessaire d'indiquer l'identité de la page courante au framework. Laravel le détermine automatiquement. 43 | 44 | Vous pouvez également accéder à des informations additionelles sur la pagination en utilisant les méthodes suivantes : 45 | 46 | - `getCurrentPage` 47 | - `getLastPage` 48 | - `getPerPage` 49 | - `getTotal` 50 | - `getFrom` 51 | - `getTo` 52 | - `count` 53 | 54 | Si vous souhaitez créer une pagination manuellement en fournissant un tableau d'éléments, utilisez la méthode `Paginator::make` : 55 | 56 | **Créer manuellement une pagination** 57 | 58 | $paginator = Paginator::make($items, $totalItems, $perPage); 59 | 60 | **Personnaliser l'URI de la pagination** 61 | 62 | Vous pouvez aussi personnaliser l'URI utilisée par la pagination via la méthode `setBaseUrl` : 63 | 64 | $users = User::paginate(); 65 | 66 | $users->setBaseUrl('custom/url'); 67 | 68 | L'exemple ci-dessus créera des URLs de la forme suivante : http://example.com/custom/url?page=2 69 | 70 | 71 | ## Ajout de paramètres sur les liens de pagination 72 | 73 | Vous pouvez ajouter des paramètres sur les liens de pagination en utilisant la méthode `appends` sur le Paginator: 74 | 75 | appends(array('sort' => 'votes'))->links(); ?> 76 | 77 | Cela génèrera une URL qui ressemblera à cela : 78 | 79 | http://example.com/something?page=2&sort=votes 80 | -------------------------------------------------------------------------------- /4.0/redis.md: -------------------------------------------------------------------------------- 1 | # Redis 2 | 3 | - [Introduction](#introduction) 4 | - [Configuration](#configuration) 5 | - [Utilisation](#usage) 6 | - [Pipelining](#pipelining) 7 | 8 | 9 | ## Introduction 10 | 11 | [Redis](http://redis.io) est une base de données open source de type clé-valeur. Il est souvent présenté comme un gestionnaire de données structurées puisque les clés peuvent être de type [strings](http://redis.io/topics/data-types#strings), [hashes](http://redis.io/topics/data-types#hashes), [lists](http://redis.io/topics/data-types#lists), [sets](http://redis.io/topics/data-types#sets), et [sorted sets](http://redis.io/topics/data-types#sorted-sets). 12 | 13 | 14 | ## Configuration 15 | 16 | La configuration Redis pour votre application est située dans le fichier **app/config/database.php**. Dans ce fichier, l'élément **redis** est un tableau contenant les serveurs Redis utilisés par votre application : 17 | 18 | 'redis' => array( 19 | 'cluster' => true, 20 | 'default' => array('host' => '127.0.0.1', 'port' => 6379), 21 | ), 22 | 23 | La configuration de serveur par défaut doit être suffisante pour le développement. Toutefois, vous pouvez modifier ce tableau à votre convenance. Donnez seulement un nom à chacun de vos serveurs Redis, puis indiquez le host et le port utilisés pour chaque serveur. 24 | 25 | Si votre serveur Redis requiert une identification, vous pouvez ajouter une clé `password` au tableau de configuration de votre serveur Redis. 26 | 27 | L'option `cluster` indiquera au client Redis de Laravel de faire du Sharding côté client sur les noeuds Redis, vous permettant de mettre en commun des noeuds et de créer un grand nombre de RAM disponibles. Cependant, notez que le sharding côté client ne gère pas les défaillances, de ce fait l'usage sera plutôt pour mettre en cache des données qui sont disponibles depuis une autre source. 28 | 29 | 30 | ## Utilisation 31 | 32 | Vous devez obtenir une instance Redis en appelant la méthode `Redis::connection` : 33 | 34 | $redis = Redis::connection(); 35 | 36 | 37 | Une instance du serveur Redis par défaut vous sera retournée. Vous devez indiquer le nom du serveur à la méthode `connection` afin d'obtenir un serveur spécifique comme défini dans votre configuration Redis : 38 | 39 | 40 | $redis = Redis::connection('other'); 41 | 42 | Une fois en possession d'une instance du client Redis, vous pouvez lui appliquer des [commandes Redis](http://redis.io/commands). Laravel utilise des méthodes magiques pour passer les commandes au serveur Redis : 43 | 44 | $redis->set('name', 'Taylor'); 45 | 46 | $name = $redis->get('name'); 47 | 48 | $values = $redis->lrange('names', 5, 10); 49 | 50 | Notez la simplicité avec laquelle les arguments des commandes sont passés à la méthode magique. Evidemment, vous n'êtes pas obligé d'utiliser les méthodes magiques, vous pouvez aussi transmettre des commandes au serveur en utilisant la méthode `command` : 51 | 52 | $values = $redis->command('lrange', array(5, 10)); 53 | 54 | Pour exécuter des commandes sans utiliser la connexion par défaut, utilisez les méthodes statiques magiques de la classe `Redis` : 55 | 56 | Redis::set('name', 'Taylor'); 57 | 58 | $name = Redis::get('name'); 59 | 60 | $values = Redis::lrange('names', 5, 10); 61 | 62 | > **Note:** Les drivers [cache](/4.0/cache) et [session](/4.0/session) de Redis sont fournis avec Laravel. 63 | 64 | 65 | ## Pipelining 66 | 67 | Le Pipelining doit être utilisé lorsque vous avez besoin d'envoyer plusieurs commandes au serveur en une opération. Pour ce faire, utilisez la méthode `pipeline` : 68 | 69 | **Envoi de plusieurs commandes au serveur** 70 | 71 | Redis::pipeline(function($pipe) 72 | { 73 | for ($i = 0; $i < 1000; $i++) 74 | { 75 | $pipe->set("key:$i", $i); 76 | } 77 | }); 78 | 79 | 80 | -------------------------------------------------------------------------------- /4.0/session.md: -------------------------------------------------------------------------------- 1 | # Les sessions 2 | 3 | - [Configuration](#configuration) 4 | - [Utilisation](#session-usage) 5 | - [Flasher des données](#flash-data) 6 | - [Enregistrer les sessions en base de données](#database-sessions) 7 | - [Drivers de session](#session-drivers) 8 | 9 | 10 | ## Configuration 11 | 12 | Puisque l'état des variables n'est pas conservé par les applications basées sur le protocole HTTP, les sessions sont un moyen de conserver des informations d'une requête à l'autre. Laravel inclut des gestionnaires de données à travers une API claire et unifiée. Laravel supporte [Memcached](http://memcached.org), [Redis](http://redis.io) et les gestionnaires de bases de données. 13 | 14 | Les sessions sont paramétrables dans le fichier `app/config/session.php`. Examinez bien les options de ce fichier, elles sont bien documentées. Par défaut, Laravel est configuré pour l'utilisation du driver de session `native` convenant à la majorité des applications. 15 | 16 | 17 | ## Utilisation 18 | 19 | **Enregistrer une information dans une variable de session** 20 | 21 | Session::put('key', 'value'); 22 | 23 | **Empile une valeur dans une variable de session** 24 | 25 | Session::push('user.teams', 'developers'); 26 | 27 | Session::push('user', 'patrick'); 28 | 29 | **Lire une variable de session** 30 | 31 | $value = Session::get('key'); 32 | 33 | **Lire une variable ou retourner une valeur par défaut** 34 | 35 | $value = Session::get('key', 'default'); 36 | 37 | $value = Session::get('key', function() { return 'default'; }); 38 | 39 | **Retourner toutes les données de la session** 40 | 41 | $data = Session::all(); 42 | 43 | **Déterminer l'existence d'une variable de session** 44 | 45 | if (Session::has('users')) 46 | { 47 | // 48 | } 49 | 50 | **Supprimer une variable de session** 51 | 52 | Session::forget('key'); 53 | 54 | **Supprimer toutes les variables de session** 55 | 56 | Session::flush(); 57 | 58 | **Régénérer l'identifiant de session** 59 | 60 | Session::regenerate(); 61 | 62 | 63 | ## Flasher des données 64 | 65 | Si vous souhaitez enregistrer des variables de session uniquement pour les transmettre à la prochaine requête, utilisez la méthode `Session::flash` : 66 | 67 | Session::flash('key', 'value'); 68 | 69 | **Répéter le flash pour une autre requête** 70 | 71 | Session::reflash(); 72 | 73 | **Répéter le flash de certaines variables** 74 | 75 | Session::keep(array('username', 'email')); 76 | 77 | 78 | ## Enregistrer les sessions en base de données 79 | 80 | Pour utiliser le driver de session `database`, vous devez créer une table destinée à stocker les variables de sessions. Voici un exemple de création d'une telle table : 81 | 82 | Schema::create('sessions', function($t) 83 | { 84 | $t->string('id')->unique(); 85 | $t->text('payload'); 86 | $t->integer('last_activity'); 87 | }); 88 | 89 | Evidemment, vous pouvez utiliser la commande Artisan `session:table` pour générer cette migration : 90 | 91 | php artisan session:table 92 | 93 | composer dump-autoload 94 | 95 | php artisan migrate 96 | 97 | 98 | ## Drivers de session 99 | 100 | Le driver de session définit où les données de session seront stockées pour chaque requête. Laravel embarque plusieurs grands drivers : 101 | 102 | - `native` - la session sera assurée par PHP selon sa configuration à l'installation. 103 | - `cookie` - la session sera stockée en sécurité, cookies cryptés. 104 | - `database` - la session sera stockée dans la base de données utilisée par votre application. 105 | - `memcached` / `redis` - la session utilisera un des plus rapides systèmes de mise en cache. 106 | - `array` - la session sera stockée dans un simple tableau PHP et ne sera pas persistante entre les requêtes. 107 | 108 | Le driver `array` est typiquement utilisé pour lancer des [tests unitaires](/4.0/testing), de ce fait aucune donnée de session ne sera persistante. 109 | -------------------------------------------------------------------------------- /4.1/artisan.md: -------------------------------------------------------------------------------- 1 | # Artisan CLI 2 | 3 | - [Introduction](#introduction) 4 | - [Utilisation](#usage) 5 | 6 | 7 | ## Introduction 8 | 9 | Artisan est le nom de l'interface en ligne de commande présente dans Laravel. Elle fournit un ensemble de commandes puissantes et utilisables pendant le développement des applications. Cette interface est basée sur le puissant composant Console de Symfony. 10 | 11 | 12 | ## Utilisation 13 | 14 | La commande `list` permet de visualiser la liste exhaustive des commandes disponibles dans Artisan : 15 | 16 | #### Afficher la liste des commandes disponibles 17 | 18 | php artisan list 19 | 20 | De plus, chaque commande possède un écran d'aide décrivant les arguments et les options disponibles. Insérer le terme `help` avant le nom d'une commande permet d'afficher cet écran d'aide : 21 | 22 | #### Afficher l'écran d'aide d'une commande 23 | 24 | php artisan help migrate 25 | 26 | Vous pouvez indiquer l'environnement devant être utilisé pour l'exécution d'une commande à l'aide de l'option `--env` : 27 | 28 | #### Indiquer l'environnement d'exécution 29 | 30 | php artisan migrate --env=local 31 | 32 | Vous pouvez aussi afficher la version de votre installation Laravel à l'aide de l'option `--version` : 33 | 34 | #### Afficher la version de Laravel 35 | 36 | php artisan --version 37 | -------------------------------------------------------------------------------- /4.1/contributing.md: -------------------------------------------------------------------------------- 1 | # Contribuer à la documentation Laravel 2 | 3 | Si vous envoyez de la documentation pour la version stable courante, soumettez là sur la branche correspondante. Par exemple, la documentation pour Laravel 4.1 devra être soumise sur la branche `4.1`. La documentation pour la version future de Laravel sera sur la branche `master`. -------------------------------------------------------------------------------- /4.1/documentation.md: -------------------------------------------------------------------------------- 1 | 2 | ### Préface 3 | - [Introduction](/4.1/introduction) 4 | - [Démarrage rapide](/4.1/quick) 5 | - [Release Notes](/4.1/releases) 6 | - [Mise à jour](/4.1/upgrade) 7 | 8 | ### Premiers pas 9 | - [Installation](/4.1/installation) 10 | - [Configuration](/4.1/configuration) 11 | - [Cycle de vie d'une requête](/4.1/lifecycle) 12 | - [Le routage](/4.1/routing) 13 | - [Requêtes et entrées](/4.1/requests) 14 | - [Les vues et les réponses](/4.1/responses) 15 | - [Les contrôleurs](/4.1/controllers) 16 | - [Les erreurs et la journalisation](/4.1/errors) 17 | 18 | ### Aller plus loin 19 | - [Identification](/4.1/security) 20 | - [La gestion du cache](/4.1/cache) 21 | - [Les événements](/4.1/events) 22 | - [Étendre le Framework](/4.1/extending) 23 | - [Facades](/4.1/facades) 24 | - [Formulaires & HTML](/4.1/html) 25 | - [Helpers](/4.1/helpers) 26 | - [Le conteneur de dépendances](/4.1/ioc) 27 | - [Traduction & Localisation](/4.1/localization) 28 | - [Email](/4.1/mail) 29 | - [Développement de packages](/4.1/packages) 30 | - [La pagination](/4.1/pagination) 31 | - [Les files de travaux](/4.1/queues) 32 | - [La sécurité](/4.1/security) 33 | - [Les sessions](/4.1/session) 34 | - [SSH](/4.1/ssh) 35 | - [Les templates](/4.1/templates) 36 | - [Les tests unitaires](/4.1/testing) 37 | - [La validation](/4.1/validation) 38 | 39 | ### Base de données 40 | - [Les bases de données](/4.1/database) 41 | - [Query Builder](/4.1/queries) 42 | - [L'ORM Eloquent](/4.1/eloquent) 43 | - [Le constructeur de schéma](/4.1/schema) 44 | - [Les migrations et la population](/4.1/migrations) 45 | - [Redis](/4.1/redis) 46 | 47 | ### Artisan CLI 48 | - [Présentation](/4.1/artisan) 49 | - [Développement de commandes](/4.1/commands) 50 | -------------------------------------------------------------------------------- /4.1/home.md: -------------------------------------------------------------------------------- 1 | # Documentation de Laravel v4 2 | 3 | La documentation est **en cours de traduction**. Vous pouvez y contribuer sur le dépôt github suivant : 4 | 5 | [https://github.com/laravel-france/laravel-france-doc/](https://github.com/laravel-france/laravel-france-doc/) 6 | 7 | Les pages non traduites ou partiellement traduites sont marquées d'un (en). -------------------------------------------------------------------------------- /4.1/introduction.md: -------------------------------------------------------------------------------- 1 | # Introduction 2 | 3 | - [Où débuter](#where-to-start) 4 | - [Philosophie de Laravel](#laravel-philosophy) 5 | - [Ressources additionnelles](#additional-resources) 6 | - [Equipe de développement](#development-team) 7 | 8 | 9 | ## Où débuter 10 | 11 | Apprendre un nouveau framework peut être intimidant, mais aussi excitant. Pour faciliter votre transition, nous avons essayé de créer une documentation concise et très claire pour Laravel. Voici quelques recommandations de ce qu'il faut lire en premier : 12 | 13 | - [Installation](/4.1/installation) et [Configuration](/4.1/configuration). 14 | - [Routage](/4.1/routing) 15 | - [Requêtes et entrées](/4.1/requests) 16 | - [Vues et Réponses](/4.1/responses) 17 | - [Contrôleurs](/4.1/controllers) 18 | 19 | Après avoir lu tous ces documents, vous devriez avoir une bonne connaissance du système basique requête / réponse dans Laravel. Ensuite, vous pouvez lire [la configuration de votre base de données](/4.1/database), le [Query Builder](/4.1/queries), et [l'ORM Eloquent](/4.1/eloquent). Vous pouvez aussi lire [l'authentification et la sécurité](4/security), pour pouvoir commencer à enregistrer des personnes dans votre application. 20 | 21 | 22 | ## Philosophie de Laravel 23 | 24 | Laravel est un framework web dont la syntaxe est expressive et élégante. Nous pensons que le développement doit être plaisant, créatif et épanouissant. Laravel tente d'alléger le développement en facilitant les tâches communes à la majorité des applications web telles que l'authentification, le routage, les sessions et la gestion de cache. 25 | 26 | Laravel a pour objectif de rendre le développement agréable tout en permettant de développer des fonctionnalités adaptées. Des développeurs heureux produisent un code meilleur. Pour cela, nous avons tenté de combiner le meilleur de ce que nous avons trouvé dans d'autres frameworks web, incluant les frameworks d'autres langages comme Ruby On Rails, ASP.NET et Sinatra. 27 | 28 | Laravel est accessible mais puissant, fournissant des outils suffisants pour des applications larges et robustes. Un superbe conteneur d'inversion de contrôle, un système de migration expressif, et une intégration de tests unitaires, vous offrent les outils nécessaires pour construire n'importe quelle application que vous devez réaliser. 29 | 30 | 31 | ## Ressources additionnelles 32 | 33 | Une des meilleures façons d'apprendre Laravel est de lire sa documentation de bout en bout. Ce guide détaille tous les aspects du framework et la manière de les mettre en oeuvre dans vos applications. 34 | 35 | Par ailleurs, jetez un coup d'oeil aux [livres sur Laravel](http://wiki.laravel.io/Books). Ces ouvrages rédigés par la communauté constituent de bon compléments pour l'apprentissage du framework : 36 | 37 | - [Code Bright](https://leanpub.com/codebright) par Dayle Rees 38 | - [Laravel Testing Decoded](https://leanpub.com/laravel-testing-decoded) par Jeffrey Way 39 | - [Laravel: From Apprentice To Artisan](https://leanpub.com/laravel) par Taylor Otwell 40 | - [Implementing Laravel](https://leanpub.com/implementinglaravel) par Chris Fidao 41 | - [Getting Stuff Done With Laravel 4](https://leanpub.com/gettingstuffdonelaravel) par Chuck Heintzelman 42 | - [Laravel 4 Cookbook](https://leanpub.com/laravel4cookbook) par Christopher Pitt 43 | - [Laravel in Action](http://www.manning.com/surguy/) par Maks Surguy 44 | 45 | 46 | ## Equipe de développement 47 | 48 | Laravel a été créé par [Taylor Otwell](https://github.com/taylorotwell), qui continue de diriger le développement du framework. Voici d'autres membres importants de la communauté et contributeurs : [Dayle Rees](https://github.com/daylerees), [Shawn McCool](https://github.com/ShawnMcCool), [Jeffrey Way](https://github.com/JeffreyWay), [Jason Lewis](https://github.com/jasonlewis), [Ben Corlett](https://github.com/bencorlett), [Franz Liedke](https://github.com/franzliedke), [Dries Vints](https://github.com/driesvints), [Mior Muhammad Zaki](https://github.com/crynobone), et [Phil Sturgeon](https://github.com/philsturgeon). 49 | -------------------------------------------------------------------------------- /4.1/license.md: -------------------------------------------------------------------------------- 1 | MIT license, Copyright (c) Taylor Otwell 2 | 3 | Traduction par Laravel.fr 4 | 5 | L'autorisation est accordée, gracieusement, à toute personne acquérant une copie de cette bibliothèque et des fichiers de documentation associés (la "Bibliothèque"), de commercialiser la Bibliothèque sans restriction, notamment les droits d'utiliser, de copier, de modifier, de fusionner, de publier, de distribuer, de sous-licencier et / ou de vendre des copies de la Bibliothèque, ainsi que d'autoriser les personnes auxquelles la Bibliothèque est fournie à le faire, sous réserve des conditions suivantes : 6 | 7 | La déclaration de copyright ci-dessus et la présente autorisation doivent être incluses dans toutes copies ou parties substantielles de la Bibliothèque. 8 | 9 | LA BIBLIOTHÈQUE EST FOURNIE "TELLE QUELLE", SANS GARANTIE D'AUCUNE SORTE, EXPLICITE OU IMPLICITE, NOTAMMENT SANS GARANTIE DE QUALITÉ MARCHANDE, D’ADÉQUATION À UN USAGE PARTICULIER ET D'ABSENCE DE CONTREFAÇON. EN AUCUN CAS, LES AUTEURS OU TITULAIRES DU DROIT D'AUTEUR NE SERONT RESPONSABLES DE TOUT DOMMAGE, RÉCLAMATION OU AUTRE RESPONSABILITÉ, QUE CE SOIT DANS LE CADRE D'UN CONTRAT, D'UN DÉLIT OU AUTRE, EN PROVENANCE DE, CONSÉCUTIF À OU EN RELATION AVEC LA BIBLIOTHÈQUE OU SON UTILISATION, OU AVEC D'AUTRES ÉLÉMENTS DE LA BIBLIOTHÈQUE. 10 | -------------------------------------------------------------------------------- /4.1/localization.md: -------------------------------------------------------------------------------- 1 | # Traduction & Localisation 2 | 3 | - [Introduction](#introduction) 4 | - [Fichiers de langues](#language-files) 5 | - [Utilisation basique](#basic-usage) 6 | - [Plurialisation](#pluralization) 7 | - [Localisation de la validation](#validation) 8 | - [Surcharger les fichiers de langues d'un package](#overriding-package-language-files) 9 | 10 | 11 | ## Introduction 12 | 13 | La classe `Lang` fournit une manière efficace de retrouver des chaînes de caractères de différentes langues, vous permettant de supporter facilement plusieurs langues au sein de votre application. 14 | 15 | 16 | ## Fichiers de langues 17 | 18 | Les chaînes de langues sont stockées dans des fichiers à l'intérieur du dossier `app/lang`. Dans ce dossier, il doit y avoir un dossier pour chaque langue supportée par votre application. 19 | 20 | /app 21 | /lang 22 | /en 23 | messages.php 24 | /fr 25 | messages.php 26 | 27 | Les fichiers de langues sont simplements des tableaux avec des clés. Par exemple: 28 | 29 | #### Fichier de langue d'exemple 30 | 31 | 'Bienvenue sur notre application' 35 | ); 36 | 37 | La langue par défaut est définie dans le fichier de configuration `app/config/app.php`. Vous pouvez changer la langue durant l'exécution grâce à la méthode `App::setLocale` : 38 | 39 | #### Changement de langue durant l'exécution 40 | 41 | App::setLocale('fr'); 42 | 43 | 44 | ## Utilisation basique 45 | 46 | #### Retrouve une ligne depuis un fichier de traduction 47 | 48 | echo Lang::get('messages.welcome'); 49 | 50 | Le premier segment passé à la méthode `get` est le nom du fichier de traduction, dans notre cas il s'agit de 'messages'. La seconde partie est le nom de la ligne qui doit être retrouvée, dans notre cas 'welcome'. 51 | 52 | > **Note*: Si la ligne n'existe pas dans le fichier, la clé sera renvoyée par la méthode `get`. 53 | 54 | Vous pouvez aussi utiliser la fonction `trans`, qui est un alias de la méthode `Lang::get`. 55 | 56 | echo trans('messages.welcome'); 57 | 58 | #### Ligne de traduction variable 59 | 60 | Vous pouvez placer une variable dans votre ligne de langue : 61 | 62 | 'welcome' => 'Bienvenue, :name', 63 | 64 | Ensuite, passez un tableau de correspondance en tant que second argument à la méthode `Lang::get` : 65 | 66 | echo Lang::get('messages.welcome', array('name' => 'Dayle')); 67 | 68 | #### Determine si un fichier de traduction contient une ligne 69 | 70 | if (Lang::has('messages.welcome')) 71 | { 72 | // la ligne est trouvée 73 | } 74 | 75 | 76 | ## Plurialisation 77 | 78 | Pluralisation est un problème complexe, étant donné que les règles ne sont pas les mêmes selon les langues. Vous pouvez gérer cela facilement dans vos fichiers de langues. En utilisant le caractère '|', vous pouvez séparer le singulier et le pluriel d'une chaîne : 79 | 80 | 'pommes' => 'Il y a une pomme|Il y a plusieurs pommes', 81 | 82 | Ensuite, vous utiliserez la méthode `Lang::choice` pour retrouver cette ligne: 83 | 84 | echo Lang::choice('messages.apples', 10); 85 | 86 | Etant donné que le traducteur de Laravel utilise le composant Translation de Symfony, vous pouvez créer des règles de plurialisation très explicites facilement : 87 | 88 | 'apples' => '{0} Il n\'y en a pas|[1,19] Il y en a quelques une|[20,Inf] Il y en a beaucoup', 89 | 90 | 91 | ## Localisation de la validation 92 | 93 | Pour la localisation des messages et erreurs de la validation, veuillez jetez un oeil sur la documentation de Validation. 94 | 95 | 96 | ## Surcharger les fichiers de langue d'un package 97 | 98 | Plusieurs packages sont fournit avec leurs propres lignes de langue. Plutôt que de faire un hack sur les fichiers du package, vous pouvez les surcharger en plaçant des fichiers dans le dossier `app/lang/packages/{locale}/{package}`. Donc par exemple, si vous avez besoin de surcharger les lignes françaises dans le fichier `messages.php` d'un package nommé `skyrim/hearthfire`, vous placerez vos fichiers de langue dans : `app/lang/packages/en/hearthfire/messages.php`. Dans ce fichier vous définirez uniquement les lignes que vous souhaitez surcharger. Toutes les lignes non surchargées garderons la valeur tel que définie dans le package. 99 | -------------------------------------------------------------------------------- /4.1/pagination.md: -------------------------------------------------------------------------------- 1 | # La pagination 2 | 3 | - [Configuration](#configuration) 4 | - [Utilisation](#usage) 5 | - [Ajout de paramètres sur les liens de pagination](#appending-to-pagination-links) 6 | - [Conversion en JSON](#converting-to-json) 7 | 8 | 9 | ## Configuration 10 | 11 | Dans d'autres frameworks, mettre en place une pagination peut être difficile. Laravel facilite cette tâche. Il suffit de valoriser l'option `pagination` du fichier `app/config/view.php` avec la vue à utiliser pour créer des liens de pagination. Par défaut, Laravel inclut deux vues. 12 | 13 | La vue `pagination::slider` a pour fonction de produire une restitution élaborée d'une série de liens sur la page courante tandis que la vue `pagination::simple` affiche les boutons "précédent" et "suivant". **Ces deux vues sont compatibles avec Twitter Bootstrap.** 14 | 15 | 16 | ## Utilisation 17 | 18 | Il existe plusieurs manières de paginer des éléments. La plus simple est d'utiliser la méthode `paginate` du requêteur ou d'un modèle Eloquent. 19 | 20 | #### Paginer le résultat d'une requête de base de données 21 | 22 | $users = DB::table('users')->paginate(15); 23 | 24 | Vous pouvez aussi paginer un modèle [Eloquent](/4.1/eloquent) : 25 | 26 | #### Paginer un modèle Eloquent 27 | 28 | $allUsers = User::paginate(15); 29 | 30 | $someUsers = User::where('votes', '>', 100)->paginate(15); 31 | 32 | L'argument transmis à la méthode `paginate` est le nombre d'éléments à afficher par page. Vous pouvez placer les éléments à afficher dans une vue et créer les liens de pagination à l'aide de la méthode `links` : 33 | 34 |
    35 | 36 | name; ?> 37 | 38 |
    39 | 40 | links(); ?> 41 | 42 | Créer un système de pagination est aussi simple que cela ! Notez qu'il n'est pas nécessaire d'indiquer l'identité de la page courante au framework. Laravel le détermine automatiquement. 43 | 44 | Si vous souhaitez spécifier une vue personnalisée pour la pagination, vous pouvez passer une vue à la méthode `links` : 45 | 46 | links('view.name'); ?> 47 | 48 | Vous pouvez également accéder à des informations additionelles sur la pagination en utilisant les méthodes suivantes : 49 | 50 | - `getCurrentPage` 51 | - `getLastPage` 52 | - `getPerPage` 53 | - `getTotal` 54 | - `getFrom` 55 | - `getTo` 56 | - `count` 57 | 58 | Si vous souhaitez créer une pagination manuellement en fournissant un tableau d'éléments, utilisez la méthode `Paginator::make` : 59 | 60 | #### Créer manuellement une pagination 61 | 62 | $paginator = Paginator::make($items, $totalItems, $perPage); 63 | 64 | #### Personnaliser l'URI de la pagination 65 | 66 | Vous pouvez aussi personnaliser l'URI utilisée par la pagination via la méthode `setBaseUrl` : 67 | 68 | $users = User::paginate(); 69 | 70 | $users->setBaseUrl('custom/url'); 71 | 72 | L'exemple ci-dessus créera des URLs de la forme suivante : http://example.com/custom/url?page=2 73 | 74 | 75 | ## Ajout de paramètres sur les liens de pagination 76 | 77 | Vous pouvez ajouter des paramètres sur les liens de pagination en utilisant la méthode `appends` sur le Paginator: 78 | 79 | appends(array('sort' => 'votes'))->links(); ?> 80 | 81 | Cela génèrera une URL qui ressemblera à cela : 82 | 83 | http://example.com/something?page=2&sort=votes 84 | 85 | Si vous souhaitez ajouter un hashtag aux URLs du Paginator, vous pouvez utiliser la méthode `fragment`: 86 | 87 | fragment('foo')->links(); ?> 88 | 89 | L'appel à cette méthode permet de générer des URLs qui ressemblent à cela : 90 | 91 | http://example.com/something?page=2#foo 92 | 93 | 94 | 95 | ## Conversion en JSON 96 | 97 | La classe `Paginator` implémente le contrat `Illuminate\Support\Contracts\JsonableInterface` et fournit la méthode `toJson`. Vous pouvez aussi convertir une instance de `Paginator` en JSON en la retournant depuis une route. La version JSON retournera quelques informations "meta" tel que `total`, `current_page`, `last_page`, `from`, et `to`. Les données de l'instance se trouvent dans la clé JSON `data`. 98 | -------------------------------------------------------------------------------- /4.1/readme.md: -------------------------------------------------------------------------------- 1 | # Contribuer à la documentation (officielle) Laravel 2 | 3 | Si vous envoyez de la documentation pour la version stable courante, soumettez là sur la branche correspondante. Par exemple, la documentation pour Laravel 4.1 devra être soumise sur la branche `4.1`. La documentation pour la version future de Laravel sera sur la branche `master`. -------------------------------------------------------------------------------- /4.1/redis.md: -------------------------------------------------------------------------------- 1 | # Redis 2 | 3 | - [Introduction](#introduction) 4 | - [Configuration](#configuration) 5 | - [Utilisation](#usage) 6 | - [Pipelining](#pipelining) 7 | 8 | 9 | ## Introduction 10 | 11 | [Redis](http://redis.io) est une base de données open source de type clé-valeur. Il est souvent présenté comme un gestionnaire de données structurées puisque les clés peuvent être de type [strings](http://redis.io/topics/data-types#strings), [hashes](http://redis.io/topics/data-types#hashes), [lists](http://redis.io/topics/data-types#lists), [sets](http://redis.io/topics/data-types#sets), et [sorted sets](http://redis.io/topics/data-types#sorted-sets). 12 | 13 | 14 | ## Configuration 15 | 16 | La configuration Redis pour votre application est située dans le fichier **app/config/database.php**. Dans ce fichier, l'élément **redis** est un tableau contenant les serveurs Redis utilisés par votre application : 17 | 18 | 'redis' => array( 19 | 'cluster' => true, 20 | 'default' => array('host' => '127.0.0.1', 'port' => 6379), 21 | ), 22 | 23 | La configuration de serveur par défaut doit être suffisante pour le développement. Toutefois, vous pouvez modifier ce tableau à votre convenance. Donnez seulement un nom à chacun de vos serveurs Redis, puis indiquez le host et le port utilisés pour chaque serveur. 24 | 25 | Si votre serveur Redis requiert une identification, vous pouvez ajouter une clé `password` au tableau de configuration de votre serveur Redis. 26 | 27 | L'option `cluster` indiquera au client Redis de Laravel de faire du Sharding côté client sur les noeuds Redis, vous permettant de mettre en commun des noeuds et de créer un grand nombre de RAM disponibles. Cependant, notez que le sharding côté client ne gère pas les défaillances, de ce fait l'usage sera plutôt pour mettre en cache des données qui sont disponibles depuis une autre source. 28 | 29 | 30 | ## Utilisation 31 | 32 | Vous devez obtenir une instance Redis en appelant la méthode `Redis::connection` : 33 | 34 | $redis = Redis::connection(); 35 | 36 | 37 | Une instance du serveur Redis par défaut vous sera retournée. Vous devez indiquer le nom du serveur à la méthode `connection` afin d'obtenir un serveur spécifique comme défini dans votre configuration Redis : 38 | 39 | 40 | $redis = Redis::connection('other'); 41 | 42 | Une fois en possession d'une instance du client Redis, vous pouvez lui appliquer des [commandes Redis](http://redis.io/commands). Laravel utilise des méthodes magiques pour passer les commandes au serveur Redis : 43 | 44 | $redis->set('name', 'Taylor'); 45 | 46 | $name = $redis->get('name'); 47 | 48 | $values = $redis->lrange('names', 5, 10); 49 | 50 | Notez la simplicité avec laquelle les arguments des commandes sont passés à la méthode magique. Evidemment, vous n'êtes pas obligé d'utiliser les méthodes magiques, vous pouvez aussi transmettre des commandes au serveur en utilisant la méthode `command` : 51 | 52 | $values = $redis->command('lrange', array(5, 10)); 53 | 54 | Pour exécuter des commandes sans utiliser la connexion par défaut, utilisez les méthodes statiques magiques de la classe `Redis` : 55 | 56 | Redis::set('name', 'Taylor'); 57 | 58 | $name = Redis::get('name'); 59 | 60 | $values = Redis::lrange('names', 5, 10); 61 | 62 | > **Note:** Les drivers [cache](/4.1/cache) et [session](/4.1/session) de Redis sont fournis avec Laravel. 63 | 64 | 65 | ## Pipelining 66 | 67 | Le Pipelining doit être utilisé lorsque vous avez besoin d'envoyer plusieurs commandes au serveur en une opération. Pour ce faire, utilisez la méthode `pipeline` : 68 | 69 | #### Envoi de plusieurs commandes au serveur 70 | 71 | Redis::pipeline(function($pipe) 72 | { 73 | for ($i = 0; $i < 1000; $i++) 74 | { 75 | $pipe->set("key:$i", $i); 76 | } 77 | }); 78 | 79 | 80 | -------------------------------------------------------------------------------- /4.1/releases.md: -------------------------------------------------------------------------------- 1 | # Release Notes 2 | 3 | - [Laravel 4.1](#laravel-4.1) 4 | 5 | 6 | ## Laravel 4.1 7 | 8 | ### Liste complète des changements 9 | 10 | La liste complète des changements peut être obtenue par la commande `php artisan changes` d'une installation de Laravel 4.1, ou en [regardant le fichier des changements sur Github](https://github.com/laravel/framework/blob/4.1/src/Illuminate/Foundation/changes.json). Ces notes couvrent seulement les améliorations majeures et les changements de cette version. 11 | 12 | ### Nouveau composant SSH 13 | 14 | Un tout nouveau composant `SSH` a été inclus dans cette version. Cette fonctionnalité permet de se connecter en SSH à des serveurs distants et de lancer des commandes. Pour en savoir plus, consultez [la documentation du composant SSH](/4.1/ssh). 15 | 16 | La nouvelle commande `php artisan tail` utilise le composant SSH. Pour plus d'informations, regardez la [documentation de la commande `tail`](http:///4.1/ssh#tailing-remote-logs). 17 | 18 | ### Boris dans le Tinker 19 | 20 | La commande `php artisan tinker` utilise maintenant [Boris REPL](https://github.com/d11wtq/boris) si votre système le supporte. les extensions PHP `readline` et `pcntl` doivent être installées pour cette fonctionnalité. Si vous n'avez pas ces extensions, le shell de la version 4.0 sera utilisé. 21 | 22 | ### Amélioration d'Eloquent 23 | 24 | Une nouvelle relation `hasManyThrough` a été ajoutée dans Eloquent. Pour en savoir plus, retrouvez des informations dans la [documentation d'Eloquent](/4.1/eloquent#has-many-through). 25 | 26 | Une nouvelle méthode `whereHas` a été ajoutée également pour [retrouver des modèles en se basant sur des contraintes de relation](/4.1/eloquent#querying-relations). 27 | 28 | ### Connexion lecture/écriture en base de données 29 | 30 | Une gestion automatique de connexions séparées pour la lecture et l'écriture en base de données est maintenant disponible dans la couche de base de données, que ce soit pour le Query Builder ou Eloquent. Pour plus d'informations, consultez [la documentation](/4.1/database#read-write-connections). 31 | 32 | ### Priorité de queues 33 | 34 | Vous pouvez maintenant gérer des priorités de queue en passant une liste séparée par une virgule à la commande `queue:listen`. 35 | 36 | ### Gestion des tâches échouées 37 | 38 | Le solution de queue inclus maintenant une gestion automatique des tâches en échec en utilisant la nouvelle option `--tries` sur la commande `queue:listen`. Plus d'informations sur la gestion des tâches en échec dans la [documentation des queues](/4.1/queues#failed-jobs). 39 | 40 | ### Tags de Cache 41 | 42 | Les "sections" de Cache ont été remplacés par des "tags". Les tags de Cache permettent d'assigner plusieurs "tags" à un élément de cache, et de vider tous les éléments d'un même tag. Plus d'informations sur l'utilisation des tags dans la [documentation du cache](/4.1/cache#cache-tags). 43 | 44 | ### Rappel de mot de passe fléxible 45 | 46 | Le moteur de rappel de mot de passe a été changé pour fournir une plus grande flexibilité au développeur lors de la validation du mot de passe, du flashage des messages d'erreurs, etc. Pour plus d'informations sur l'utilisation de cet outil, [consultez la documentation](/4.1/security#password-reminders-and-reset). 47 | 48 | ### Moteur de routage amélioré 49 | 50 | Laravel 4.1 fournit une couche de routage complètement réécrite. L'API est la même; cependant, l'enregistrement d'une route est 100% plus rapide que dans la version 4.0. Le moteur a été grandement simplifié, et la dépendance à Symfony Routing a été minimisée à la compilation des expressions de routes. 51 | 52 | ### Amélioration du moteur de session 53 | 54 | Avec cette version, nous avons introduit un tout nouveau moteur de session. De la même manière que pour le routage, le nouveau moteur de session est plus léger et rapide. Nous n'utilisons plus la gestion de sessions de Symfony (et donc de PHP), nous utilisons une solution personnalisée plus facile à améliorer et maintenir. 55 | 56 | ### Doctrine DBAL 57 | 58 | Si vous utilisez la méthode `renameColumn` dans vos migrations, vous devez ajouter la dépendance `doctrine/dbal` dans votre fichier `composer.json`. Ce package n'est plus inclus par défaut avec Laravel. 59 | -------------------------------------------------------------------------------- /4.1/session.md: -------------------------------------------------------------------------------- 1 | # Les sessions 2 | 3 | - [Configuration](#configuration) 4 | - [Utilisation](#session-usage) 5 | - [Flasher des données](#flash-data) 6 | - [Enregistrer les sessions en base de données](#database-sessions) 7 | - [Drivers de session](#session-drivers) 8 | 9 | 10 | ## Configuration 11 | 12 | Puisque l'état des variables n'est pas conservé par les applications basées sur le protocole HTTP, les sessions sont un moyen de conserver des informations d'une requête à l'autre. Laravel inclut des gestionnaires de données à travers une API claire et unifiée. Laravel supporte [Memcached](http://memcached.org), [Redis](http://redis.io) et les gestionnaires de bases de données. 13 | 14 | Les sessions sont paramétrables dans le fichier `app/config/session.php`. Examinez bien les options de ce fichier, elles sont bien documentées. Par défaut, Laravel est configuré pour l'utilisation du driver de session `file` convenant à la majorité des applications. 15 | 16 | 17 | ## Utilisation 18 | 19 | #### Enregistrer une information dans une variable de session 20 | 21 | Session::put('key', 'value'); 22 | 23 | #### Empile une valeur dans une variable de session 24 | 25 | Session::push('user.teams', 'developers'); 26 | 27 | Session::push('user', 'patrick'); 28 | 29 | #### Lire une variable de session 30 | 31 | $value = Session::get('key'); 32 | 33 | #### Lire une variable ou retourner une valeur par défaut 34 | 35 | $value = Session::get('key', 'default'); 36 | 37 | $value = Session::get('key', function() { return 'default'; }); 38 | 39 | #### Retourner toutes les données de la session 40 | 41 | $data = Session::all(); 42 | 43 | #### Déterminer l'existence d'une variable de session 44 | 45 | if (Session::has('users')) 46 | { 47 | // 48 | } 49 | 50 | #### Supprimer une variable de session 51 | 52 | Session::forget('key'); 53 | 54 | #### Supprimer toutes les variables de session 55 | 56 | Session::flush(); 57 | 58 | #### Régénérer l'identifiant de session 59 | 60 | Session::regenerate(); 61 | 62 | 63 | ## Flasher des données 64 | 65 | Si vous souhaitez enregistrer des variables de session uniquement pour les transmettre à la prochaine requête, utilisez la méthode `Session::flash` : 66 | 67 | Session::flash('key', 'value'); 68 | 69 | #### Répéter le flash pour une autre requête 70 | 71 | Session::reflash(); 72 | 73 | #### Répéter le flash de certaines variables 74 | 75 | Session::keep(array('username', 'email')); 76 | 77 | 78 | ## Enregistrer les sessions en base de données 79 | 80 | Pour utiliser le driver de session `database`, vous devez créer une table destinée à stocker les variables de sessions. Voici un exemple de création d'une telle table : 81 | 82 | Schema::create('sessions', function($t) 83 | { 84 | $t->string('id')->unique(); 85 | $t->text('payload'); 86 | $t->integer('last_activity'); 87 | }); 88 | 89 | Evidemment, vous pouvez utiliser la commande Artisan `session:table` pour générer cette migration : 90 | 91 | php artisan session:table 92 | 93 | composer dump-autoload 94 | 95 | php artisan migrate 96 | 97 | 98 | ## Drivers de session 99 | 100 | Le driver de session définit où les données de session seront stockées pour chaque requête. Laravel embarque plusieurs grands drivers : 101 | 102 | - `file` - la session sera stockée dans `app/storage/sessions`. 103 | - `cookie` - la session sera stockée en sécurité, cookies cryptés. 104 | - `database` - la session sera stockée dans la base de données utilisée par votre application. 105 | - `memcached` / `redis` - la session utilisera un des plus rapides systèmes de mise en cache. 106 | - `array` - la session sera stockée dans un simple tableau PHP et ne sera pas persistante entre les requêtes. 107 | 108 | Le driver `array` est typiquement utilisé pour lancer des [tests unitaires](/4.1/testing), de ce fait aucune donnée de session ne sera persistante. 109 | -------------------------------------------------------------------------------- /4.1/upgrade.md: -------------------------------------------------------------------------------- 1 | # Guide de mise à jour 2 | 3 | - [Mise à jour de la 4.0 à 4.1](#upgrade-4.1) 4 | 5 | 6 | ## Mise à jour de la 4.0 à 4.1 7 | 8 | ### Mise à jour de la dépendance dans composer 9 | 10 | Pour mettre à jour Laravel en version 4.1, changez la version de `laravel/framework` en `4.1.*` dans votre fichier `composer.json`. 11 | 12 | ### Remplacement de fichiers 13 | 14 | Remplacez votre fichier `public/index.php` avec [cette copie fraiche du dépôt](https://github.com/laravel/laravel/blob/master/public/index.php). 15 | 16 | Remplacez votre fichier `artisan` avec [cette copie fraiche du dépôt](https://github.com/laravel/laravel/blob/master/artisan). 17 | 18 | ### Ajout de fichiers de configurations & d'options 19 | 20 | Mettez à jour les tableaux `aliases` et `providers` dans le fichier de configuration `app/config/app.php`. Les valeurs mises à jour sont disponibles dans [ce fichier](https://github.com/laravel/laravel/blob/master/app/config/app.php). Assurez vous d'ajouter à nouveau vos Service Providers et Alias personnalisés ensuite. 21 | 22 | Ajouter le nouveau fichier `app/config/remote.php` [depuis le dépôt](https://github.com/laravel/laravel/blob/master/app/config/remote.php). 23 | 24 | Ajoutez la nouvelle option de configuration `expire_on_close` dans le fichier `app/config/session.php`. la valeur par défaut est `false`. 25 | 26 | Ajouter la section de configuration `failed` dans votre fichier `app/config/queue.php`. Voici les valeurs par défaut pour ce fichier : 27 | 28 | 'failed' => array( 29 | 'database' => 'mysql', 'table' => 'failed_jobs', 30 | ), 31 | 32 | **(Optionnel)** Mettre à jour l'option de configuration `pagination` dans le fichier `app/config/view.php` pour `pagination::slider-3`. 33 | 34 | ### Controller Updates 35 | 36 | Si `app/controllers/BaseController.php` a un déclaration `use` en haut, changez `use Illuminate\Routing\Controllers\Controller;` pour `use Illuminate\Routing\Controller;`. 37 | 38 | ### Mise à jour du rappel de mot de passe 39 | 40 | Le rappel de mot de passe a été revu pour une flexibilité plus grande. Vous pouvez regarder à quoi ressemble le nouveau contrôleur en executant la commande `php artisan auth:reminders-controller`. Vous pouvez aussi regarder [la documentation mise à jour](/4.1/security#password-reminders-and-reset) et mettre à jour votre application en conséquence. 41 | 42 | Mettez à jour votre fichier `app/lang/en/reminders.php` pour qu'il corresponde [au dernier fichier](https://github.com/laravel/laravel/blob/master/app/lang/en/reminders.php). 43 | 44 | ### Mise à jour de la détection d'environnement 45 | 46 | Pour des raisons de sécurité, les noms de domaines ne doivent pas être utilisé pour detecter l'environnement de l'application. Ces valeurs sont facilement imitables et permettent d'exécuter une requête sur un environnement non désiré. Vous devez convertir la detection pour qu'elle utilise le nom de la machine (commande `hostname` sur Mac & GNU/Linux). 47 | 48 | ### Fichier de log simple 49 | 50 | Laravel génère maintenant un fichier de log unique : `app/storage/logs/laravel.log`. Cependant, cela reste configurable dans le fichier `app/start/global.php`. 51 | 52 | ### Suppression de la redirection si l'url se termine par un slash 53 | 54 | Dans le fichier `bootstrap/start.php`, supprimez l'appel à `$app->redirectIfTrailingSlash()`. Cette méthode n'est plus utilisée car la règle est gérée directement par le fichier .htaccess fournit avec le framework. 55 | 56 | Ensuite, remplacez le fichier `.htaccess` avec [cette nouvelle version](https://github.com/laravel/laravel/blob/master/public/.htaccess) 57 | 58 | ### Accès à la route actuelle 59 | 60 | La route actuelle est accessible via `Route::current()` à la place de `Route::getCurrentRoute()`. 61 | 62 | ### Composer Update 63 | 64 | Une fois que tout les étapes au dessus sont réalisées, vous pouvez lancer la commande `composer update` pour mettre à jour les fichiers du framework ! Si vous avez des erreurs de chargement de classes, essayez de lancer composer update avec l'option `--no-scripts` comme cela : `composer update --no-scripts`. 65 | -------------------------------------------------------------------------------- /4.2/artisan.md: -------------------------------------------------------------------------------- 1 | # Artisan CLI 2 | 3 | - [Introduction](#introduction) 4 | - [Utilisation](#usage) 5 | 6 | 7 | ## Introduction 8 | 9 | Artisan est le nom de l'interface en ligne de commande présente dans Laravel. Elle fournit un ensemble de commandes puissantes et utilisables pendant le développement des applications. Cette interface est basée sur le puissant composant Console de Symfony. 10 | 11 | 12 | ## Utilisation 13 | 14 | #### Afficher la liste des commandes disponibles 15 | 16 | La commande `list` permet de visualiser la liste exhaustive des commandes disponibles dans Artisan : 17 | 18 | php artisan list 19 | 20 | #### Afficher l'écran d'aide d'une commande 21 | 22 | De plus, chaque commande possède un écran d'aide décrivant les arguments et les options disponibles. Insérer le terme `help` avant le nom d'une commande permet d'afficher cet écran d'aide : 23 | 24 | php artisan help migrate 25 | 26 | #### Indiquer l'environnement d'exécution 27 | 28 | Vous pouvez indiquer l'environnement devant être utilisé pour l'exécution d'une commande à l'aide de l'option `--env` : 29 | 30 | php artisan migrate --env=local 31 | 32 | #### Afficher la version de Laravel 33 | 34 | Vous pouvez aussi afficher la version de votre installation Laravel à l'aide de l'option `--version` : 35 | 36 | php artisan --version 37 | -------------------------------------------------------------------------------- /4.2/contributing.md: -------------------------------------------------------------------------------- 1 | # Contribuer à la documentation Laravel 2 | 3 | Si vous envoyez de la documentation pour la version stable courante, soumettez là sur la branche correspondante. Par exemple, la documentation pour Laravel 4.1 devra être soumise sur la branche `4.1`. La documentation pour la version future de Laravel sera sur la branche `master`. -------------------------------------------------------------------------------- /4.2/documentation.md: -------------------------------------------------------------------------------- 1 | 2 | ### Préface 3 | - [Introduction](/4.2/introduction) 4 | - [Démarrage rapide](/4.2/quick) 5 | - [Release Notes](/4.2/releases) 6 | - [Mise à jour](/4.2/upgrade) 7 | 8 | ### Premiers pas 9 | - [Installation](/4.2/installation) 10 | - [Configuration](/4.2/configuration) 11 | - [Homestead](/4.2/homestead) 12 | - [Cycle de vie d'une requête](/4.2/lifecycle) 13 | - [Le routage](/4.2/routing) 14 | - [Requêtes et entrées](/4.2/requests) 15 | - [Les vues et les réponses](/4.2/responses) 16 | - [Les contrôleurs](/4.2/controllers) 17 | - [Les erreurs et la journalisation](/4.2/errors) 18 | 19 | ### Aller plus loin 20 | - [Identification](/4.2/security) 21 | - [Facturation](/docs/billing) 22 | - [La gestion du cache](/4.2/cache) 23 | - [Étendre le Framework](/4.2/extending) 24 | - [Les événements](/4.2/events) 25 | - [Facades](/4.2/facades) 26 | - [Formulaires & HTML](/4.2/html) 27 | - [Helpers](/4.2/helpers) 28 | - [Le conteneur de dépendances](/4.2/ioc) 29 | - [Traduction & Localisation](/4.2/localization) 30 | - [Email](/4.2/mail) 31 | - [Développement de packages](/4.2/packages) 32 | - [La pagination](/4.2/pagination) 33 | - [Les files de travaux](/4.2/queues) 34 | - [La sécurité](/4.2/security) 35 | - [Les sessions](/4.2/session) 36 | - [SSH](/4.2/ssh) 37 | - [Les templates](/4.2/templates) 38 | - [Les tests unitaires](/4.2/testing) 39 | - [La validation](/4.2/validation) 40 | 41 | ### Base de données 42 | - [Les bases de données](/4.2/database) 43 | - [Query Builder](/4.2/queries) 44 | - [L'ORM Eloquent](/4.2/eloquent) 45 | - [Le constructeur de schéma](/4.2/schema) 46 | - [Les migrations et la population](/4.2/migrations) 47 | - [Redis](/4.2/redis) 48 | 49 | ### Artisan CLI 50 | - [Présentation](/4.2/artisan) 51 | - [Développement de commandes](/4.2/commands) 52 | -------------------------------------------------------------------------------- /4.2/home.md: -------------------------------------------------------------------------------- 1 | # Documentation de Laravel v4 2 | 3 | La documentation est **en cours de traduction**. Vous pouvez y contribuer sur le dépôt github suivant : 4 | 5 | [https://github.com/laravel-france/laravel-france-doc/](https://github.com/laravel-france/laravel-france-doc/) 6 | 7 | Les pages non traduites ou partiellement traduites sont marquées d'un (en). -------------------------------------------------------------------------------- /4.2/introduction.md: -------------------------------------------------------------------------------- 1 | # Introduction 2 | 3 | - [Où débuter](#where-to-start) 4 | - [Philosophie de Laravel](#laravel-philosophy) 5 | - [Ressources additionnelles](#additional-resources) 6 | - [Equipe de développement](#development-team) 7 | 8 | 9 | ## Où débuter 10 | 11 | Apprendre un nouveau framework peut être intimidant, mais aussi excitant. Pour faciliter votre transition, nous avons essayé de créer une documentation concise et très claire pour Laravel. Voici quelques recommandations de ce qu'il faut lire en premier : 12 | 13 | - [Installation](/4.1/installation) et [Configuration](/4.1/configuration). 14 | - [Routage](/4.1/routing) 15 | - [Requêtes et entrées](/4.1/requests) 16 | - [Vues et Réponses](/4.1/responses) 17 | - [Contrôleurs](/4.1/controllers) 18 | 19 | Après avoir lu tous ces documents, vous devriez avoir une bonne connaissance du système basique requête / réponse dans Laravel. Ensuite, vous pouvez lire [la configuration de votre base de données](/4.1/database), le [Query Builder](/4.1/queries), et [l'ORM Eloquent](/4.1/eloquent). Vous pouvez aussi lire [l'authentification et la sécurité](4/security), pour pouvoir commencer à enregistrer des personnes dans votre application. 20 | 21 | 22 | ## Philosophie de Laravel 23 | 24 | Laravel est un framework web dont la syntaxe est expressive et élégante. Nous pensons que le développement doit être plaisant, créatif et épanouissant. Laravel tente d'alléger le développement en facilitant les tâches communes à la majorité des applications web telles que l'authentification, le routage, les sessions et la gestion de cache. 25 | 26 | Laravel a pour objectif de rendre le développement agréable tout en permettant de développer des fonctionnalités adaptées. Des développeurs heureux produisent un code meilleur. Pour cela, nous avons tenté de combiner le meilleur de ce que nous avons trouvé dans d'autres frameworks web, incluant les frameworks d'autres langages comme Ruby On Rails, ASP.NET et Sinatra. 27 | 28 | Laravel est accessible mais puissant, fournissant des outils suffisants pour des applications larges et robustes. Un superbe conteneur d'inversion de contrôle, un système de migration expressif, et une intégration de tests unitaires, vous offrent les outils nécessaires pour construire n'importe quelle application que vous devez réaliser. 29 | 30 | 31 | ## Ressources additionnelles 32 | 33 | Une des meilleures façons d'apprendre Laravel est de lire sa documentation de bout en bout. Ce guide détaille tous les aspects du framework et la manière de les mettre en oeuvre dans vos applications. 34 | 35 | Par ailleurs, jetez un coup d'oeil aux [livres sur Laravel](http://wiki.laravel.io/Books). Ces ouvrages rédigés par la communauté constituent de bon compléments pour l'apprentissage du framework : 36 | 37 | - [Code Bright](https://leanpub.com/codebright) par Dayle Rees 38 | - [Laravel Testing Decoded](https://leanpub.com/laravel-testing-decoded) par Jeffrey Way 39 | - [Laravel: From Apprentice To Artisan](https://leanpub.com/laravel) par Taylor Otwell 40 | - [Implementing Laravel](https://leanpub.com/implementinglaravel) par Chris Fidao 41 | - [Getting Stuff Done With Laravel 4](https://leanpub.com/gettingstuffdonelaravel) par Chuck Heintzelman 42 | - [Laravel 4 Cookbook](https://leanpub.com/laravel4cookbook) par Christopher Pitt 43 | - [Laravel in Action](http://www.manning.com/surguy/) par Maks Surguy 44 | 45 | 46 | ## Equipe de développement 47 | 48 | Laravel a été créé par [Taylor Otwell](https://github.com/taylorotwell), qui continue de diriger le développement du framework. Voici d'autres membres importants de la communauté et contributeurs : [Dayle Rees](https://github.com/daylerees), [Shawn McCool](https://github.com/ShawnMcCool), [Jeffrey Way](https://github.com/JeffreyWay), [Jason Lewis](https://github.com/jasonlewis), [Ben Corlett](https://github.com/bencorlett), [Franz Liedke](https://github.com/franzliedke), [Dries Vints](https://github.com/driesvints), [Mior Muhammad Zaki](https://github.com/crynobone), et [Phil Sturgeon](https://github.com/philsturgeon). 49 | -------------------------------------------------------------------------------- /4.2/license.md: -------------------------------------------------------------------------------- 1 | MIT license, Copyright (c) Taylor Otwell 2 | 3 | Traduction par Laravel.fr 4 | 5 | L'autorisation est accordée, gracieusement, à toute personne acquérant une copie de cette bibliothèque et des fichiers de documentation associés (la "Bibliothèque"), de commercialiser la Bibliothèque sans restriction, notamment les droits d'utiliser, de copier, de modifier, de fusionner, de publier, de distribuer, de sous-licencier et / ou de vendre des copies de la Bibliothèque, ainsi que d'autoriser les personnes auxquelles la Bibliothèque est fournie à le faire, sous réserve des conditions suivantes : 6 | 7 | La déclaration de copyright ci-dessus et la présente autorisation doivent être incluses dans toutes copies ou parties substantielles de la Bibliothèque. 8 | 9 | LA BIBLIOTHÈQUE EST FOURNIE "TELLE QUELLE", SANS GARANTIE D'AUCUNE SORTE, EXPLICITE OU IMPLICITE, NOTAMMENT SANS GARANTIE DE QUALITÉ MARCHANDE, D’ADÉQUATION À UN USAGE PARTICULIER ET D'ABSENCE DE CONTREFAÇON. EN AUCUN CAS, LES AUTEURS OU TITULAIRES DU DROIT D'AUTEUR NE SERONT RESPONSABLES DE TOUT DOMMAGE, RÉCLAMATION OU AUTRE RESPONSABILITÉ, QUE CE SOIT DANS LE CADRE D'UN CONTRAT, D'UN DÉLIT OU AUTRE, EN PROVENANCE DE, CONSÉCUTIF À OU EN RELATION AVEC LA BIBLIOTHÈQUE OU SON UTILISATION, OU AVEC D'AUTRES ÉLÉMENTS DE LA BIBLIOTHÈQUE. 10 | -------------------------------------------------------------------------------- /4.2/localization.md: -------------------------------------------------------------------------------- 1 | # Traduction & Localisation 2 | 3 | - [Introduction](#introduction) 4 | - [Fichiers de langues](#language-files) 5 | - [Utilisation basique](#basic-usage) 6 | - [Plurialisation](#pluralization) 7 | - [Localisation de la validation](#validation) 8 | - [Surcharger les fichiers de langues d'un package](#overriding-package-language-files) 9 | 10 | 11 | ## Introduction 12 | 13 | La classe `Lang` fournit une manière efficace de retrouver des chaînes de caractères de différentes langues, vous permettant de supporter facilement plusieurs langues au sein de votre application. 14 | 15 | 16 | ## Fichiers de langues 17 | 18 | Les chaînes de langues sont stockées dans des fichiers à l'intérieur du dossier `app/lang`. Dans ce dossier, il doit y avoir un dossier pour chaque langue supportée par votre application. 19 | 20 | /app 21 | /lang 22 | /en 23 | messages.php 24 | /fr 25 | messages.php 26 | 27 | Les fichiers de langues sont simplements des tableaux avec des clés. Par exemple: 28 | 29 | #### Fichier de langue d'exemple 30 | 31 | 'Bienvenue sur notre application' 35 | ); 36 | 37 | La langue par défaut est définie dans le fichier de configuration `app/config/app.php`. Vous pouvez changer la langue durant l'exécution grâce à la méthode `App::setLocale` : 38 | 39 | #### Changement de langue durant l'exécution 40 | 41 | App::setLocale('fr'); 42 | 43 | 44 | ## Utilisation basique 45 | 46 | #### Retrouve une ligne depuis un fichier de traduction 47 | 48 | echo Lang::get('messages.welcome'); 49 | 50 | Le premier segment passé à la méthode `get` est le nom du fichier de traduction, dans notre cas il s'agit de 'messages'. La seconde partie est le nom de la ligne qui doit être retrouvée, dans notre cas 'welcome'. 51 | 52 | > **Note*: Si la ligne n'existe pas dans le fichier, la clé sera renvoyée par la méthode `get`. 53 | 54 | Vous pouvez aussi utiliser la fonction `trans`, qui est un alias de la méthode `Lang::get`. 55 | 56 | echo trans('messages.welcome'); 57 | 58 | #### Ligne de traduction variable 59 | 60 | Vous pouvez placer une variable dans votre ligne de langue : 61 | 62 | 'welcome' => 'Bienvenue, :name', 63 | 64 | Ensuite, passez un tableau de correspondance en tant que second argument à la méthode `Lang::get` : 65 | 66 | echo Lang::get('messages.welcome', array('name' => 'Dayle')); 67 | 68 | #### Determine si un fichier de traduction contient une ligne 69 | 70 | if (Lang::has('messages.welcome')) 71 | { 72 | // la ligne est trouvée 73 | } 74 | 75 | 76 | ## Plurialisation 77 | 78 | Pluralisation est un problème complexe, étant donné que les règles ne sont pas les mêmes selon les langues. Vous pouvez gérer cela facilement dans vos fichiers de langues. En utilisant le caractère '|', vous pouvez séparer le singulier et le pluriel d'une chaîne : 79 | 80 | 'pommes' => 'Il y a une pomme|Il y a plusieurs pommes', 81 | 82 | Ensuite, vous utiliserez la méthode `Lang::choice` pour retrouver cette ligne: 83 | 84 | echo Lang::choice('messages.apples', 10); 85 | 86 | Etant donné que le traducteur de Laravel utilise le composant Translation de Symfony, vous pouvez créer des règles de plurialisation très explicites facilement : 87 | 88 | 'apples' => '{0} Il n\'y en a pas|[1,19] Il y en a quelques une|[20,Inf] Il y en a beaucoup', 89 | 90 | 91 | ## Localisation de la validation 92 | 93 | Pour la localisation des messages et erreurs de la validation, veuillez jetez un oeil sur la documentation de Validation. 94 | 95 | 96 | ## Surcharger les fichiers de langue d'un package 97 | 98 | Plusieurs packages sont fournit avec leurs propres lignes de langue. Plutôt que de faire un hack sur les fichiers du package, vous pouvez les surcharger en plaçant des fichiers dans le dossier `app/lang/packages/{locale}/{package}`. Donc par exemple, si vous avez besoin de surcharger les lignes françaises dans le fichier `messages.php` d'un package nommé `skyrim/hearthfire`, vous placerez vos fichiers de langue dans : `app/lang/packages/en/hearthfire/messages.php`. Dans ce fichier vous définirez uniquement les lignes que vous souhaitez surcharger. Toutes les lignes non surchargées garderons la valeur tel que définie dans le package. 99 | -------------------------------------------------------------------------------- /4.2/pagination.md: -------------------------------------------------------------------------------- 1 | # La pagination 2 | 3 | - [Configuration](#configuration) 4 | - [Utilisation](#usage) 5 | - [Ajout de paramètres sur les liens de pagination](#appending-to-pagination-links) 6 | - [Conversion en JSON](#converting-to-json) 7 | 8 | 9 | ## Configuration 10 | 11 | Dans d'autres frameworks, mettre en place une pagination peut être difficile. Laravel facilite cette tâche. Il suffit de valoriser l'option `pagination` du fichier `app/config/view.php` avec la vue à utiliser pour créer des liens de pagination. Par défaut, Laravel inclut deux vues. 12 | 13 | La vue `pagination::slider` a pour fonction de produire une restitution élaborée d'une série de liens sur la page courante tandis que la vue `pagination::simple` affiche les boutons "précédent" et "suivant". **Ces deux vues sont compatibles avec Twitter Bootstrap.** 14 | 15 | 16 | ## Utilisation 17 | 18 | Il existe plusieurs manières de paginer des éléments. La plus simple est d'utiliser la méthode `paginate` du requêteur ou d'un modèle Eloquent. 19 | 20 | #### Paginer le résultat d'une requête de base de données 21 | 22 | $users = DB::table('users')->paginate(15); 23 | 24 | Vous pouvez aussi paginer un modèle [Eloquent](/4.1/eloquent) : 25 | 26 | #### Paginer un modèle Eloquent 27 | 28 | $allUsers = User::paginate(15); 29 | 30 | $someUsers = User::where('votes', '>', 100)->paginate(15); 31 | 32 | L'argument transmis à la méthode `paginate` est le nombre d'éléments à afficher par page. Vous pouvez placer les éléments à afficher dans une vue et créer les liens de pagination à l'aide de la méthode `links` : 33 | 34 |
    35 | 36 | name; ?> 37 | 38 |
    39 | 40 | links(); ?> 41 | 42 | Créer un système de pagination est aussi simple que cela ! Notez qu'il n'est pas nécessaire d'indiquer l'identité de la page courante au framework. Laravel le détermine automatiquement. 43 | 44 | Si vous souhaitez spécifier une vue personnalisée pour la pagination, vous pouvez passer une vue à la méthode `links` : 45 | 46 | links('view.name'); ?> 47 | 48 | Vous pouvez également accéder à des informations additionelles sur la pagination en utilisant les méthodes suivantes : 49 | 50 | - `getCurrentPage` 51 | - `getLastPage` 52 | - `getPerPage` 53 | - `getTotal` 54 | - `getFrom` 55 | - `getTo` 56 | - `count` 57 | 58 | Si vous souhaitez créer une pagination manuellement en fournissant un tableau d'éléments, utilisez la méthode `Paginator::make` : 59 | 60 | #### Créer manuellement une pagination 61 | 62 | $paginator = Paginator::make($items, $totalItems, $perPage); 63 | 64 | #### Personnaliser l'URI de la pagination 65 | 66 | Vous pouvez aussi personnaliser l'URI utilisée par la pagination via la méthode `setBaseUrl` : 67 | 68 | $users = User::paginate(); 69 | 70 | $users->setBaseUrl('custom/url'); 71 | 72 | L'exemple ci-dessus créera des URLs de la forme suivante : http://example.com/custom/url?page=2 73 | 74 | 75 | ## Ajout de paramètres sur les liens de pagination 76 | 77 | Vous pouvez ajouter des paramètres sur les liens de pagination en utilisant la méthode `appends` sur le Paginator: 78 | 79 | appends(array('sort' => 'votes'))->links(); ?> 80 | 81 | Cela génèrera une URL qui ressemblera à cela : 82 | 83 | http://example.com/something?page=2&sort=votes 84 | 85 | Si vous souhaitez ajouter un hashtag aux URLs du Paginator, vous pouvez utiliser la méthode `fragment`: 86 | 87 | fragment('foo')->links(); ?> 88 | 89 | L'appel à cette méthode permet de générer des URLs qui ressemblent à cela : 90 | 91 | http://example.com/something?page=2#foo 92 | 93 | 94 | 95 | ## Conversion en JSON 96 | 97 | La classe `Paginator` implémente le contrat `Illuminate\Support\Contracts\JsonableInterface` et fournit la méthode `toJson`. Vous pouvez aussi convertir une instance de `Paginator` en JSON en la retournant depuis une route. La version JSON retournera quelques informations "meta" tel que `total`, `current_page`, `last_page`, `from`, et `to`. Les données de l'instance se trouvent dans la clé JSON `data`. 98 | -------------------------------------------------------------------------------- /4.2/readme.md: -------------------------------------------------------------------------------- 1 | # Contribuer à la documentation (officielle) Laravel 2 | 3 | Si vous envoyez de la documentation pour la version stable courante, soumettez là sur la branche correspondante. Par exemple, la documentation pour Laravel 4.1 devra être soumise sur la branche `4.1`. La documentation pour la version future de Laravel sera sur la branche `master`. -------------------------------------------------------------------------------- /4.2/redis.md: -------------------------------------------------------------------------------- 1 | # Redis 2 | 3 | - [Introduction](#introduction) 4 | - [Configuration](#configuration) 5 | - [Utilisation](#usage) 6 | - [Pipelining](#pipelining) 7 | 8 | 9 | ## Introduction 10 | 11 | [Redis](http://redis.io) est une base de données open source de type clé-valeur. Il est souvent présenté comme un gestionnaire de données structurées puisque les clés peuvent être de type [strings](http://redis.io/topics/data-types#strings), [hashes](http://redis.io/topics/data-types#hashes), [lists](http://redis.io/topics/data-types#lists), [sets](http://redis.io/topics/data-types#sets), et [sorted sets](http://redis.io/topics/data-types#sorted-sets). 12 | 13 | 14 | ## Configuration 15 | 16 | La configuration Redis pour votre application est située dans le fichier **app/config/database.php**. Dans ce fichier, l'élément **redis** est un tableau contenant les serveurs Redis utilisés par votre application : 17 | 18 | 'redis' => array( 19 | 'cluster' => true, 20 | 'default' => array('host' => '127.0.0.1', 'port' => 6379), 21 | ), 22 | 23 | La configuration de serveur par défaut doit être suffisante pour le développement. Toutefois, vous pouvez modifier ce tableau à votre convenance. Donnez seulement un nom à chacun de vos serveurs Redis, puis indiquez le host et le port utilisés pour chaque serveur. 24 | 25 | Si votre serveur Redis requiert une identification, vous pouvez ajouter une clé `password` au tableau de configuration de votre serveur Redis. 26 | 27 | L'option `cluster` indiquera au client Redis de Laravel de faire du Sharding côté client sur les noeuds Redis, vous permettant de mettre en commun des noeuds et de créer un grand nombre de RAM disponibles. Cependant, notez que le sharding côté client ne gère pas les défaillances, de ce fait l'usage sera plutôt pour mettre en cache des données qui sont disponibles depuis une autre source. 28 | 29 | 30 | ## Utilisation 31 | 32 | Vous devez obtenir une instance Redis en appelant la méthode `Redis::connection` : 33 | 34 | $redis = Redis::connection(); 35 | 36 | 37 | Une instance du serveur Redis par défaut vous sera retournée. Vous devez indiquer le nom du serveur à la méthode `connection` afin d'obtenir un serveur spécifique comme défini dans votre configuration Redis : 38 | 39 | 40 | $redis = Redis::connection('other'); 41 | 42 | Une fois en possession d'une instance du client Redis, vous pouvez lui appliquer des [commandes Redis](http://redis.io/commands). Laravel utilise des méthodes magiques pour passer les commandes au serveur Redis : 43 | 44 | $redis->set('name', 'Taylor'); 45 | 46 | $name = $redis->get('name'); 47 | 48 | $values = $redis->lrange('names', 5, 10); 49 | 50 | Notez la simplicité avec laquelle les arguments des commandes sont passés à la méthode magique. Evidemment, vous n'êtes pas obligé d'utiliser les méthodes magiques, vous pouvez aussi transmettre des commandes au serveur en utilisant la méthode `command` : 51 | 52 | $values = $redis->command('lrange', array(5, 10)); 53 | 54 | Pour exécuter des commandes sans utiliser la connexion par défaut, utilisez les méthodes statiques magiques de la classe `Redis` : 55 | 56 | Redis::set('name', 'Taylor'); 57 | 58 | $name = Redis::get('name'); 59 | 60 | $values = Redis::lrange('names', 5, 10); 61 | 62 | > **Note:** Les drivers [cache](/4.1/cache) et [session](/4.1/session) de Redis sont fournis avec Laravel. 63 | 64 | 65 | ## Pipelining 66 | 67 | Le Pipelining doit être utilisé lorsque vous avez besoin d'envoyer plusieurs commandes au serveur en une opération. Pour ce faire, utilisez la méthode `pipeline` : 68 | 69 | #### Envoi de plusieurs commandes au serveur 70 | 71 | Redis::pipeline(function($pipe) 72 | { 73 | for ($i = 0; $i < 1000; $i++) 74 | { 75 | $pipe->set("key:$i", $i); 76 | } 77 | }); 78 | 79 | 80 | -------------------------------------------------------------------------------- /4.2/releases.md: -------------------------------------------------------------------------------- 1 | # Release Notes 2 | 3 | - [Laravel 4.1](#laravel-4.1) 4 | 5 | 6 | ## Laravel 4.1 7 | 8 | ### Liste complète des changements 9 | 10 | La liste complète des changements peut être obtenue par la commande `php artisan changes` d'une installation de Laravel 4.1, ou en [regardant le fichier des changements sur Github](https://github.com/laravel/framework/blob/4.1/src/Illuminate/Foundation/changes.json). Ces notes couvrent seulement les améliorations majeures et les changements de cette version. 11 | 12 | ### Nouveau composant SSH 13 | 14 | Un tout nouveau composant `SSH` a été inclus dans cette version. Cette fonctionnalité permet de se connecter en SSH à des serveurs distants et de lancer des commandes. Pour en savoir plus, consultez [la documentation du composant SSH](/4.1/ssh). 15 | 16 | La nouvelle commande `php artisan tail` utilise le composant SSH. Pour plus d'informations, regardez la [documentation de la commande `tail`](http:///4.1/ssh#tailing-remote-logs). 17 | 18 | ### Boris dans le Tinker 19 | 20 | La commande `php artisan tinker` utilise maintenant [Boris REPL](https://github.com/d11wtq/boris) si votre système le supporte. les extensions PHP `readline` et `pcntl` doivent être installées pour cette fonctionnalité. Si vous n'avez pas ces extensions, le shell de la version 4.0 sera utilisé. 21 | 22 | ### Amélioration d'Eloquent 23 | 24 | Une nouvelle relation `hasManyThrough` a été ajoutée dans Eloquent. Pour en savoir plus, retrouvez des informations dans la [documentation d'Eloquent](/4.1/eloquent#has-many-through). 25 | 26 | Une nouvelle méthode `whereHas` a été ajoutée également pour [retrouver des modèles en se basant sur des contraintes de relation](/4.1/eloquent#querying-relations). 27 | 28 | ### Connexion lecture/écriture en base de données 29 | 30 | Une gestion automatique de connexions séparées pour la lecture et l'écriture en base de données est maintenant disponible dans la couche de base de données, que ce soit pour le Query Builder ou Eloquent. Pour plus d'informations, consultez [la documentation](/4.1/database#read-write-connections). 31 | 32 | ### Priorité de queues 33 | 34 | Vous pouvez maintenant gérer des priorités de queue en passant une liste séparée par une virgule à la commande `queue:listen`. 35 | 36 | ### Gestion des tâches échouées 37 | 38 | Le solution de queue inclus maintenant une gestion automatique des tâches en échec en utilisant la nouvelle option `--tries` sur la commande `queue:listen`. Plus d'informations sur la gestion des tâches en échec dans la [documentation des queues](/4.1/queues#failed-jobs). 39 | 40 | ### Tags de Cache 41 | 42 | Les "sections" de Cache ont été remplacés par des "tags". Les tags de Cache permettent d'assigner plusieurs "tags" à un élément de cache, et de vider tous les éléments d'un même tag. Plus d'informations sur l'utilisation des tags dans la [documentation du cache](/4.1/cache#cache-tags). 43 | 44 | ### Rappel de mot de passe fléxible 45 | 46 | Le moteur de rappel de mot de passe a été changé pour fournir une plus grande flexibilité au développeur lors de la validation du mot de passe, du flashage des messages d'erreurs, etc. Pour plus d'informations sur l'utilisation de cet outil, [consultez la documentation](/4.1/security#password-reminders-and-reset). 47 | 48 | ### Moteur de routage amélioré 49 | 50 | Laravel 4.1 fournit une couche de routage complètement réécrite. L'API est la même; cependant, l'enregistrement d'une route est 100% plus rapide que dans la version 4.0. Le moteur a été grandement simplifié, et la dépendance à Symfony Routing a été minimisée à la compilation des expressions de routes. 51 | 52 | ### Amélioration du moteur de session 53 | 54 | Avec cette version, nous avons introduit un tout nouveau moteur de session. De la même manière que pour le routage, le nouveau moteur de session est plus léger et rapide. Nous n'utilisons plus la gestion de sessions de Symfony (et donc de PHP), nous utilisons une solution personnalisée plus facile à améliorer et maintenir. 55 | 56 | ### Doctrine DBAL 57 | 58 | Si vous utilisez la méthode `renameColumn` dans vos migrations, vous devez ajouter la dépendance `doctrine/dbal` dans votre fichier `composer.json`. Ce package n'est plus inclus par défaut avec Laravel. 59 | -------------------------------------------------------------------------------- /4.2/session.md: -------------------------------------------------------------------------------- 1 | # Les sessions 2 | 3 | - [Configuration](#configuration) 4 | - [Utilisation](#session-usage) 5 | - [Flasher des données](#flash-data) 6 | - [Enregistrer les sessions en base de données](#database-sessions) 7 | - [Drivers de session](#session-drivers) 8 | 9 | 10 | ## Configuration 11 | 12 | Puisque l'état des variables n'est pas conservé par les applications basées sur le protocole HTTP, les sessions sont un moyen de conserver des informations d'une requête à l'autre. Laravel inclut des gestionnaires de données à travers une API claire et unifiée. Laravel supporte [Memcached](http://memcached.org), [Redis](http://redis.io) et les gestionnaires de bases de données. 13 | 14 | Les sessions sont paramétrables dans le fichier `app/config/session.php`. Examinez bien les options de ce fichier, elles sont bien documentées. Par défaut, Laravel est configuré pour l'utilisation du driver de session `file` convenant à la majorité des applications. 15 | 16 | 17 | ## Utilisation 18 | 19 | #### Enregistrer une information dans une variable de session 20 | 21 | Session::put('key', 'value'); 22 | 23 | #### Empile une valeur dans une variable de session 24 | 25 | Session::push('user.teams', 'developers'); 26 | 27 | Session::push('user', 'patrick'); 28 | 29 | #### Lire une variable de session 30 | 31 | $value = Session::get('key'); 32 | 33 | #### Lire une variable ou retourner une valeur par défaut 34 | 35 | $value = Session::get('key', 'default'); 36 | 37 | $value = Session::get('key', function() { return 'default'; }); 38 | 39 | #### Retourner toutes les données de la session 40 | 41 | $data = Session::all(); 42 | 43 | #### Déterminer l'existence d'une variable de session 44 | 45 | if (Session::has('users')) 46 | { 47 | // 48 | } 49 | 50 | #### Supprimer une variable de session 51 | 52 | Session::forget('key'); 53 | 54 | #### Supprimer toutes les variables de session 55 | 56 | Session::flush(); 57 | 58 | #### Régénérer l'identifiant de session 59 | 60 | Session::regenerate(); 61 | 62 | 63 | ## Flasher des données 64 | 65 | Si vous souhaitez enregistrer des variables de session uniquement pour les transmettre à la prochaine requête, utilisez la méthode `Session::flash` : 66 | 67 | Session::flash('key', 'value'); 68 | 69 | #### Répéter le flash pour une autre requête 70 | 71 | Session::reflash(); 72 | 73 | #### Répéter le flash de certaines variables 74 | 75 | Session::keep(array('username', 'email')); 76 | 77 | 78 | ## Enregistrer les sessions en base de données 79 | 80 | Pour utiliser le driver de session `database`, vous devez créer une table destinée à stocker les variables de sessions. Voici un exemple de création d'une telle table : 81 | 82 | Schema::create('sessions', function($t) 83 | { 84 | $t->string('id')->unique(); 85 | $t->text('payload'); 86 | $t->integer('last_activity'); 87 | }); 88 | 89 | Evidemment, vous pouvez utiliser la commande Artisan `session:table` pour générer cette migration : 90 | 91 | php artisan session:table 92 | 93 | composer dump-autoload 94 | 95 | php artisan migrate 96 | 97 | 98 | ## Drivers de session 99 | 100 | Le driver de session définit où les données de session seront stockées pour chaque requête. Laravel embarque plusieurs grands drivers : 101 | 102 | - `file` - la session sera stockée dans `app/storage/sessions`. 103 | - `cookie` - la session sera stockée en sécurité, cookies cryptés. 104 | - `database` - la session sera stockée dans la base de données utilisée par votre application. 105 | - `memcached` / `redis` - la session utilisera un des plus rapides systèmes de mise en cache. 106 | - `array` - la session sera stockée dans un simple tableau PHP et ne sera pas persistante entre les requêtes. 107 | 108 | Le driver `array` est typiquement utilisé pour lancer des [tests unitaires](/4.1/testing), de ce fait aucune donnée de session ne sera persistante. 109 | -------------------------------------------------------------------------------- /4.2/upgrade.md: -------------------------------------------------------------------------------- 1 | # Guide de mise à jour 2 | 3 | - [Mise à jour de la 4.0 à 4.1](#upgrade-4.1) 4 | 5 | 6 | ## Mise à jour de la 4.0 à 4.1 7 | 8 | ### Mise à jour de la dépendance dans composer 9 | 10 | Pour mettre à jour Laravel en version 4.1, changez la version de `laravel/framework` en `4.1.*` dans votre fichier `composer.json`. 11 | 12 | ### Remplacement de fichiers 13 | 14 | Remplacez votre fichier `public/index.php` avec [cette copie fraiche du dépôt](https://github.com/laravel/laravel/blob/master/public/index.php). 15 | 16 | Remplacez votre fichier `artisan` avec [cette copie fraiche du dépôt](https://github.com/laravel/laravel/blob/master/artisan). 17 | 18 | ### Ajout de fichiers de configurations & d'options 19 | 20 | Mettez à jour les tableaux `aliases` et `providers` dans le fichier de configuration `app/config/app.php`. Les valeurs mises à jour sont disponibles dans [ce fichier](https://github.com/laravel/laravel/blob/master/app/config/app.php). Assurez vous d'ajouter à nouveau vos Service Providers et Alias personnalisés ensuite. 21 | 22 | Ajouter le nouveau fichier `app/config/remote.php` [depuis le dépôt](https://github.com/laravel/laravel/blob/master/app/config/remote.php). 23 | 24 | Ajoutez la nouvelle option de configuration `expire_on_close` dans le fichier `app/config/session.php`. la valeur par défaut est `false`. 25 | 26 | Ajouter la section de configuration `failed` dans votre fichier `app/config/queue.php`. Voici les valeurs par défaut pour ce fichier : 27 | 28 | 'failed' => array( 29 | 'database' => 'mysql', 'table' => 'failed_jobs', 30 | ), 31 | 32 | **(Optionnel)** Mettre à jour l'option de configuration `pagination` dans le fichier `app/config/view.php` pour `pagination::slider-3`. 33 | 34 | ### Controller Updates 35 | 36 | Si `app/controllers/BaseController.php` a un déclaration `use` en haut, changez `use Illuminate\Routing\Controllers\Controller;` pour `use Illuminate\Routing\Controller;`. 37 | 38 | ### Mise à jour du rappel de mot de passe 39 | 40 | Le rappel de mot de passe a été revu pour une flexibilité plus grande. Vous pouvez regarder à quoi ressemble le nouveau contrôleur en executant la commande `php artisan auth:reminders-controller`. Vous pouvez aussi regarder [la documentation mise à jour](/4.1/security#password-reminders-and-reset) et mettre à jour votre application en conséquence. 41 | 42 | Mettez à jour votre fichier `app/lang/en/reminders.php` pour qu'il corresponde [au dernier fichier](https://github.com/laravel/laravel/blob/master/app/lang/en/reminders.php). 43 | 44 | ### Mise à jour de la détection d'environnement 45 | 46 | Pour des raisons de sécurité, les noms de domaines ne doivent pas être utilisé pour detecter l'environnement de l'application. Ces valeurs sont facilement imitables et permettent d'exécuter une requête sur un environnement non désiré. Vous devez convertir la detection pour qu'elle utilise le nom de la machine (commande `hostname` sur Mac & GNU/Linux). 47 | 48 | ### Fichier de log simple 49 | 50 | Laravel génère maintenant un fichier de log unique : `app/storage/logs/laravel.log`. Cependant, cela reste configurable dans le fichier `app/start/global.php`. 51 | 52 | ### Suppression de la redirection si l'url se termine par un slash 53 | 54 | Dans le fichier `bootstrap/start.php`, supprimez l'appel à `$app->redirectIfTrailingSlash()`. Cette méthode n'est plus utilisée car la règle est gérée directement par le fichier .htaccess fournit avec le framework. 55 | 56 | Ensuite, remplacez le fichier `.htaccess` avec [cette nouvelle version](https://github.com/laravel/laravel/blob/master/public/.htaccess) 57 | 58 | ### Accès à la route actuelle 59 | 60 | La route actuelle est accessible via `Route::current()` à la place de `Route::getCurrentRoute()`. 61 | 62 | ### Composer Update 63 | 64 | Une fois que tout les étapes au dessus sont réalisées, vous pouvez lancer la commande `composer update` pour mettre à jour les fichiers du framework ! Si vous avez des erreurs de chargement de classes, essayez de lancer composer update avec l'option `--no-scripts` comme cela : `composer update --no-scripts`. 65 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | This is not maintained anymore. Please use official documentation at https://laravel.com/docs 2 | -------------------------------------------------------------------------------- /dev/artisan.md: -------------------------------------------------------------------------------- 1 | # Artisan CLI 2 | 3 | - [Introduction](#introduction) 4 | - [Utilisation](#usage) 5 | 6 | 7 | ## Introduction 8 | 9 | Artisan est le nom de l'interface en ligne de commande présente dans Laravel. Elle fournit un ensemble de commandes puissantes et utilisables pendant le développement des applications. Cette interface est basée sur le puissant composant Console de Symfony. 10 | 11 | 12 | ## Utilisation 13 | 14 | La commande `list` permet de visualiser la liste exhaustive des commandes disponibles dans Artisan : 15 | 16 | #### Afficher la liste des commandes disponibles 17 | 18 | php artisan list 19 | 20 | De plus, chaque commande possède un écran d'aide décrivant les arguments et les options disponibles. Insérer le terme `help` avant le nom d'une commande permet d'afficher cet écran d'aide : 21 | 22 | #### Afficher l'écran d'aide d'une commande 23 | 24 | php artisan help migrate 25 | 26 | Vous pouvez indiquer l'environnement devant être utilisé pour l'exécution d'une commande à l'aide de l'option `--env` : 27 | 28 | #### Indiquer l'environnement d'exécution 29 | 30 | php artisan migrate --env=local 31 | 32 | Vous pouvez aussi afficher la version de votre installation Laravel à l'aide de l'option `--version` : 33 | 34 | #### Afficher la version de Laravel 35 | 36 | php artisan --version 37 | -------------------------------------------------------------------------------- /dev/contributing.md: -------------------------------------------------------------------------------- 1 | # Contribuer à la documentation Laravel 2 | 3 | Si vous envoyez de la documentation pour la version stable courante, soumettez là sur la branche correspondante. Par exemple, la documentation pour Laravel 4.1 devra être soumise sur la branche `4.1`. La documentation pour la version future de Laravel sera sur la branche `master`. -------------------------------------------------------------------------------- /dev/documentation.md: -------------------------------------------------------------------------------- 1 | 2 | ### Préface 3 | - [Introduction](/dev/introduction) 4 | - [Démarrage rapide](/dev/quick) 5 | - [Release Notes](/dev/releases) 6 | - [Mise à jour](/dev/upgrade) 7 | 8 | ### Premiers pas 9 | - [Installation](/dev/installation) 10 | - [Configuration](/dev/configuration) 11 | - [Cycle de vie d'une requête](/dev/lifecycle) 12 | - [Le routage](/dev/routing) 13 | - [Requêtes et entrées](/dev/requests) 14 | - [Les vues et les réponses](/dev/responses) 15 | - [Les contrôleurs](/dev/controllers) 16 | - [Les erreurs et la journalisation](/dev/errors) 17 | 18 | ### Aller plus loin 19 | - [Identification](/dev/security) 20 | - [La gestion du cache](/dev/cache) 21 | - [Les événements](/dev/events) 22 | - [Étendre le Framework](/dev/extending) 23 | - [Facades](/dev/facades) 24 | - [Formulaires & HTML](/dev/html) 25 | - [Helpers](/dev/helpers) 26 | - [Le conteneur de dépendances](/dev/ioc) 27 | - [Traduction & Localisation](/dev/localization) 28 | - [Email](/dev/mail) 29 | - [Développement de packages](/dev/packages) 30 | - [La pagination](/dev/pagination) 31 | - [Les files de travaux](/dev/queues) 32 | - [La sécurité](/dev/security) 33 | - [Les sessions](/dev/session) 34 | - [SSH](/dev/ssh) 35 | - [Les templates](/dev/templates) 36 | - [Les tests unitaires](/dev/testing) 37 | - [La validation](/dev/validation) 38 | 39 | ### Base de données 40 | - [Les bases de données](/dev/database) 41 | - [Query Builder](/dev/queries) 42 | - [L'ORM Eloquent](/dev/eloquent) 43 | - [Le constructeur de schéma](/dev/schema) 44 | - [Les migrations et la population](/dev/migrations) 45 | - [Redis](/dev/redis) 46 | 47 | ### Artisan CLI 48 | - [Présentation](/dev/artisan) 49 | - [Développement de commandes](/dev/commands) 50 | -------------------------------------------------------------------------------- /dev/home.md: -------------------------------------------------------------------------------- 1 | # Documentation de Laravel v4 2 | 3 | La documentation est **en cours de traduction**. Vous pouvez y contribuer sur le dépôt github suivant : 4 | 5 | [https://github.com/laravel-france/laravel-france-doc/](https://github.com/laravel-france/laravel-france-doc/) 6 | 7 | Les pages non traduites ou partiellement traduites sont marquées d'un (en). -------------------------------------------------------------------------------- /dev/installation.md: -------------------------------------------------------------------------------- 1 | # Installation 2 | 3 | - [Installation de Composer](#install-composer) 4 | - [Installation de Laravel](#install-laravel) 5 | - [Prérequis](#server-requirements) 6 | - [Configuration](#configuration) 7 | - [Permissions](#permissions) 8 | - [Des URLs propres](#pretty-urls) 9 | 10 | 11 | ## Installation de Composer 12 | 13 | Laravel utilise [Composer](http://getcomposer.org) pour gérer ses dépendances. Premièrement, téléchargez une copie de `composer.phar`. Une fois que vous avez l'archive PHAR, vous pouvez soit la laisser dans le dossier local de votre projet, soit la déplacer vers `usr/local/bin` pour l'utiliser de manière globale sur votre système. Sur Windows, vous pouvez utiliser l'installeur de Composer [pour Windows](https://getcomposer.org/Composer-Setup.exe). 14 | 15 | 16 | ## Installation de Laravel 17 | 18 | ### Via Laravel Installer 19 | 20 | D'abord, téléchargez [l'archive PHAR de Laravel installer](http://laravel.com/laravel.phar). Pour des raisons pratique, nous vous conseillons de renommer le fichier en `laravel` et de le déplacer dans `/usr/local/bin`. Une fois installé, la simple commande `laravel new` vous créera une installation fraiche de Laravel dans le dossier spécifié. Par exemple, `laravel new blog` créera un dossier `blog` qui contiendra une installation fraiche de Laravel avec toutes les dépendances installées. Cette méthode est plus rapide que celle via Composer 21 | 22 | ### Via Composer Create-Project 23 | 24 | Vous pouvez également installer Laravel en exécutant la commande `create-project` de composer dans votre terminal : 25 | 26 | composer create-project laravel/laravel --prefer-dist 27 | 28 | ### Via un téléchargement 29 | 30 | Une fois que Composer est installé, téléchargez la [dernière version](https://github.com/laravel/laravel/archive/master.zip) du framework, et extrayez son contenu dans un dossier sur votre serveur. Ensuite, à la racine de votre application Laravel, lancez la commande `php composer.phar install` pour installer toutes les dépendances du framework. Ce process requis que git soit installé sur le serveur pour terminer l'installation. 31 | 32 | Si vous souhaitez mettre à jour le framework Laravel, vous pouvez exécuter la commande `php composer.phar update`. 33 | 34 | 35 | ## Prérequis 36 | 37 | Le framework Laravel a quelques prérequis système : 38 | 39 | - PHP >= 5.3.7 40 | - L'extension PHP MCrypt 41 | 42 | > Quant à PHP 5.5, certaines distributions d'OS peuvent requérir l'installation manuelle de l'extension PHP JSON. Pour Ubuntu, la commande est `apt-get install php5-json`. 43 | 44 | 45 | ## Configuration 46 | 47 | Laravel n'a presque pas besoin de configuration pour fonctionner. En fait, vous êtes libre de commencer à développer ! Cependant, vous devriez au minimum jeter un oeil au fichier `app/config/app.php` et à sa documentation. Il contient plusieurs options comme `timezone` et `locale` que vous pourriez vouloir changer pour votre application. 48 | 49 | 50 | ### Permissions 51 | 52 | Laravel peut avoir besoin que le serveur web ait un accès en écriture sur les dossiers à l'intérieur de `app/storage`. 53 | 54 | 55 | ### Chemins 56 | 57 | Plusieurs chemins des dossiers du Framework sont configurables. Pour changer leurs positions, regardez le fichier `bootstrap/paths.php`. 58 | 59 | 60 | ## Des URLs propres 61 | 62 | Le framework est fourni avec un fichier `public/.htaccess` qui est utilisé pour autoriser les URLs sans `index.php`. Si vous utilisez Apache pour servir votre application Laravel, veuillez vous assurer que le module `mod_rewrite` est actif. 63 | 64 | Si le fichier `.htaccess` fourni avec Laravel ne fonctionne pas, essayez celui ci : 65 | 66 | Options +FollowSymLinks 67 | RewriteEngine On 68 | 69 | RewriteCond %{REQUEST_FILENAME} !-d 70 | RewriteCond %{REQUEST_FILENAME} !-f 71 | RewriteRule ^ index.php [L] 72 | -------------------------------------------------------------------------------- /dev/introduction.md: -------------------------------------------------------------------------------- 1 | # Introduction 2 | 3 | - [Où débuter](#where-to-start) 4 | - [Philosophie de Laravel](#laravel-philosophy) 5 | - [Ressources additionnelles](#additional-resources) 6 | - [Equipe de développement](#development-team) 7 | 8 | 9 | ## Où débuter 10 | 11 | Apprendre un nouveau framework peut être intimidant, mais aussi excitant. Pour faciliter votre transition, nous avons essayé de créer une documentation concise et très claire pour Laravel. Voici quelques recommandations de ce qu'il faut lire en premier : 12 | 13 | - [Installation](/dev/installation) et [Configuration](/dev/configuration). 14 | - [Routage](/dev/routing) 15 | - [Requêtes et entrées](/dev/requests) 16 | - [Vues et Réponses](/dev/responses) 17 | - [Contrôleurs](/dev/controllers) 18 | 19 | Après avoir lu tous ces documents, vous devriez avoir une bonne connaissance sur le système basique requête / réponse dans Laravel. Ensuite, vous pouvez lire sur [la configuration de votre base de données](/dev/database), le [Query Builder](/dev/queries), et [l'ORM Eloquent](/dev/eloquent). Ou, vous pouvez lire sur [l'authentification et la sécurité](4/security), de sorte que vous pouvez commencer à enregistrer des gens dans votre application. 20 | 21 | 22 | ## Philosophie de Laravel 23 | 24 | Laravel est un framework web dont la syntaxe est expressive et élégante. Le développement doit être plaisant, créatif et épanouissant. Laravel tente d'alléger le développement en facilitant les tâches communes à la majorité des applications web telles que l'authentification, le routage, les sessions et la gestion de cache. 25 | 26 | Laravel a pour objectif de rendre le développement agréable tout en permettant de développer des fonctionnalités adaptées. Des développeurs heureux produisent du code meilleur. Pour cela, nous avons tenté de combiner le meilleur de ce que nous avons trouvé dans d'autres frameworks web, incluant les frameworks d'autres langages comme Ruby On Rails, ASP.NET et Sinatra. 27 | 28 | Laravel est accessible, puissant, fournissant des outils puissants pour des applications larges et robustes. Un superbe conteneur d'inversion de contrôle, un système de migration expressif, et un support pour l'intégration de tests unitaires vous donnent les outils nécessaires pour construire n'importe quelle application que vous devez réaliser. 29 | 30 | 31 | ## Ressources additionnelles 32 | 33 | Une des meilleurs façons d'apprendre Laravel est de lire sa documentation de bout en bout. Ce guide détaille tous les aspects du framework et la manière de les mettre en oeuvre dans vos applications. 34 | 35 | Par ailleurs, jetez un coup d'oeil aux [livres sur Laravel](http://wiki.laravel.io/Books). Ces ouvrages constituent de bon compléments pour l'apprentissage du framework. 36 | 37 | - [Code Bright](https://leanpub.com/codebright) par Dayle Rees 38 | - [Laravel Testing Decoded](https://leanpub.com/laravel-testing-decoded) par Jeffrey Way 39 | - [Laravel: From Apprentice To Artisan](https://leanpub.com/laravel) par Taylor Otwell 40 | - [Implementing Laravel](https://leanpub.com/implementinglaravel) par Chris Fidao 41 | - [Getting Stuff Done With Laravel 4](https://leanpub.com/gettingstuffdonelaravel) par Chuck Heintzelman 42 | - [Laravel 4 Cookbook](https://leanpub.com/laravel4cookbook) par Christopher Pitt 43 | - [Laravel in Action](http://www.manning.com/surguy/) par Maks Surguy 44 | 45 | 46 | ## Equipe de développement 47 | 48 | Laravel a été créé par [Taylor Otwell](https://github.com/taylorotwell), qui continue de diriger le développement du framework. D'autres membres proéminents de la communauté et contributeurs incluant [Dayle Rees](https://github.com/daylerees), [Shawn McCool](https://github.com/ShawnMcCool), [Jeffrey Way](https://github.com/JeffreyWay), [Jason Lewis](https://github.com/jasonlewis), [Ben Corlett](https://github.com/bencorlett), [Franz Liedke](https://github.com/franzliedke), [Dries Vints](https://github.com/driesvints), [Mior Muhammad Zaki](https://github.com/crynobone), et [Phil Sturgeon](https://github.com/philsturgeon). 49 | -------------------------------------------------------------------------------- /dev/license.md: -------------------------------------------------------------------------------- 1 | MIT license, Copyright (c) Taylor Otwell 2 | 3 | Traduction par Laravel.fr 4 | 5 | L'autorisation est accordée, gracieusement, à toute personne acquérant une copie de cette bibliothèque et des fichiers de documentation associés (la "Bibliothèque"), de commercialiser la Bibliothèque sans restriction, notamment les droits d'utiliser, de copier, de modifier, de fusionner, de publier, de distribuer, de sous-licencier et / ou de vendre des copies de la Bibliothèque, ainsi que d'autoriser les personnes auxquelles la Bibliothèque est fournie à le faire, sous réserve des conditions suivantes : 6 | 7 | La déclaration de copyright ci-dessus et la présente autorisation doivent être incluses dans toutes copies ou parties substantielles de la Bibliothèque. 8 | 9 | LA BIBLIOTHÈQUE EST FOURNIE "TELLE QUELLE", SANS GARANTIE D'AUCUNE SORTE, EXPLICITE OU IMPLICITE, NOTAMMENT SANS GARANTIE DE QUALITÉ MARCHANDE, D’ADÉQUATION À UN USAGE PARTICULIER ET D'ABSENCE DE CONTREFAÇON. EN AUCUN CAS, LES AUTEURS OU TITULAIRES DU DROIT D'AUTEUR NE SERONT RESPONSABLES DE TOUT DOMMAGE, RÉCLAMATION OU AUTRE RESPONSABILITÉ, QUE CE SOIT DANS LE CADRE D'UN CONTRAT, D'UN DÉLIT OU AUTRE, EN PROVENANCE DE, CONSÉCUTIF À OU EN RELATION AVEC LA BIBLIOTHÈQUE OU SON UTILISATION, OU AVEC D'AUTRES ÉLÉMENTS DE LA BIBLIOTHÈQUE. 10 | -------------------------------------------------------------------------------- /dev/localization.md: -------------------------------------------------------------------------------- 1 | # Traduction & Localisation 2 | 3 | - [Introduction](#introduction) 4 | - [Fichiers de langues](#language-files) 5 | - [Utilisation basique](#basic-usage) 6 | - [Plurialisation](#pluralization) 7 | - [Localisation de la validation](#validation) 8 | - [Surcharger les fichiers de langues d'un package](#overriding-package-language-files) 9 | 10 | 11 | ## Introduction 12 | 13 | La classe `Lang` fournit une manière efficace de retrouver des chaînes de caractères de différentes langues, vous permettant de supporter facilement plusieurs langues au sein de votre application. 14 | 15 | 16 | ## Fichiers de langues 17 | 18 | Les chaînes de langues sont stockées dans des fichiers à l'intérieur du dossier `app/lang`. Dans ce dossier, il doit y avoir un dossier pour chaque langue supportée par votre application. 19 | 20 | /app 21 | /lang 22 | /en 23 | messages.php 24 | /fr 25 | messages.php 26 | 27 | Les fichiers de langues sont simplements des tableaux avec des clés. Par exemple: 28 | 29 | #### Fichier de langue d'exemple 30 | 31 | 'Bienvenue sur notre application' 35 | ); 36 | 37 | La langue par défaut est définie dans le fichier de configuration `app/config/app.php`. Vous pouvez changer la langue durant l'exécution grâce à la méthode `App::setLocale` : 38 | 39 | #### Changement de langue durant l'exécution 40 | 41 | App::setLocale('fr'); 42 | 43 | 44 | ## Utilisation basique 45 | 46 | #### Retrouve une ligne depuis un fichier de traduction 47 | 48 | echo Lang::get('messages.welcome'); 49 | 50 | Le premier segment passé à la méthode `get` est le nom du fichier de traduction, dans notre cas il s'agit de 'messages'. La seconde partie est le nom de la ligne qui doit être retrouvée, dans notre cas 'welcome'. 51 | 52 | > **Note*: Si la ligne n'existe pas dans le fichier, la clé sera renvoyée par la méthode `get`. 53 | 54 | Vous pouvez aussi utiliser la fonction `trans`, qui est un alias de la méthode `Lang::get`. 55 | 56 | echo trans('messages.welcome'); 57 | 58 | #### Ligne de traduction variable 59 | 60 | Vous pouvez placer une variable dans votre ligne de langue : 61 | 62 | 'welcome' => 'Bienvenue, :name', 63 | 64 | Ensuite, passez un tableau de correspondance en tant que second argument à la méthode `Lang::get` : 65 | 66 | echo Lang::get('messages.welcome', array('name' => 'Dayle')); 67 | 68 | #### Determine si un fichier de traduction contient une ligne 69 | 70 | if (Lang::has('messages.welcome')) 71 | { 72 | // la ligne est trouvée 73 | } 74 | 75 | 76 | ## Plurialisation 77 | 78 | Pluralisation est un problème complexe, étant donné que les règles ne sont pas les mêmes selon les langues. Vous pouvez gérer cela facilement dans vos fichiers de langues. En utilisant le caractère '|', vous pouvez séparer le singulier et le pluriel d'une chaîne : 79 | 80 | 'pommes' => 'Il y a une pomme|Il y a plusieurs pommes', 81 | 82 | Ensuite, vous utiliserez la méthode `Lang::choice` pour retrouver cette ligne: 83 | 84 | echo Lang::choice('messages.apples', 10); 85 | 86 | Etant donné que le traducteur de Laravel utilise le composant Translation de Symfony, vous pouvez créer des règles de plurialisation très explicites facilement : 87 | 88 | 'apples' => '{0} Il n\'y en a pas|[1,19] Il y en a quelques une|[20,Inf] Il y en a beaucoup', 89 | 90 | 91 | ## Localisation de la validation 92 | 93 | Pour la localisation des messages et erreurs de la validation, veuillez jetez un oeil sur la documentation de Validation. 94 | 95 | 96 | ## Surcharger les fichiers de langue d'un package 97 | 98 | Plusieurs packages sont fournit avec leurs propres lignes de langue. Plutôt que de faire un hack sur les fichiers du package, vous pouvez les surcharger en plaçant des fichiers dans le dossier `app/lang/packages/{locale}`. Donc par exemple, si vous avez besoin de surcharger les lignes françaises d'un package nommé `skyrim/hearthfire`, vous placerez vos fichiers de langue dans : `app/lang/packages/fr/hearthfire.php`. Dans ce fichier vous définirez uniquement les lignes que vous souhaitez surcharger. Toutes les lignes non surchargées garderons la valeur tel que définie dans le package. -------------------------------------------------------------------------------- /dev/pagination.md: -------------------------------------------------------------------------------- 1 | # La pagination 2 | 3 | - [Configuration](#configuration) 4 | - [Utilisation](#usage) 5 | - [Ajout de paramètres sur les liens de pagination](#appending-to-pagination-links) 6 | - [Conversion en JSON](#converting-to-json) 7 | 8 | 9 | ## Configuration 10 | 11 | Dans d'autres frameworks, mettre en place une pagination peut être difficile. Laravel facilite cette tâche. Il suffit de valoriser l'option `pagination` du fichier `app/config/view.php` avec la vue à utiliser pour créer des liens de pagination. Par défaut, Laravel inclut deux vues. 12 | 13 | La vue `pagination::slider` a pour fonction de produire une restitution élaborée d'une série de liens sur la page courante tandis que la vue `pagination::simple` affiche les boutons "précédent" et "suivant". **Ces deux vues sont compatibles avec Twitter Bootstrap.** 14 | 15 | 16 | ## Utilisation 17 | 18 | Il existe plusieurs manières de paginer des éléments. La plus simple est d'utiliser la méthode `paginate` du requêteur ou d'un modèle Eloquent. 19 | 20 | #### Paginer le résultat d'une requête de base de données 21 | 22 | $users = DB::table('users')->paginate(15); 23 | 24 | Vous pouvez aussi paginer un modèle [Eloquent](/dev/eloquent) : 25 | 26 | #### Paginer un modèle Eloquent 27 | 28 | $allUsers = User::paginate(15); 29 | 30 | $someUsers = User::where('votes', '>', 100)->paginate(15); 31 | 32 | L'argument transmis à la méthode `paginate` est le nombre d'éléments à afficher par page. Vous pouvez placer les éléments à afficher dans une vue et créer les liens de pagination à l'aide de la méthode `links` : 33 | 34 |
    35 | 36 | name; ?> 37 | 38 |
    39 | 40 | links(); ?> 41 | 42 | Créer un système de pagination est aussi simple que cela ! Notez qu'il n'est pas nécessaire d'indiquer l'identité de la page courante au framework. Laravel le détermine automatiquement. 43 | 44 | Si vous souhaitez spécifier une vue personnalisée pour la pagination, vous pouvez passer une vue à la méthode `links` : 45 | 46 | links('view.name'); ?> 47 | 48 | Vous pouvez également accéder à des informations additionelles sur la pagination en utilisant les méthodes suivantes : 49 | 50 | - `getCurrentPage` 51 | - `getLastPage` 52 | - `getPerPage` 53 | - `getTotal` 54 | - `getFrom` 55 | - `getTo` 56 | - `count` 57 | 58 | Si vous souhaitez créer une pagination manuellement en fournissant un tableau d'éléments, utilisez la méthode `Paginator::make` : 59 | 60 | #### Créer manuellement une pagination 61 | 62 | $paginator = Paginator::make($items, $totalItems, $perPage); 63 | 64 | #### Personnaliser l'URI de la pagination 65 | 66 | Vous pouvez aussi personnaliser l'URI utilisée par la pagination via la méthode `setBaseUrl` : 67 | 68 | $users = User::paginate(); 69 | 70 | $users->setBaseUrl('custom/url'); 71 | 72 | L'exemple ci-dessus créera des URLs de la forme suivante : http://example.com/custom/url?page=2 73 | 74 | 75 | ## Ajout de paramètres sur les liens de pagination 76 | 77 | Vous pouvez ajouter des paramètres sur les liens de pagination en utilisant la méthode `appends` sur le Paginator: 78 | 79 | appends(array('sort' => 'votes'))->links(); ?> 80 | 81 | Cela génèrera une URL qui ressemblera à cela : 82 | 83 | http://example.com/something?page=2&sort=votes 84 | 85 | Si vous souhaitez ajouter un hashtag aux URLs du Paginator, vous pouvez utiliser la méthode `fragment`: 86 | 87 | fragment('foo')->links(); ?> 88 | 89 | L'appel à cette méthode permet de générer des URLs qui ressemblent à cela : 90 | 91 | http://example.com/something?page=2#foo 92 | 93 | 94 | 95 | ## Conversion en JSON 96 | 97 | La classe `Paginator` implémente le contrat `Illuminate\Support\Contracts\JsonableInterface` et fournit la méthode `toJson`. Vous pouvez aussi convertir une instance de `Paginator` en JSON en la retournant depuis une route. La version JSON retournera quelques informations "meta" tel que `total`, `current_page`, `last_page`, `from`, et `to`. Les données de l'instance se trouvent dans la clé JSON `data`. 98 | -------------------------------------------------------------------------------- /dev/readme.md: -------------------------------------------------------------------------------- 1 | # Contribuer à la documentation (officielle) Laravel 2 | 3 | Si vous envoyez de la documentation pour la version stable courante, soumettez là sur la branche correspondante. Par exemple, la documentation pour Laravel 4.1 devra être soumise sur la branche `4.1`. La documentation pour la version future de Laravel sera sur la branche `master`. -------------------------------------------------------------------------------- /dev/redis.md: -------------------------------------------------------------------------------- 1 | # Redis 2 | 3 | - [Introduction](#introduction) 4 | - [Configuration](#configuration) 5 | - [Utilisation](#usage) 6 | - [Pipelining](#pipelining) 7 | 8 | 9 | ## Introduction 10 | 11 | [Redis](http://redis.io) est une base de données open source de type clé-valeur. Il est souvent présenté comme un gestionnaire de données structurées puisque les clés peuvent être de type [strings](http://redis.io/topics/data-types#strings), [hashes](http://redis.io/topics/data-types#hashes), [lists](http://redis.io/topics/data-types#lists), [sets](http://redis.io/topics/data-types#sets), et [sorted sets](http://redis.io/topics/data-types#sorted-sets). 12 | 13 | 14 | ## Configuration 15 | 16 | La configuration Redis pour votre application est située dans le fichier **app/config/database.php**. Dans ce fichier, l'élément **redis** est un tableau contenant les serveurs Redis utilisés par votre application : 17 | 18 | 'redis' => array( 19 | 'cluster' => true, 20 | 'default' => array('host' => '127.0.0.1', 'port' => 6379), 21 | ), 22 | 23 | La configuration de serveur par défaut doit être suffisante pour le développement. Toutefois, vous pouvez modifier ce tableau à votre convenance. Donnez seulement un nom à chacun de vos serveurs Redis, puis indiquez le host et le port utilisés pour chaque serveur. 24 | 25 | Si votre serveur Redis requiert une identification, vous pouvez ajouter une clé `password` au tableau de configuration de votre serveur Redis. 26 | 27 | L'option `cluster` indiquera au client Redis de Laravel de faire du Sharding côté client sur les noeuds Redis, vous permettant de mettre en commun des noeuds et de créer un grand nombre de RAM disponibles. Cependant, notez que le sharding côté client ne gère pas les défaillances, de ce fait l'usage sera plutôt pour mettre en cache des données qui sont disponibles depuis une autre source. 28 | 29 | 30 | ## Utilisation 31 | 32 | Vous devez obtenir une instance Redis en appelant la méthode `Redis::connection` : 33 | 34 | $redis = Redis::connection(); 35 | 36 | 37 | Une instance du serveur Redis par défaut vous sera retournée. Vous devez indiquer le nom du serveur à la méthode `connection` afin d'obtenir un serveur spécifique comme défini dans votre configuration Redis : 38 | 39 | 40 | $redis = Redis::connection('other'); 41 | 42 | Une fois en possession d'une instance du client Redis, vous pouvez lui appliquer des [commandes Redis](http://redis.io/commands). Laravel utilise des méthodes magiques pour passer les commandes au serveur Redis : 43 | 44 | $redis->set('name', 'Taylor'); 45 | 46 | $name = $redis->get('name'); 47 | 48 | $values = $redis->lrange('names', 5, 10); 49 | 50 | Notez la simplicité avec laquelle les arguments des commandes sont passés à la méthode magique. Evidemment, vous n'êtes pas obligé d'utiliser les méthodes magiques, vous pouvez aussi transmettre des commandes au serveur en utilisant la méthode `command` : 51 | 52 | $values = $redis->command('lrange', array(5, 10)); 53 | 54 | Pour exécuter des commandes sans utiliser la connexion par défaut, utilisez les méthodes statiques magiques de la classe `Redis` : 55 | 56 | Redis::set('name', 'Taylor'); 57 | 58 | $name = Redis::get('name'); 59 | 60 | $values = Redis::lrange('names', 5, 10); 61 | 62 | > **Note:** Les drivers [cache](/dev/cache) et [session](/dev/session) de Redis sont fournis avec Laravel. 63 | 64 | 65 | ## Pipelining 66 | 67 | Le Pipelining doit être utilisé lorsque vous avez besoin d'envoyer plusieurs commandes au serveur en une opération. Pour ce faire, utilisez la méthode `pipeline` : 68 | 69 | #### Envoi de plusieurs commandes au serveur 70 | 71 | Redis::pipeline(function($pipe) 72 | { 73 | for ($i = 0; $i < 1000; $i++) 74 | { 75 | $pipe->set("key:$i", $i); 76 | } 77 | }); 78 | 79 | 80 | -------------------------------------------------------------------------------- /dev/releases.md: -------------------------------------------------------------------------------- 1 | # Release Notes 2 | 3 | - [Laravel 4.1](#laravel-4.1) 4 | 5 | 6 | ## Laravel 4.1 7 | 8 | ### Liste complète des changements 9 | 10 | La liste complète des changements peut être obtenue par la commande `php artisan changes` d'une installation de Laravel 4.1, ou en [regardant le fichier des changements sur Github](https://github.com/laravel/framework/blob/4.1/src/Illuminate/Foundation/changes.json). Ces notes couvrent seulement les améliorations majeures et les changements de cette version. 11 | 12 | ### Nouveau composant SSH 13 | 14 | Un tout nouveau composant `SSH` a été inclus dans cette version. Cette fonctionnalité permet de se connecter en SSH à des serveurs distants et de lancer des commandes. Pour en savoir plus, consultez [la documentation du composant SSH](/dev/ssh). 15 | 16 | La nouvelle commande `php artisan tail` utilise le composant SSH. Pour plus d'informations, regardez la [documentation de la commande `tail`](http:///4.1/ssh#tailing-remote-logs). 17 | 18 | ### Boris dans le Tinker 19 | 20 | La commande `php artisan tinker` utilise maintenant [Boris REPL](https://github.com/d11wtq/boris) si votre système le supporte. les extensions PHP `readline` et `pcntl` doivent être installées pour cette fonctionnalité. Si vous n'avez pas ces extensions, le shell de la version 4.0 sera utilisé. 21 | 22 | ### Amélioration d'Eloquent 23 | 24 | Une nouvelle relation `hasManyThrough` a été ajoutée dans Eloquent. Pour en savoir plus, retrouvez des informations dans la [documentation d'Eloquent](/dev/eloquent#has-many-through). 25 | 26 | Une nouvelle méthode `whereHas` a été ajoutée également pour [retrouver des modèles en se basant sur des contraintes de relation](/dev/eloquent#querying-relations). 27 | 28 | ### Connexion lecture/écriture en base de données 29 | 30 | Une gestion automatique de connexions séparées pour la lecture et l'écriture en base de données est maintenant disponible dans la couche de base de données, que ce soit pour le Query Builder ou Eloquent. Pour plus d'informations, consultez [la documentation](/dev/database#read-write-connections). 31 | 32 | ### Priorité de queues 33 | 34 | Vous pouvez maintenant gérer des priorités de queue en passant une liste séparée par une virgule à la commande `queue:listen`. 35 | 36 | ### Gestion des tâches échouées 37 | 38 | Le solution de queue inclus maintenant une gestion automatique des tâches en échec en utilisant la nouvelle option `--tries` sur la commande `queue:listen`. Plus d'informations sur la gestion des tâches en échec dans la [documentation des queues](/dev/queues#failed-jobs). 39 | 40 | ### Tags de Cache 41 | 42 | Les "sections" de Cache ont été remplacés par des "tags". Les tags de Cache permettent d'assigner plusieurs "tags" à un élément de cache, et de vider tous les éléments d'un même tag. Plus d'informations sur l'utilisation des tags dans la [documentation du cache](/dev/cache#cache-tags). 43 | 44 | ### Rappel de mot de passe fléxible 45 | 46 | Le moteur de rappel de mot de passe a été changé pour fournir une plus grande flexibilité au développeur lors de la validation du mot de passe, du flashage des messages d'erreurs, etc. Pour plus d'informations sur l'utilisation de cet outil, [consultez la documentation](/dev/security#password-reminders-and-reset). 47 | 48 | ### Moteur de routage amélioré 49 | 50 | Laravel 4.1 fournit une couche de routage complètement réécrite. L'API est la même; cependant, l'enregistrement d'une route est 100% plus rapide que dans la version 4.0. Le moteur a été grandement simplifié, et la dépendance à Symfony Routing a été minimisée à la compilation des expressions de routes. 51 | 52 | ### Amélioration du moteur de session 53 | 54 | Avec cette version, nous avons introduit un tout nouveau moteur de session. De la même manière que pour le routage, le nouveau moteur de session est plus léger et rapide. Nous n'utilisons plus la gestion de sessions de Symfony (et donc de PHP), nous utilisons une solution personnalisée plus facile à améliorer et maintenir. 55 | 56 | ### Doctrine DBAL 57 | 58 | Si vous utilisez la méthode `renameColumn` dans vos migrations, vous devez ajouter la dépendance `doctrine/dbal` dans votre fichier `composer.json`. Ce package n'est plus inclus par défaut avec Laravel. 59 | -------------------------------------------------------------------------------- /dev/session.md: -------------------------------------------------------------------------------- 1 | # Les sessions 2 | 3 | - [Configuration](#configuration) 4 | - [Utilisation](#session-usage) 5 | - [Flasher des données](#flash-data) 6 | - [Enregistrer les sessions en base de données](#database-sessions) 7 | - [Drivers de session](#session-drivers) 8 | 9 | 10 | ## Configuration 11 | 12 | Puisque l'état des variables n'est pas conservé par les applications basées sur le protocole HTTP, les sessions sont un moyen de conserver des informations d'une requête à l'autre. Laravel inclut des gestionnaires de données à travers une API claire et unifiée. Laravel supporte [Memcached](http://memcached.org), [Redis](http://redis.io) et les gestionnaires de bases de données. 13 | 14 | Les sessions sont paramétrables dans le fichier `app/config/session.php`. Examinez bien les options de ce fichier, elles sont bien documentées. Par défaut, Laravel est configuré pour l'utilisation du driver de session `file` convenant à la majorité des applications. 15 | 16 | 17 | ## Utilisation 18 | 19 | #### Enregistrer une information dans une variable de session 20 | 21 | Session::put('key', 'value'); 22 | 23 | #### Empile une valeur dans une variable de session 24 | 25 | Session::push('user.teams', 'developers'); 26 | 27 | Session::push('user', 'patrick'); 28 | 29 | #### Lire une variable de session 30 | 31 | $value = Session::get('key'); 32 | 33 | #### Lire une variable ou retourner une valeur par défaut 34 | 35 | $value = Session::get('key', 'default'); 36 | 37 | $value = Session::get('key', function() { return 'default'; }); 38 | 39 | #### Retourner toutes les données de la session 40 | 41 | $data = Session::all(); 42 | 43 | #### Déterminer l'existence d'une variable de session 44 | 45 | if (Session::has('users')) 46 | { 47 | // 48 | } 49 | 50 | #### Supprimer une variable de session 51 | 52 | Session::forget('key'); 53 | 54 | #### Supprimer toutes les variables de session 55 | 56 | Session::flush(); 57 | 58 | #### Régénérer l'identifiant de session 59 | 60 | Session::regenerate(); 61 | 62 | 63 | ## Flasher des données 64 | 65 | Si vous souhaitez enregistrer des variables de session uniquement pour les transmettre à la prochaine requête, utilisez la méthode `Session::flash` : 66 | 67 | Session::flash('key', 'value'); 68 | 69 | #### Répéter le flash pour une autre requête 70 | 71 | Session::reflash(); 72 | 73 | #### Répéter le flash de certaines variables 74 | 75 | Session::keep(array('username', 'email')); 76 | 77 | 78 | ## Enregistrer les sessions en base de données 79 | 80 | Pour utiliser le driver de session `database`, vous devez créer une table destinée à stocker les variables de sessions. Voici un exemple de création d'une telle table : 81 | 82 | Schema::create('sessions', function($t) 83 | { 84 | $t->string('id')->unique(); 85 | $t->text('payload'); 86 | $t->integer('last_activity'); 87 | }); 88 | 89 | Evidemment, vous pouvez utiliser la commande Artisan `session:table` pour générer cette migration : 90 | 91 | php artisan session:table 92 | 93 | composer dump-autoload 94 | 95 | php artisan migrate 96 | 97 | 98 | ## Drivers de session 99 | 100 | Le driver de session définit où les données de session seront stockées pour chaque requête. Laravel embarque plusieurs grands drivers : 101 | 102 | - `file` - la session sera stockée dans `app/storage/sessions`. 103 | - `cookie` - la session sera stockée en sécurité, cookies cryptés. 104 | - `database` - la session sera stockée dans la base de données utilisée par votre application. 105 | - `memcached` / `redis` - la session utilisera un des plus rapides systèmes de mise en cache. 106 | - `array` - la session sera stockée dans un simple tableau PHP et ne sera pas persistante entre les requêtes. 107 | 108 | Le driver `array` est typiquement utilisé pour lancer des [tests unitaires](/dev/testing), de ce fait aucune donnée de session ne sera persistante. 109 | -------------------------------------------------------------------------------- /dev/ssh.md: -------------------------------------------------------------------------------- 1 | # SSH 2 | 3 | - [Configuration](#configuration) 4 | - [Basic Usage](#basic-usage) 5 | - [Tasks](#tasks) 6 | - [SFTP Uploads](#sftp-uploads) 7 | - [Tailing Remote Logs](#tailing-remote-logs) 8 | 9 | 10 | ## Configuration 11 | 12 | Laravel includes a simple way to SSH into remote servers and run commands, allowing you to easily build Artisan tasks that work on remote servers. The `SSH` facade provides the access point to connecting to your remote servers and running commands. 13 | 14 | The configuration file is located at `app/config/remote.php`, and contains all of the options you need to configure your remote connections. The `connections` array contains a list of your servers keyed by name. Simple populate the credentials in the `connections` array and you will be ready to start running remote tasks. Note that the `SSH` can authenticate using either a password or an SSH key. 15 | 16 | 17 | ## Basic Usage 18 | 19 | #### Running Commands On The Default Server 20 | 21 | To run commands on your `default` remote connection, use the `SSH::run` method: 22 | 23 | SSH::run(array( 24 | 'cd /var/www', 25 | 'git pull origin master', 26 | )); 27 | 28 | #### Running Commands On A Specific Connection 29 | 30 | Alternatively, you may run commands on a specific connection using the `into` method: 31 | 32 | SSH::into('staging')->run(array( 33 | 'cd /var/www', 34 | 'git pull origin master', 35 | )); 36 | 37 | #### Catching Output From Commands 38 | 39 | You may catch the "live" output of your remote commands by passing a Closure into the `run` method: 40 | 41 | SSH::run($commands, function($line) 42 | { 43 | echo $line.PHP_EOL; 44 | }); 45 | 46 | ## Tasks 47 | 48 | 49 | If you need to define a group of commands that should always be run together, you may use the `define` method to define a `task`: 50 | 51 | SSH::into('staging')->define('deploy', array( 52 | 'cd /var/www', 53 | 'git pull origin master', 54 | 'php artisan migrate', 55 | )); 56 | 57 | Once the task has been defined, you may use the `task` method to run it: 58 | 59 | SSH::into('staging')->task('deploy', function($line) 60 | { 61 | echo $line.PHP_EOL; 62 | }); 63 | 64 | 65 | ## SFTP Uploads 66 | 67 | The `SSH` class also includes a simple way to upload files, or even strings, to the server using the `put` and `putString` methods: 68 | 69 | SSH::into('staging')->put($localFile, $remotePath); 70 | 71 | SSH::into('staging')->putString('Foo', $remotePath); 72 | 73 | 74 | ## Tailing Remote Logs 75 | 76 | Laravel includes a helpful command for tailing the `laravel.log` files on any of your remote connections. Simple use the `tail` Artisan command and specify the name of the remote connection you would like to tail: 77 | 78 | php artisan tail staging 79 | 80 | php artisan tail staging --path=/path/to/log.file --------------------------------------------------------------------------------