Initial commit: apps.supersam24.ru
This commit is contained in:
root committed
commit
e955e1da36
6566 files changed
+1271095
No files matched your search
+351
@@ -0,0 +1,351 @@
|
||||
Etendre Bake
|
||||
############
|
||||
|
||||
Bake dispose d'une architecture extensible qui permet à votre application ou
|
||||
à vos plugins de modifier ou ajouter la fonctionnalité de base. Bake utilise une
|
||||
classe de vue dédiée qui n'utilise pas la syntaxe PHP standard.
|
||||
|
||||
Events de Bake
|
||||
==============
|
||||
|
||||
Comme une classe de vue, ``BakeView`` envoie les mêmes events que toute autre
|
||||
classe de vue, ainsi qu'un event initialize supplémentaire. Cependant,
|
||||
alors que les classes de vue standard utilisent le préfixe d'event
|
||||
"View.", ``BakeView`` utilise le préfixe d'event "Bake.".
|
||||
|
||||
L'event initialize peut être utilisé pour faire des changements qui
|
||||
s'appliquent à toutes les sorties fabriquées avec bake, par exemple pour ajouter
|
||||
un autre helper à la classe de vue bake, cet event peut être utilisé::
|
||||
|
||||
<?php
|
||||
// config/bootstrap_cli.php
|
||||
|
||||
use Cake\Event\Event;
|
||||
use Cake\Event\EventManager;
|
||||
|
||||
EventManager::instance()->on('Bake.initialize', function (Event $event) {
|
||||
$view = $event->getSubject();
|
||||
|
||||
// Dans mes templates de bake, permet l'utilisation du helper MySpecial
|
||||
$view->loadHelper('MySpecial', ['some' => 'config']);
|
||||
|
||||
// Et ajoute une variable $author pour qu'elle soit toujours disponible
|
||||
$view->set('author', 'Andy');
|
||||
|
||||
});
|
||||
|
||||
Si vous souhaitez modifier bake à partir d'un autre plugin, mettre les events
|
||||
de bake de votre plugin dans le fichier ``config/bootstrap.php`` du plugin est
|
||||
une bonne idée.
|
||||
|
||||
Les events de bake peuvent être pratiques pour faire de petits changements dans
|
||||
les templates existants. Par exemple, pour changer les noms de variables
|
||||
utilisés lors de la création avec bake de fichiers de controller/template, on
|
||||
pourra utiliser une fonction qui écoute ``Bake.beforeRender`` pour modifier les
|
||||
variables utilisées dans les templates de bake::
|
||||
|
||||
<?php
|
||||
// config/bootstrap_cli.php
|
||||
|
||||
use Cake\Event\Event;
|
||||
use Cake\Event\EventManager;
|
||||
|
||||
EventManager::instance()->on('Bake.beforeRender', function (Event $event) {
|
||||
$view = $event->getSubject();
|
||||
|
||||
// Utilise $rows pour les principales variables de données dans les indexes
|
||||
if ($view->get('pluralName')) {
|
||||
$view->set('pluralName', 'rows');
|
||||
}
|
||||
if ($view->get('pluralVar')) {
|
||||
$view->set('pluralVar', 'rows');
|
||||
}
|
||||
|
||||
// Utilise $theOne pour les principales variable de données dans les view/edit
|
||||
if ($view->get('singularName')) {
|
||||
$view->set('singularName', 'theOne');
|
||||
}
|
||||
if ($view->get('singularVar')) {
|
||||
$view->set('singularVar', 'theOne');
|
||||
}
|
||||
|
||||
});
|
||||
|
||||
Vous pouvez aussi scoper les events ``Bake.beforeRender`` et
|
||||
``Bake.afterRender`` dans un fichier généré spécifique. Par exemple, si vous
|
||||
souhaitez ajouter des actions spécifiques à votre UsersController quand vous le
|
||||
générez à partir d'un fichier **Controller/controller.ctp**, vous pouvez
|
||||
utiliser l'event suivant::
|
||||
|
||||
<?php
|
||||
// config/bootstrap_cli.php
|
||||
|
||||
use Cake\Event\Event;
|
||||
use Cake\Event\EventManager;
|
||||
use Cake\Utility\Hash;
|
||||
|
||||
EventManager::instance()->on(
|
||||
'Bake.beforeRender.Controller.controller',
|
||||
function (Event $event) {
|
||||
$view = $event->subject;
|
||||
if ($view->viewVars['name'] == 'Users') {
|
||||
// ajouter les actions login et logout au controller Users
|
||||
$view->viewVars['actions'] = [
|
||||
'login',
|
||||
'logout',
|
||||
'index',
|
||||
'view',
|
||||
'add',
|
||||
'edit',
|
||||
'delete'
|
||||
];
|
||||
}
|
||||
}
|
||||
);
|
||||
|
||||
En scopant les écouteurs d'event vers des templates de bake spécifiques, vous
|
||||
pouvez simplifier votre logique d'event liée à bake et fournir des callbacks
|
||||
qui sont plus faciles à tester.
|
||||
|
||||
Syntaxe de Template de Bake
|
||||
===========================
|
||||
|
||||
Les fichiers de template de Bake utilisent les balises erb-style (``<% %>``)
|
||||
pour indiquer la logique des templates, et traitent le reste, y compris les
|
||||
balises php, comme du texte.
|
||||
|
||||
.. note::
|
||||
|
||||
Les fichiers de template de Bake n'utilisent pas, et sont insensibles aux
|
||||
``asp_tags`` de la configuration de php ini.
|
||||
|
||||
``BakeView`` intègre les balises suivantes:
|
||||
|
||||
* ``<%`` Une balise php ouverte de template de Bake
|
||||
* ``%>`` Une balise php fermante de template de Bake
|
||||
* ``<%=`` Une balise php de short-echo de template de Bake
|
||||
* ``<%-`` Une balise php ouverte de template de Bake, enlevant tout espace
|
||||
en tête avant la balise
|
||||
* ``-%>`` Une balise php fermante de template de Bake, enlevant les espaces
|
||||
à a fin après la balise
|
||||
|
||||
Une façon de voir/comprendre la façon dont les templates de Bake fonctionne,
|
||||
spécialement quand on essaie de modifier les fichiers de template de bake, est
|
||||
de créer avec bake une classe et de comparer le template utilisé avec le
|
||||
template déjà présent dans le dossier **tmp/bake** de votre application.
|
||||
|
||||
Ainsi, par exemple, pour créer avec bake un shell comme ceci:
|
||||
|
||||
.. code-block:: bash
|
||||
|
||||
bin/cake bake shell Foo
|
||||
|
||||
Le template utilisé
|
||||
(**vendor/cakephp/cakephp/src/Template/Bake/Shell/shell.ctp**)
|
||||
ressemble à ceci::
|
||||
|
||||
<?php
|
||||
namespace <%= $namespace %>\Shell;
|
||||
|
||||
use Cake\Console\Shell;
|
||||
|
||||
/**
|
||||
* <%= $name %> shell command.
|
||||
*/
|
||||
class <%= $name %>Shell extends Shell
|
||||
{
|
||||
|
||||
/**
|
||||
* main() method.
|
||||
*
|
||||
* @return bool|int Success or error code.
|
||||
*/
|
||||
public function main()
|
||||
{
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
Le fichier template déjà présent (pre-processed)
|
||||
(**tmp/bake/Bake-Shell-shell-ctp.php**), qui est le fichier réellement
|
||||
rendu, ressemble à ceci::
|
||||
|
||||
<CakePHPBakeOpenTagphp
|
||||
namespace <?= $namespace ?>\Shell;
|
||||
|
||||
use Cake\Console\Shell;
|
||||
|
||||
/**
|
||||
* <?= $name ?> shell command.
|
||||
*/
|
||||
class <?= $name ?>Shell extends Shell
|
||||
{
|
||||
|
||||
/**
|
||||
* main() method.
|
||||
*
|
||||
* @return bool|int Success or error code.
|
||||
*/
|
||||
public function main()
|
||||
{
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
Et la classe résultante construite avec bake (**src/Shell/FooShell.php**)
|
||||
ressemble à ceci::
|
||||
|
||||
<?php
|
||||
namespace App\Shell;
|
||||
|
||||
use Cake\Console\Shell;
|
||||
|
||||
/**
|
||||
* Foo shell command.
|
||||
*/
|
||||
class FooShell extends Shell
|
||||
{
|
||||
|
||||
/**
|
||||
* main() method.
|
||||
*
|
||||
* @return bool|int Success or error code.
|
||||
*/
|
||||
public function main()
|
||||
{
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
.. _creating-a-bake-theme:
|
||||
|
||||
Créer un theme de bake
|
||||
======================
|
||||
|
||||
Si vous souhaitez modifier la sortie du HTML produit par la commande "bake",
|
||||
vous pouvez créer votre propre 'template' de bake qui vous permet de remplacer
|
||||
certaine ou toute partie des templates que bake utilise. Pour créer un nouveau
|
||||
template de bake, faîtes ce qui suit:
|
||||
|
||||
#. Créez un nouveau plugin avec Bake. Le nom du plugin est le nom du 'theme' de
|
||||
Bake
|
||||
#. Créez un nouveau répertoire **plugins/[name]/src/Template/Bake/Template/**.
|
||||
#. Copiez tout template que vous souhaitez changer à partir de
|
||||
**vendor/cakephp/bake/src/Template/Bake/Template** vers les
|
||||
fichiers correspondants dans votre plugin.
|
||||
#. Quand vous lancez bake, utilisez l'option ``--theme`` pour spécifier le
|
||||
theme de bake que vous souhaitez utiliser. Pour éviter d'avoir à spécifier
|
||||
cette option dans chaque appel, vous pouvez aussi définir votre thème
|
||||
personnalisé à utiliser comme thème par défaut::
|
||||
|
||||
<?php
|
||||
// in config/bootstrap.php or config/bootstrap_cli.php
|
||||
Configure::write('Bake.theme', 'MyTheme');
|
||||
|
||||
Personnaliser les Templates de Bake
|
||||
===================================
|
||||
|
||||
Si vous souhaitez modifier la sortie par défaut produite par la commande "bake",
|
||||
vous pouvez créer vos propres templates de bake dans votre application. Cette
|
||||
façon n'utilise pas l'option ``--theme`` dans la ligne de commande lors de
|
||||
l'exécution de bake. La meilleure façon de faire est de faire ce qui suit:
|
||||
|
||||
#. Créer un nouveau répertoire **/src/Template/Bake/**.
|
||||
#. Copier tout template que vous souhaitez surcharger de
|
||||
**vendor/cakephp/bake/src/Template/Bake/** vers les fichiers correspondants
|
||||
dans votre application.
|
||||
|
||||
Créer de Nouvelles Options de Commande pour Bake
|
||||
================================================
|
||||
|
||||
Il est possible d'ajouter de nouvelles options de commandes de bake, ou de
|
||||
surcharger celles fournies par CakePHP en créant des tâches dans votre
|
||||
application ou dans vos plugins. En étendant ``Cake\Shell\Task\BakeTask``, bake
|
||||
va trouver votre nouvelle tâche et l'inclure comme faisant partie de bake.
|
||||
|
||||
En exemple, nous allons faire une tâche qui créé une classe arbitraire foo.
|
||||
D'abord créez le fichier de tâche **src/Shell/Task/FooTask.php**. Nous
|
||||
étendrons le ``SimpleBakeTask`` pour l'instant puisque notre tâche shell sera
|
||||
simple. ``SimpleBakeTask`` est abstraite et nous impose de définir 3 méthodes
|
||||
qui disent à bake comment la tâche est appelée, l'endroit où devront se trouver
|
||||
les fichiers qu'il va générer, et le template à utiliser. Notre fichier
|
||||
FooTask.php devra ressembler à ceci::
|
||||
|
||||
<?php
|
||||
namespace App\Shell\Task;
|
||||
|
||||
use Cake\Shell\Task\SimpleBakeTask;
|
||||
|
||||
class FooTask extends SimpleBakeTask
|
||||
{
|
||||
public $pathFragment = 'Foo/';
|
||||
|
||||
public function name()
|
||||
{
|
||||
return 'foo';
|
||||
}
|
||||
|
||||
public function fileName($name)
|
||||
{
|
||||
return $name . 'Foo.php';
|
||||
}
|
||||
|
||||
public function template()
|
||||
{
|
||||
return 'foo';
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
Une fois que le fichier a été créé, nous devons créer un template que bake peut
|
||||
utiliser pour la génération de code. Créez
|
||||
**src/Template/Bake/foo.ctp**. Dans ce fichier, nous
|
||||
ajouterons le contenu suivant::
|
||||
|
||||
<?php
|
||||
namespace <%= $namespace %>\Foo;
|
||||
|
||||
/**
|
||||
* <%= $name %> foo
|
||||
*/
|
||||
class <%= $name %>Foo
|
||||
{
|
||||
// Add code.
|
||||
}
|
||||
|
||||
Vous devriez maintenant voir votre nouvelle tâche dans l'affichage de
|
||||
``bin/cake bake``. Vous pouvez lancer votre nouvelle tâche en exécutant
|
||||
``bin/cake bake foo Example``.
|
||||
Cela va générer une nouvelle classe ``ExampleFoo`` dans
|
||||
**src/Foo/ExampleFoo.php** que votre application va
|
||||
pouvoir utiliser.
|
||||
|
||||
Si vous souhaitez que votre appel à ``bake`` crée également un fichier de test
|
||||
pour la classe ``ExampleFoo``, vous devrez surcharger la méthode ``bakeTest()``
|
||||
dans la classe ``FooTask`` pour y définir le suffixe et le namespace de la
|
||||
classe de votre nom de commande personnalisée::
|
||||
|
||||
public function bakeTest($className)
|
||||
{
|
||||
if (!isset($this->Test->classSuffixes[$this->name()])) {
|
||||
$this->Test->classSuffixes[$this->name()] = 'Foo';
|
||||
}
|
||||
|
||||
$name = ucfirst($this->name());
|
||||
if (!isset($this->Test->classTypes[$name])) {
|
||||
$this->Test->classTypes[$name] = 'Foo';
|
||||
}
|
||||
|
||||
return parent::bakeTest($className);
|
||||
}
|
||||
|
||||
* Le **suffixe de classe** sera ajouté après le nom passé à ``bake``. Dans le
|
||||
cadre de l'exemple ci-dessus, cela créerait un fichier ``ExampleFooTest.php``.
|
||||
* Le **type de classe** sera le sous-namespace utilisé pour atteindre votre
|
||||
fichier (relatif à l'application ou au plugin dans lequel vous faites le
|
||||
``bake``). Dans le cadre de l'exemple ci-dessus, cela créerait le test avec le
|
||||
namespace ``App\Test\TestCase\Foo``.
|
||||
|
||||
.. meta::
|
||||
:title lang=fr: Etendre Bake
|
||||
:keywords lang=fr: interface ligne de commande,development,bake view, bake template syntax,erb tags,asp tags,percent tags
|
||||
Reference in new issue
Block a user