Yii Framework: Come customizzare gii per generare codice per la tua App

A partire dalla versione 1.1.2 , Yii Framework si è dotato di uno strumento basato sul Web generazione di codice chiamato Gii.

Essa sostituisce la precedente yiic strumento shell di generazione che girava su riga di comando.

In questa sezione, descriveremo come  estendere Gii per aumentare la nostra produttività di sviluppo.

Mentre i generatori di codice di default che vengono con Gii in grado di generare codice molto potenti, spesso si ha l’esigenza di personalizzarli o crearne di nuovi per soddisfare i nostri gusti e le esigenze.

Ad esempio, potremmo volere che il codice generato sia basato su nostri stili di codifica preferiti, o potremmo voler rendere il codice utile a supportare più lingue.

Tutto questo può essere fatto facilmente con Gii.

Gii può essere esteso in due modi: personalizzando i template di codice dei generatori di codice esistenti, oppure utilizzando la scrittura di nuovi generatori di codice.


Un generatore di codice viene memorizzato in una directory il cui nome viene trattato come il nome del generatore.

La directory di solito consiste il seguente contenuto:

model/                       La directory radice per il gen. model
   ModelCode.php             Il Model Code usato per generare il code
   ModelGenerator.php        Il Controller Generation 
   views/                    Contiene lo scripts view per il generator
     index.php              Lo script di default per la view
   templates/                Contiene il codice per sets del template
      default/               Il 'default' code template setta
         model.php           il code template per gernerare il model

PERCORSO DI RICERCA DEL GENERATOR

Gii cerca i generatori disponibili in una serie di directory specificata dalla proprietà GiiModule :: generatorPaths.

Quando è necessaria la personalizzazione, possiamo configurare questa struttura nella configurazione dell’applicazione come segue,

return array(
    'modules'=>array(
        'gii'=>array(
            'class'=>'system.gii.GiiModule',
            'generatorPaths'=>array(
                'common.gii',   // a path alias
            ),
        ),
    ),
);

La configurazione di cui sopra indica Gii a cercare i generatori sotto la directory alias come common.gii, in aggiunta alle posizioni predefinite system.gii.generators e application.gii.

E ‘possibile avere due generatori con lo stesso nome, ma sotto diversi percorsi di ricerca.

In questo caso, il generatore nel percorso specificato in precedenza in GiiModule :: generatorPaths avrà la precedenza.

PERSONALIZZARE IL TEMPLATE CODE

Questo è il più semplice e il modo più comune di estendere Gii.

Usiamo un esempio per spiegare come personalizzare modelli di codice.

Supponiamo che vogliamo personalizzare il codice generato dal generatore model.

Si crea una directory chiamata protected/ gii / model / templates / compact.

Qui model significa che stiamo andando a sovrascrivere il generatore model predefinito.

E templates / compact aggiungeremo un nuovo set di template nome in codice compact.

Abbiamo poi modifichiamo la nostra configurazione dell’applicazione per aggiungere application.gii a GiiModule :: generatorPaths, come illustrato nel precedente comma.

Ora aprite la pagina di generatore di codice del model, fare clic sul campo codice del modello.

Dovremmo vedere un elenco a discesa che contiene la nostra directory template appena creato compatta.

Tuttavia, se si sceglie questo modello per generare il codice, vedremo un errore.

Questo perché dobbiamo ancora mettere qualsiasi file vero e proprio modello di codice in questo nuovo set di modelli compatti.

Copiare il  file framework / GII / generator/ model / templates / default / model.php a protected / gii / modello / templates / compact.

Se cerchiamo la generazione di nuovo con il modello compatto, dovremmo riuscire.

Tuttavia, il codice generato non è diverso da quello generato dal set modello predefinito.

E ‘tempo per noi di fare il vero lavoro di personalizzazione.
Aprire il file protected/ gii / model / templates / compact / model.php di modificarla.
Ricordate che questo file verrà utilizzato come da copia vista, il che significa che può contenere espressioni PHP e dichiarazioni.
Andiamo a modificare il template in modo che il metodo attributeLabels () nel codice generato utilizza Yii :: t () per tradurre le etichette degli attributi:
public function attributeLabels()
{
    return array(
<?php foreach($labels as $name=>$label): ?>
            <?php echo "'$name' => Yii::t('application', '$label'),\n"; ?>
<?php endforeach; ?>
    );
}
In ogni modello di codice, possiamo accedere ad alcune variabili predefinite, come ad esempio $ label nell’esempio precedente.
Queste variabili sono forniti dal generatore di codice corrispondente.
Diversi generatori di codice possono fornire diverse serie di variabili nei loro modelli di codice.
Si prega di leggere la descrizione dei modelli di codice predefinito con attenzione.
CREAZIONE DI NUOVI GENERATORI DI CODICE
In questa sotto-sezione, mostriamo come creare un nuovo generatore che può generare una nuova classe di widget.
Si crea una directory chiamata protected/ gii / widget.
Sotto questa directory, creeremo i seguenti file:
WidgetGenerator.php: contiene la classe controller WidgetGenerator.
Questo è il punto di ingresso del generatore gadget.
WidgetCode.php: contiene la classe del modello WidgetCode.
Questa classe ha la logica principale per la generazione del codice.
views / index.php: lo script di vista che mostra la maschera di immissione generatore di codice.
templates / default / widget.php: il modello di codice predefinito per la generazione di un file di classe di widget.

CREAZIONE DI WidgetGenerator.php

Il file WidgetGenerator.php è estremamente semplice.

Esso contiene solo il codice seguente:

class WidgetGenerator extends CCodeGenerator
{
    public $codeModel='application.gii.widget.WidgetCode';
}
Nel codice di cui sopra, si precisa che il generatore utilizzerà la classe del model la cui alias percorso è application.gii.widget.WidgetCode.
La classe WidgetGenerator estende da CCodeGenerator che implementa un sacco di funzionalità, comprese le azioni del controller necessarie per coordinare il processo di generazione del codice.
Creazione WidgetCode.php Il file WidgetCode.php contiene la classe modello WidgetCode che ha la logica principale per generare una classe Widget base all’input dell’utente.
In questo esempio, supponiamo che l’unico input che vogliamo da parte dell’utente è il nome della classe del widget.

Il nostro WidgetCode è simile al seguente:

class WidgetCode extends CCodeModel
{
    public $className;

    public function rules()
    {
        return array_merge(parent::rules(), array(
            array('className', 'required'),
            array('className', 'match', 'pattern'=>'/^\w+$/'),
        ));
    }

    public function attributeLabels()
    {
        return array_merge(parent::attributeLabels(), array(
            'className'=>'Widget Class Name',
        ));
    }

    public function prepare()
    {
        $path=Yii::getPathOfAlias('application.components.' . $this->className) . '.php';
        $code=$this->render($this->templatepath.'/widget.php');

        $this->files[]=new CCodeFile($path, $code);
    }
}
La classe WidgetCode estende da CCodeModel.
Come una normale classe di modello, in questa categoria possiamo dichiarare rules() e attributeLabels () per la validazione dell’input dell’utente e fornire etichette attributi, rispettivamente.
Si noti che, poiché la classe base CCodeModel  definisce già alcune regole e attributi etichette, dobbiamo unirli con le nuove regole ed etichette qui.
Il metodo che prepare() prepara il codice da generare.
Il suo compito principale è quello di preparare un elenco di oggetti CCodeFile, ciascuno dei quali rappresenta un file di codice generato.
Nel nostro esempio, abbiamo solo bisogno di creare un oggetto CCodeFile che rappresenta il file di classe widget generato.
La nuova classe widget verrà creata nella directory protected/ components.
Chiamiamo il metodo CCodeFile :: render per generare il codice vero e proprio.
Questo metodo comprende il modello di codice come script PHP e restituisce il contenuto dato mentre il codice generato.

Creating views/index.php

Avendo il controller (WidgetGenerator) e il modello (WidgetCode), è il momento per noi di creare la vista views / index.php.
<h1>Widget Generator</h1>

<?php $form=$this->beginWidget('CCodeForm', array('model'=>$model)); ?>

    <div class="row">
        <?php echo $form->labelEx($model,'className'); ?>
        <?php echo $form->textField($model,'className',array('size'=>65)); ?>
        <div class="tooltip">
            Widget class name must only contain word characters.
        </div>
        <?php echo $form->error($model,'className'); ?>
    </div>

<?php $this->endWidget(); ?>
In quanto sopra, abbiamo principalmente visualizzare un form utilizzando il widget di CCodeForm.
In questa forma, visualizziamo il campo per raccogliere l’input per l’attributo className in WidgetCode.
Quando si crea la forma, possiamo sfruttare due belle caratteristiche fornite dal widget CCodeForm.
Uno è su descrizioni dell’input. L’altro riguarda ingressi appiccicose.
Se avete provato qualsiasi generatore di codice predefinito, si noterà che l’impostazione di messa a fuoco in un campo di input, un bel tooltip apparirà accanto al campo.
Questo può essere facilmente ottenuto qui scrivendo accanto al campo di inserimento di un div la cui classe CSS è tooltip.
Per alcuni campi di input, potremmo voler ricordare i loro ultimi valori validi in modo che l’utente può risparmiare la fatica di rientrare ogni volta che usano il generatore per generare il codice.
Un esempio è il campo di input raccogliere il controllore classe base del generatore regolatore nome predefinito.
Questi campi appiccicose sono inizialmente visualizzati come evidenziato testo statico. Se si clicca su di loro, si trasformano in campi di input per prendere input dell’utente.
Per dichiarare un campo di input per essere appiccicoso, abbiamo bisogno di fare due cose. In primo luogo, abbiamo bisogno di dichiarare una regola di convalida appiccicoso per l’attributo modello corrispondente.
Ad esempio, il generatore controller di default ha la seguente regola di dichiarare che gli attributi baseclass e azioni sono appiccicosi
public function rules()
{
    return array_merge(parent::rules(), array(
        ......
        array('baseClass, actions', 'sticky'),
    ));
}

In secondo luogo, abbiamo bisogno di aggiungere una classe CSS denominata sticky al div container del campo di input in vista, come la seguente:

<div class="row sticky">
    ...input field here...
</div>

Infine, creiamo il codice template templates / default / widget.php.

Come abbiamo descritto in precedenza, questo è usato come da copione vista che può contenere espressioni PHP e dichiarazioni.

In un modello di codice, possiamo sempre accedere al $this variabile che si riferisce all’oggetto modello di codice.

Nel nostro esempio, $this fa riferimento all’oggetto WidgetModel.

Possiamo così ottenere il nome della classe widget inserite dall’utente tramite $ this-> className.

<?php echo '<?php'; ?>

class <?php echo $this->className; ?> extends CWidget
{
    public function run()
    {

    }
}

Questo conclude la creazione di un nuovo generatore di codice.

Siamo in grado di accedere immediatamente a questo generatore di codice tramite l’URL http://hostname/path/to/index.php?r=gii/widget.

Creating templates/default/widget.php

Infine, creiamo il template templates codice / default / widget.php. Come abbiamo descritto in precedenza, questo è usato come da copione vista che può contenere espressioni PHP e dichiarazioni. In un modello di codice, possiamo sempre accedere al $ questa variabile che si riferisce all’oggetto modello di codice. Nel nostro esempio, $ this fa riferimento all’oggetto WidgetModel. Possiamo così ottenere il nome del widget classe inserite dall’utente tramite $ this-> className.
<?php echo '<?php'; ?>

class <?php echo $this->className; ?> extends CWidget
{
    public function run()
    {

    }
}

Questo conclude la creazione di un nuovo generatore di codice. Siamo in grado di accedere immediatamente a questo generatore di codice tramite l’URL http://hostname/path/to/index.php?r=gii/widget.

Be Sociable, Share!

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *