deon/khosb
Archived
1
0
Fork 0
Code Issues 6 Pull Requests Packages Projects Releases Wiki Activity

Added Kohana v3.0.8

Browse Source
This commit is contained in:
Deon George
2010-08-21 14:43:03 +10:00
parent 27aee719b0
commit 64bdbdc981
558 changed files with 58712 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

316
includes/kohana/modules/userguide/guide/nl/about.conventions.md Normal file
View File

@@ -0,0 +1,316 @@
# Conventies
Het is aanbevolen om Kohana's [manier van coderen](http://dev.kohanaframework.org/wiki/kohana2/CodingStyle) te gebruiken. Dit gebruikt de [BSD/Allman stijl](http://en.wikipedia.org/wiki/Indent_style#BSD.2FAllman_style) van haakjes, en nog andere dingen.
## Class namen en locaties van bestanden {#classes}
Class namen in Kohana volgen een strikte conventie om [autoloading](using.autoloading) gemakkelijker te maken. Class namen zouden met een hoofdletter moeten beginnen en een underscore gebruiken om woorden af te scheiden van elkaar. Underscores zijn belangrijk omdat ze de locatie van het bestand weerspiegelen in de folderstructuur.
De volgende conventies worden gebruikt:
1. CamelCased class namen worden niet gebruikt, alleen maar als het onnodig is om een nieuw folderniveau aan te maken.
2. Alle class bestandsnamen en foldernamen zijn met kleine letters geschreven.
3. Alle classes zitten in de `classes` folder. Dit kan op ieder niveau in het [cascading filesystem](about.filesystem).
[!!] In tegenstelling tot Kohana v2.x, is er geen afscheiding tussen "controllers", "models", "libraries" en "helpers". Alle classes worden in de folder "classes/" geplaatst, of het nu static "helpers" of object "libraries" zijn. Ieder design pattern is mogelijk voor het maken van classes: static, singleton, adapter, etc.
## Voorbeelden
Onthoud dat in een class, een underscore een folder betekent. Bekijk de volgende voorbeelden:
Class Naam | Locatie File
----------------------|-------------------------------
Controller_Template | classes/controller/template.php
Model_User | classes/model/user.php
Database | classes/database.php
Database_Query | classes/database/query.php
Form | classes/form.php
## Coding Standaarden {#coding_standards}
Om zeer consistente broncode te schrijven, vragen we dat iedereen de coding standaarden zo nauw mogelijk probeert na te volgen.
### Gekrulde Haakjes (Brackets)
Gebruik aub [BSD/Allman Stijl](http://en.wikipedia.org/wiki/Indent_style#BSD.2FAllman_style) van bracketing.
### Naam conventies
Kohana gebruikt underscore namen, geen camelCase.
#### Classes
<?php
// Controller class, gebruikt Controller_ voorvoegsel
class Controller_Apple extends Controller {
// Model class, gebruikt Model_ voorvoegsel
class Model_Cheese extends Model {
// Regular class
class peanut {
Wanneer je een instantie aanmaakt van een class, gebruik dan haakjes als je niets meegeeft aan de constructor:
<?php
// Correct:
$db = new Database;
// Niet correct:
$db = new Database();
#### Functies en Methoden
Functies moeten altijd lowercase zijn. Gebruik underscores om woorden van elkaar te scheiden:
<?php
function drink_beverage($beverage)
{
#### Variabelen
Alle variabelen moeten lowercase zijn, gebruik underscores, geen cameCase:
<?php
// Correct:
$foo = 'bar';
$long_example = 'Gebruik underscores';
// Niet correct:
$weWillenDitDusNiet = 'verstaan?';
### Inspringen
Je moet tabs gebruiken om je code te laten inspringen. In geen enkel geval gebruik je spaties als tabs.
Verticale afstanden (voor multi-line) wordt gedaan met spaties. Tabs zijn niet goed voor verticale uitlijning omdat verschillende mensen andere tabbreedtes hebben.
<?php
$text = 'this is a long text block that is wrapped. Normally, we aim for '
. 'wrapping at 80 chars. Vertical alignment is very important for '
. 'code readability. Remember that all indentation is done with tabs,'
. 'but vertical alignment should be completed with spaces, after '
. 'indenting with tabs.';
### String concatenatie
Plaats geen spaties rond de concatenatie operator:
<?php
// Correct:
$str = 'one'.$var.'two';
// Niet correct:
$str = 'one'. $var .'two';
$str = 'one' . $var . 'two';
### Enkelvoudige lijn Statements
Enkelvoudige lijn IF statements mogen enkel maar gebruikt worden wanneer het de normale executie stop zoals `return` of `continue`:
<?php
// Aanvaardbaar:
if ($foo == $bar)
return $foo;
if ($foo == $bar)
continue;
if ($foo == $bar)
break;
if ($foo == $bar)
throw new Exception('You screwed up!');
// Niet aanvaardbaar:
if ($baz == $bun)
$baz = $bar + 2;
### Vergelijkingsoperatoren
Gebruik OR en AND in je statements:
<?php
// Correct:
if (($foo AND $bar) OR ($b AND $c))
// Niet correct:
if (($foo && $bar) || ($b && $c))
Bij if/else blokken, gebruik `elseif`, niet `else if`:
<?php
// Correct:
elseif ($bar)
// Niet correct:
else if($bar)
### Switch structuren
Iedere case, break en default moeten op een aparte lijn staan. Het blok binnenin een case of default moet met één tab ingesprongen worden.
<?php
switch ($var)
{
case 'bar':
case 'foo':
echo 'hello';
break;
case 1:
echo 'one';
break;
default:
echo 'bye';
break;
}
### Haakjes (Parentheses)
Er moet een spatie achter het statements naam staan, gevolgd door een haakje. Het ! (bang) karakter moet een spatie langs beide kanten hebben om de zichtbaarheid te maximaliseren. Je mag geen spatie hebben na het eerste haakje of voor de laatste haakje, enkel in het geval van een bang of type casting.
<?php
// Correct:
if ($foo == $bar)
if ( ! $foo)
// Niet correct:
if($foo == $bar)
if(!$foo)
if ((int) $foo)
if ( $foo == $bar )
if (! $foo)
### Ternaries
Alle ternaire operaties moeten volgens het standaard formaat. Gebruik enkel haakjes rond uitdrukkingen, niet rond enkel maar variabelen.
$foo = ($bar == $foo) ? $foo : $bar;
$foo = $bar ? $foo : $bar;
Alle vergelijkingen en bewerkingen moeten binnenin de haakjes gebeuren:
$foo = ($bar > 5) ? ($bar + $foo) : strlen($bar);
Bij het scheiden van complexe ternaries (ternaries waarbij het eerste deel meer dan ~80 karakters bevat) in meerdere regels, moet je spaties gebruiken om operators op te lijnen, deze plaats je in het begin van de opeenvolgende lijnen:
$foo = ($bar == $foo)
? $foo
: $bar;
### Type Casting
Type casting wordt gedaan met spatie langs elke kant van de cast:
// Correct:
$foo = (string) $bar;
if ( (string) $bar)
// Niet correct:
$foo = (string)$bar;
Indien mogelijk, gebruik dan in plaats van type casting ternaire operators:
// Correct:
$foo = (bool) $bar;
// Niet correct:
$foo = ($bar == TRUE) ? TRUE : FALSE;
Bij het casten van een integer of een boolean gebruik je het korte formaat:
// Correct:
$foo = (int) $bar;
$foo = (bool) $bar;
// Incorrect:
$foo = (integer) $bar;
$foo = (boolean) $bar;
### Constanten
Gebruik altijd hoofdletters voor constanten:
// Correct:
define('MY_CONSTANT', 'my_value');
$a = TRUE;
$b = NULL;
// Niet correct:
define('MyConstant', 'my_value');
$a = True;
$b = null;
Plaats constant vergelijkingen aan het einde van de tests:
// Correct:
if ($foo !== FALSE)
// Niet correct:
if (FALSE !== $foo)
Dit is een enigszins een controversiële keuze, dus is een uitleg op zijn plaats. Als we het vorige voorbeeld in gewoon taal schrijven, zou het goede voorbeeld als volgt te lezen zijn:
if variable $foo is not exactly FALSE
En het foute voorbeeld zou als volgt te lezen zijn:
if FALSE is not exactly variable $foo
En aangezien we van links naar rechts lezen, is het logischer om de constante als laatste te plaatsen.
### Commentaren
#### Commentaren op één lijn
Gebruik //, best boven de lijn met je code waar je de commentaar voor wilt schrijven. Laat een spatie tussen en start met een hoofdletter. Gebruik nooit #
// Correct
//Niet correct
// niet correct
# Niet correct
### Reguliere expressies
Bij het coderen van reguliere expressies gebruik je beter PCRE in plaats van POSIX. PCRE zou krachtiger en sneller zijn.
// Correct:
if (preg_match('/abc/i'), $str)
// Incorrect:
if (eregi('abc', $str))
Gebruik enkele aanhalingstekens rond uw reguliere expressies in plaats van dubbele aanhalingstekens. Enkele aanhalingstekens worden gemakkelijker door hun eenvoud in gebruik. In tegenstelling tot de dubbele aanhalingstekens ondersteunen ze niet variabele interpolatie, noch geïntegreerde backslash sequenties zoals \n of \t, enz.
// Correct:
preg_match('/abc/', $str);
// Incorrect:
preg_match("/abc/", $str);
Bij het uitvoeren van een reguliere expressie zoeken en vervangen, gebruik dan de $n notatie voor terugverwijzingen. Dit verdient de voorkeur boven \\n.
// Correct:
preg_replace('/(\d+) dollar/', '$1 euro', $str);
// Incorrect:
preg_replace('/(\d+) dollar/', '\\1 euro', $str);
Tot slot, let wel dat het $-teken voor de eindpositie van de lijn aan te geven toelaat om een newline-karakter als volgend karakter te gebruiken. Gebruik de D modifier om dit te verhelpen indien nodig. [Meer informatie](http://blog.php-security.org/archives/76-Holes-in-most-preg_match-filters.html).
$str = "email@example.com\n";
preg_match('/^.+@.+$/', $str); // TRUE
preg_match('/^.+@.+$/D', $str); // FALSE

76
includes/kohana/modules/userguide/guide/nl/about.filesystem.md Normal file
View File

@@ -0,0 +1,76 @@
# Cascading Filesystem
Het Kohana filesysteem heeft hiërarchie van folder-structuur. Wanneer een bestand wordt ingeladen door [Kohana::find_file], dan wordt het gezocht in de volgend volgorde:
Application pad
: Gedefineerd als `APPPATH` in `index.php`. De standaard value hiervan is `application`.
Module paden
: Dit is ingesteld als een associatieve array met behulp van [Kohana::modules] in `APPPATH/bootstrap.php`. Elk van de waarden van de array zal worden gezocht in de volgorde waarin de modules worden toegevoegd.
System pad
: Gedefineerd als `SYSPATH` in `index.php`. De standaard value hiervan is `system`. Alle belangrijkste of "core"-bestanden en classes zijn hier gedefinieerd.
Bestanden die zich hoger bevinden in de volgorde van het inladen van bestanden hebben voorrang op bestanden met dezelfde naam die zich lager bevinden in de volgorde van inladen, dit maakt het mogelijk om ieder bestand te overloaden door een bestand met dezelfde naam in een "hogere" folder te plaatsen:
![Cascading Filesystem Infographic](img/cascading_filesystem.png)
Als je een view bestand hebt met de naam `welcome.php` in de `APPPATH/views` en `SYSPATH/views` folders, dan zal hetgeen uit application worden gereturned als `welcome.php` wordt ingeladen omdat het "hoger" staat in de folderstructuur.
## Types bestanden
De top level folders van de application, module en systeem paden hebben volgende standaard folders:
classes/
: Alle classes dat je wilt [automatisch inladen](using.autoloading) moeten zich hier
bevinden. Dit houdt in controllers, models, en alle andere classes. Alle classes moeten
de [class naam conventies](about.conventions#classes) volgen.
config/
: Configuratie bestanden geven een associatieve array van opties terug die je kunt
inladen via [Kohana::config]. Zie [gebruik van configuratie](using.configuration) voor
meer informatie.
i18n/
: Vertalingsbestanden geven een associatieve array van strings terug. Vertalen wordt
gedaan door de `__()` methode te gebruiken. Om "Hello, world!" te vertalen in het
Spaans zou je de methode `__('Hello, world!')` oproepen met [I18n::$lang] ingesteld op "es-es".
Zie [gebruik van vertaling](using.translation) voor meer informatie.
messages/
: Berichtenbestanden geven een associatieve array van strings terug die ingeladen kunnen
worden via [Kohana::message]. Messages en i18n bestanden verschillen erin dat messages
niet worden vertaald, maar altijd geschreven worden in de standaard taal en verwezen worden
via een enkelvoudige key. Zie [gebruik van messages](using.messages) voor meer informatie.
views/
: Views zijn plain PHP files die worden gebruikt om HTML of een ander formaat te genereren. Het view bestand wordt
ingeladen in in een [View] object en toegewezen variabelen, die het dan zal omzetten naar een HTML fractie. Het is mogelijk om meerder views in elkaar te gebruiken.
Zie [gebruik van views](usings.views) voor meer informatie.
## Vinden van betanden
Het pad naar eender welk bestand in de folderstructuur kan worden gevonden door het gebruik van [Kohana::find_file]:
// Vind het volledige pad naar "classes/cookie.php"
$path = Kohana::find_file('classes', 'cookie');
// Vind het volledige pad naar "views/user/login.php"
$path = Kohana::find_file('views', 'user/login');
# Vendor Extensions
Extensies die niet specifiek zijn aan Kohana noemen we "vendor" extensions.
Bijvoorbeeld, als je [DOMPDF](http://code.google.com/p/dompdf) wilt gebruiken,
dan moet je het kopiëren naar `application/vendor/dompdf` en de DOMPDF
autoloading class inladen:
require Kohana::find_file('vendor', 'dompdf/dompdf/dompdf_config.inc');
Nu kan je DOMPDF gebruiken zonder inladen van andere bestanden:
$pdf = new DOMPDF;
[!!] Indien je views wilt omzetten in PDFs via DOMPDF, probeer dan de
[PDFView](http://github.com/shadowhand/pdfview) module.

73
includes/kohana/modules/userguide/guide/nl/about.flow.md Normal file
View File

@@ -0,0 +1,73 @@
# Request Flow
Iedere applicatie volgt de zelfde flow:
1. Applicatie start vanaf `index.php`.
2. De application, module, en system paden worden ingesteld.
3. Error reporting niveaus worden ingesteld.
4. Install file wordt geladen, als het bestaat.
5. De [Kohana] class wordt ingeladen.
6. Het bootstrap bestand, `APPPATH/bootstrap.php`, wordt geinclude.
7. [Kohana::init] wordt aangeroepen, deze stelt error handling, caching, en logging in.
8. [Kohana_Config] lezers en [Kohana_Log] schrijvers worden toegevoegd.
9. [Kohana::modules] wordt aangeroepen om additionele modules te activeren.
* Module paden worden toegevoegd aan het [cascading filesystem](about.filesystem).
* Includen van `init.php` bestand, als het bestaat.
* Het `init.php` bestand kan een extra omgevingsinstellingen instellen, waaronder het toevoegen van routes.
10. [Route::set] wordt verschillende keren opgeroepen om de [applicaties routes](using.routing) te definiëren.
11. [Request::instance] wordt opgeroepen om het request-proces te starten.
1. Iedere route controleren dat is ingesteld tot er een overeenkomst is gevonden.
2. Conroller instantie wordt gecreeërd en het request wordt doorgeven eraan.
3. De [Controller::before] methode wordt aangeroepen.
4. De controller action wordt aangeroepen, deze genereerd de request response.
5. De [Controller::after] methode wordt aangeroepen.
* De 5 bovenstaande stappen kunnen verschillende keren worden herhaald wanneer je [HMVC sub-requests](about.mvc) gebruikt.
12. De basis [Request] response wordt getoond
## index.php
Kohana volgt een [front controller] pattern, dit betekent dat alle requests worden gezonden naar `index.php`. Dit laat een zeer eenvoudig [bestandsstructuur](about.filesystem) design toe. In `index.php` zijn er enkele zeer basis configuratie opties mogelijk. je kan de `$application`, `$modules`, en `$system` paden veranderen en het error reporting level instellen.
De `$application` variabele laat je toe om de folder in te stellen die al je application bestanden bevat. Standaard is dit `application`. De `$modules` variabele laat je toe om de folder in te stellen die alle module bestanden bevat. De `$system` variabele laat je toe om de folder in te stellen die alle Kohana bestanden bevat.
Je kan deze drie folders overal naartoe verplaatsen. Bijvoorbeeld, als je folderstructuur zo is ingesteld:
www/
index.php
application/
modules/
system/
Dan kan je de folders uit de webroot verplaatsen:
application/
modules/
system/
www/
index.php
Dan moet je de instellingen in `index.php` veranderen naar:
$application = '../application';
$modules = '../modules';
$system = '../system';
Nu kan geen enkele van deze folders worden bereikt via de webserver. Het is niet noodzakelijk om deze verandering te maken, maar het maakt het wel mogelijk om de folders te delen met meerdere applicaties, de mogelijkheden zijn enorm.
[!!] Er is een veiligheidscontrole bovenaan elke Kohana file om te voorkomen dat het wordt uitgevoerd zonder het gebruik van de front controller. Maar natuurlijk is het veiliger om de application, modules, en system folders te verplaatsen naar een locatie dat niet kan worden bereikt via het web.
### Error Reporting
Standaard toont Kohana alle errors, zo ook strikte warnings. Dit wordt ingesteld door [error_reporting](http://php.net/error_reporting):
error_reporting(E_ALL | E_STRICT);
Als je applicatie live staat en in productie is, een meer conversatieve instelling is aangeraden, zoals het negeren van notices:
error_reporting(E_ALL & ~E_NOTICE);
Als je een wit scherm krijgt wanneer een error is opgetreden, dan zal uw host waarschijnlijk het tonen van errors hebben uitgeschakeld. Je kan dit terug aanzetten door deze lijn toe te voegen juist achter je `error_reporting` call:
ini_set('display_errors', TRUE);
Errors zouden **altijd** moeten worden getoond, zelf in productie, omdat het je toelaat om [exception en error handling](debugging.errors) te gebruiken om een mooie error pagina te tonen in plaats van een wit scherm als een error voorkomt.

94
includes/kohana/modules/userguide/guide/nl/about.install.md Normal file
View File

@@ -0,0 +1,94 @@
# Installatie
1. Download de laatste **stabiele** release van de [Kohana website](http://kohanaframework.org/).
2. Unzip het gedownloade pakket om de `kohana` folder aan te maken.
3. Upload de inhoud van deze folder naar je webserver.
4. Open `application/bootstrap.php` en maak de volgende aanpassingen:
- Stel de standaard [timezone](http://php.net/timezones) in voor je applicatie
- Stel de `base_url` in de [Kohana::init] methode in om te verwijzen naar de locatie van de kohana folder op je server
6. Zorg ervoor dat de `application/cache` en `application/logs` folders schrijfrechten hebben voor de web server
7. Test je installatie door de URL te openen in je favoriete browser dat je hebt ingesteld als `base_url`
[!!] Afhankelijk van je platform is het mogelijk dat de installatie subfolders hun rechten verloren hebben tijdens de zip extractie. Chmod ze allemaal met 755 door het commando `find . -type d -exec chmod 0755 {} \;` uit te voeren in de root van je Kohana installatie.
Je zou de installatie pagina moeten zien. Als het errors toont, zal je ze moeten aanpassen vooraleer je verder kunt gaan.
![Install Page](img/install.png "Voorbeeld van de installatie pagina")
Eens je installatie pagina zegt dat je omgeving goed is ingesteld dan moet je de `install.php` pagina hernoemen of verwijderen in de root folder. Je zou nu de de Kohana welcome pagina moeten zien:
![Welcome Page](img/welcome.png "Voorbeeld van welcome pagina")
## Een productie-omgeving opzetten
Er zijn enkele dingen dat je best doet met je applicatie vooraleer je deze in productie plaatst:
1. Bekijk de [configuratie pagina](about.configuration) in de documentatie.
Dit omvat het grootste gedeelte van de globale instellingen dat zouden moeten veranderen bij andere omgevingen.
Als algemene regel, zet je best caching aan en zet je profiling uit ([Kohana::init] settings) voor sites in productie.
[Route caching](api/Route#cache) kan ook helpen als je heel wat routes hebt.
2. Catch alle exceptions in `application/bootstrap.php`, zodat gevoelige gegevens niet kan worden gelekt door stack traces.
Zie onderstaand voorbeeld van Shadowhand's [wingsc.com broncode](http://github.com/shadowhand/wingsc).
3. Zet APC of een andere soort opcode caching aan. Dit is het enige en eenvoudigste manier om de performantie te verbeteren dat je kunt doen in PHP zelf. Hoe complexer je applicatie, hoe groter het voordeel van opcode caching.
[!!] Opmerking: De standaard bootstrap zal Kohana::$environment = $_ENV['KOHANA_ENV'] instellen indien ingesteld. Documentatie hoe je deze variable moet invullen kan je vinden in je webservers documentatie (e.g. [Apache](http://httpd.apache.org/docs/1.3/mod/mod_env.html#setenv), [Lighttpd](http://redmine.lighttpd.net/wiki/1/Docs:ModSetEnv#Options), [Nginx](http://wiki.nginx.org/NginxHttpFcgiModule#fastcgi_param))). Deze manier wordt als beste beschouwd in vergelijking met de alternatieve manieren om Kohana::$environment in te stellen.
/**
* Stel de omgeving in aan de hand van het domein (standaard Kohana::DEVELOPMENT).
*/
Kohana::$environment = ($_SERVER['SERVER_NAME'] !== 'localhost') ? Kohana::PRODUCTION : Kohana::DEVELOPMENT;
/**
* Initialiseer Kohana op basis van de omgeving
*/
Kohana::init(array(
'base_url' => '/',
'index_file' => FALSE,
'profile' => Kohana::$environment !== Kohana::PRODUCTION,
'caching' => Kohana::$environment === Kohana::PRODUCTION,
));
/**
* Voer de algemene request uit met PATH_INFO. Als er geen URI is gespecifeerd,
* dan zal de URI automatisch worden gedetecteerd.
*/
$request = Request::instance($_SERVER['PATH_INFO']);
try
{
// Propeer het request uit te voeren
$request->execute();
}
catch (Exception $e)
{
if (Kohana::$environment == Kohana::DEVELOPMENT)
{
// Just re-throw the exception
throw $e;
}
// De error loggen
Kohana::$log->add(Kohana::ERROR, Kohana::exception_text($e));
// Maak een 404 uitvoer
$request->status = 404;
$request->response = View::factory('template')
->set('title', '404')
->set('content', View::factory('errors/404'));
}
if ($request->send_headers()->response)
{
// Verkrijg totaal aantal geheugen en snelheids tijd
$total = array(
'{memory_usage}' => number_format((memory_get_peak_usage() - KOHANA_START_MEMORY) / 1024, 2).'KB',
'{execution_time}' => number_format(microtime(TRUE) - KOHANA_START_TIME, 5).' seconds');
// Stel de totalen in, in de uitvoer
$request->response = str_replace(array_keys($total), $total, $request->response);
}
/**
* Toon de uitvoer dan het request.
*/
echo $request->response;

15
includes/kohana/modules/userguide/guide/nl/about.kohana.md Normal file
View File

@@ -0,0 +1,15 @@
# Wat is Kohana?
Kohana is een open source, [objectgeoriënteerd](http://nl.wikipedia.org/wiki/Objectgeori%C3%ABnteerd) [MVC](http://wikipedia.org/wiki/Model–View–Controller "Model View Controller") [web framework](http://wikipedia.org/wiki/Web_Framework) gebouwd met [PHP5](http://php.net/manual/intro-whatis "PHP Hypertext Preprocessor") door een aantal vrijwilligers die veiligheid, snelheid en een kleine voetafdruk nastreven.
[!!] Kohana is gelicentieerd onder een [BSD license](http://kohanaframework.org/license), zodat je het framework legaal kunt gebruiken voor allerlei projecten: open source, commercieel of persoonlijk.
## Waarom is Kohana zo goed?
Alles kan worden uitgebreid door het unieke design van het [filesystem](about.filesystem), er is geen of weinig [configuratie](about.configuration) voor nodig, [error handling](debugging.errors) helpt je vlug de oorzaak te vinden van je fouten en [debuggen](debugging) en [profiling](debugging.profiling) zorgen voor een beter inzicht in je applicatie.
Om je te helpen je applicatie te beveiligen zijn er tools voor [XSS te verwijderen](security.xss), [input validatie](security.validation), [gesigneerde cookies](security.cookies), [formulieren](security.forms) en [HTML](security.html) generators toegevoegd aan het systeem. De [database](security.database) layer voorkomt [SQL injectie](http://wikipedia.org/wiki/SQL_Injection). En natuurlijk, alle officiële code is met zorg geschreven en herbekeken inzake veiligheid.
## Vul mee deze documentatie aan
We zijn keihard en volop bezig om je van een complete documentatie te voorzien. Om deze documentatie te helpen verbeteren, gelieve dan de userguide te [forken](http://github.com/kohana/userguide), uw aanpassingen te doen en een pull request te sturen. Als je nog geen ervaring hebt met git kan je altijd een [feature request](http://dev.kohanaframework.org/projects/kohana3/issues) aanmaken (vereist registratie).

7
includes/kohana/modules/userguide/guide/nl/about.mvc.md Normal file
View File

@@ -0,0 +1,7 @@
# (Hiërarchische) Model View Controller
Model View Controller (of MVC afgekort) is een populair design pattern dat de data (Model) afscheid van de presentatie/templates (View) en de request-logica (Controller).
Het maakt ontwikkelen van applicaties een stuk gemakkelijker omdat het systeem zo gedesignd is om code meermaals te hergebruiken, wat wil zeggen dat je er minder moet schrijven!
[!!] Stub

4
includes/kohana/modules/userguide/guide/nl/about.translation.md Normal file
View File

@@ -0,0 +1,4 @@
# Translation
[!!] This article is a stub!

288
includes/kohana/modules/userguide/guide/nl/about.upgrading.md Normal file
View File

@@ -0,0 +1,288 @@
# Upgraden vanaf 2.3.x
De code van Kohana v3 werkt grotendeels anders dan Kohana 2.3, hier is een lijst van de meeste valkuilen en tips om succesvol te upgraden.
## Naming conventies
In 2.x versies onderscheiden de verschillende soorten van classes (zoals controller, model, ...) zich met elkaar met behulp van achtervoegsels. Mappen in de model / controller mappen hadden geen invloed op de naam van de class.
In 3.0 werd aanpak geschrapt ten gunste van de Zend framework bestandssysteem conventies, waar de naam van de class het pad is naar de class zelf, gescheiden door een underscore in plaats van slashes (dus `/some/class/file.php` bekomt `Some_Class_File`).
Zie de [conventies documentatie](start.conventions) voor meer informatie.
## Input Library
De Input Library is verwijderd in 3.0, er wordt nu aanbevolen om gewoon `$_GET` en `$_POST` te gebruiken.
### XSS Protectie
Als je invoer van gebruikers wilt filteren op XSS kan je [Security::xss_clean] gebruiken om:
$_POST['description'] = security::xss_clean($_POST['description']);
Je kan ook altijd [Security::xss_clean] gebruiken als filter met de [Validate] library:
$validation = new Validate($_POST);
$validate->filter('description', 'Security::xss_clean');
### POST & GET
Eén van de grootste functies van de Input Library was als je probeerde een waarde uit een superglobale array te halen en deze bestond bestond niet, dan zou de Input Library een standaard waarde teruggeven dat je kon instellen:
$_GET = array();
// $id heeft de waarde 1 gekregen
$id = Input::instance()->get('id', 1);
$_GET['id'] = 25;
// $id heeft de waarde 25 gekregen
$id = Input::instance()->get('id', 1);
In 3.0 kan je deze functionaliteit nabootsen door [Arr::get] te gebruiken:
$_GET = array();
// $id heeft de waarde 1 gekregen
$id = Arr::get($_GET, 'id', 1);
$_GET['id'] = 42;
// $id heeft de waarde 42 gekregen
$id = Arr::get($_GET, 'id', 1);
## ORM Library
Er zijn redelijk veel grote wijzingingen aangebracht in ORM sedert 2.3. Hier is een lijst met de meest voorkomende upgrade problemen.
### Member variablen
Alle member variablen hebben nu een voorvoegsel gekregen met een underscore (_) en zijn niet langer bereikbaar via `__get()`. Nu moet je een functie aanroepen met de naam van de property zonder de underscore.
Bijvoorbeeld, in 2.3 had je `loaded` en in 3.x is dat nu `_loaded` en heb je nu toegang van buiten de class via `$model->loaded()`.
### Relaties
Als je in 2.3 de gerelateerde objecten van een model wilde herhalen, kon je dat zo doen:
foreach($model->{relation_name} as $relation)
Maar in 3.0 zal dit niet werken. In de 2.3 serie werden alle queries die gegenereerd werden met behulp van de Database Library gegeneeerd in een globale omgeving, wat betekent dat je niet kon proberen en maken van twee queries. Bijvoorbeeld:
# TODO: GOED VOORBEELD!!!!
Deze query zou mislukken doordat de tweede, inner query alle voorwaarden zou overerven van de eerste, wat zou leiden tot het mislukken.
In 3.0 is dit aangepast door iedere query te laten genereren in zijn eigen omgeving. Let wel dat sommige dingen hierdoor niet gaan werken zoals je verwacht. Bijvoorbeeld:
foreach(ORM::factory('user', 3)->where('post_date', '>', time() - (3600 * 24))->posts as $post)
{
echo $post->title;
}
[!!] (Zie [de Database tutorial](tutorials.databases) voor de nieuwe query syntax)
In 2.3 zou je verwachten dat dit iterator teruggeeft van alle berichten van een gebruiker met `id` 3 met een `post_date` binnenin de 24 uren, maar in de plaats daarvan zal de WHERE conditie toegepast worden op het user-model en een `Model_Post` worden teruggevens met de joining conditities gespecifieerd.
Om hetzelfde effect te verkrijgen zoals in 2.3, moet je de structuur iets aanpassen:
foreach(ORM::factory('user', 3)->posts->where('post_date', '>', time() - (36000 * 24))->find_all() as $post)
{
echo $post->title;
}
Dit is ook van toepassing op de `has_one` relaties:
// Niet correct
$user = ORM::factory('post', 42)->author;
// Correct
$user = ORM::factory('post', 42)->author->find();
### Has and belongs to many relaties
In 2.3 kon je `has_and_belongs_to_many` relaties specifieren. In 3.0 is deze functionaliteit herschreven naar `has_many` *through*.
In het model definieer je een `has_many` relatie met een ander model maar dan voeg je nog een `'through' => 'table'` attribuut aan toe, waar `'table'` de naam is van de trough tabel. Bijvoorbeeld (in de context van posts<>categories):
$_has_many = array
(
'categories' => array
(
'model' => 'category', // The foreign model
'through' => 'post_categories' // The joining table
),
);
Als je Kohana hebt opgezet om een tabel voorvoegsel te gebruiken, dan hoef je geen zorgen te maken om dit voorvoegsel hier te gebruiken bij de tabelnaam.
### Foreign keys
Als je in Kohana 2.x's ORM een foreign key wilde overschrijven moest je de relatie specificeren waaraan het toebehoorde, en de nieuwe foreign key instellen in de member variabele `$foreign_keys`.
In 3.0 moet je nu een `foreign_key` definiëren in de relatie-definitie, zoals hier:
Class Model_Post extends ORM
{
$_belongs_to = array
(
'author' => array
(
'model' => 'user',
'foreign_key' => 'user_id',
),
);
}
In dit voorbeeld zouden we een `user_id` veld moeten hebben in de tabel posts.
In has_many relaties is de `far_key` het veld in de trough tabel die linkt naar de foreign tabel en is de `foreign key` het veld in de trough tabel die "this" model's tabel linkt naar de trough table.
Stel je de volgende opstelleing voor: "Posts" hebben en behoren tot vele "Categories" via `posts_sections` ("Posts" have and belong to many "Categories" through `posts_sections`)
| categories | posts_sections | posts |
|------------|------------------|---------|
| id | section_id | id |
| name | post_id | title |
| | | content |
Class Model_Post extends ORM
{
protected $_has_many = array(
'sections' => array(
'model' => 'category',
'through' => 'posts_sections',
'far_key' => 'section_id',
),
);
}
Class Model_Category extends ORM
{
protected $_has_many = array (
'posts' => array(
'model' => 'post',
'through' => 'posts_sections',
'foreign_key' => 'section_id',
),
);
}
Uiteraard is de aliasing setup hier een beetje gek, onnodig, maar het is een goed voorbeeld om te tonen hoe het foreign/far key systeem werkt.
### ORM Iterator
Het is ook best te melden dat `ORM_Iterator` nu herschreven is naar `Database_Result`.
Als je een array van ORM objecten met hun keys als index van de array wilt verkrijgen, moet je [Database_Result::as_array] gebruiken, bijvoorbeeld:
$objects = ORM::factory('user')->find_all()->as_array('id');
Waar `id` de primary key is in de user tabel.
## Router Library
In versie 2 was er een Router library die de main request afhandelde. Het liet je de basisroutes instellen in het `config/routes.php` bestand en het liet je toe om zelfgeschreven regex te gebruiken voor routes, maar het was niet echt flexibel als je iets radicaal wou veranderen.
## Routes
Het routing systeem (nu wordt verwezen naar het request systeem) is een stuk flexibeler in 3.0. Routes zijn nu gedefinieerd in het boostrap bestand (`application/bootstrap.php`) en de de module's init.php (`modules/module_name/init.php`). Het is ook interessant te weten dat routes worden geëvalueerd in de volgorde dat ze worden gedefinieerd. In plaats daarvan specifieer je een patroon voor elke uri, je kan variabelen gebruiken om segmenten aan te duiden (zoals een controller, methode, id).
Bijvoorbeeld, in 2.x zouden deze regexes:
$config['([a-z]+)/?(\d+)/?([a-z]*)'] = '$1/$3/$1';
de uri `controller/id/method` linken aan `controller/method/id`. In 3.0 gebruik je dit:
Route::set('reversed','(<controller>(/<id>(/<action>)))')
->defaults(array('controller' => 'posts', 'action' => 'index'));
[!!] Iedere uri moet een unieke naam hebben (in dit geval `reversed`), de reden hiervoor wordt nader uitgelegd in de [url tutorial](tutorials.urls).
Slashes geven dynamische secties weer die zouden moeten worden ontleed in variabelen. Haakjes geven optionele secties aan die niet vereist zijn. Als je met een route enkel uris die beginnen met admin wilt aanspreken kan je dit gebruiken:
Rouse::set('admin', 'admin(/<controller>(/<id>(/<action>)))');
En als je wilt een dat een gebruiker een controller specificeert:
Route::set('admin', 'admin/<controller>(/<id>(/<action>))');
Kohana maakt geen gebruik van `default defaults`. Als je wilt dat Kohana ervan uit gaat dat de standaard actie 'index' is, dan moet je dat ook zo instellen! Dit kan je doen via [Route::defaults]. Als je zelfgeschreven regex wilt gebruiken voor uri segmenten dan moet je ene array met `segment => regex` meegeven, bijvoorbeeld:
Route::set('reversed', '(<controller>(/<id>(/<action>)))', array('id' => '[a-z_]+'))
->defaults(array('controller' => 'posts', 'action' => 'index'))
Dit zou de `id` waarde forceren om te bestaan uit kleine letters van a tot z en underscores.
### Actions
Nog één ding dat belangrijk is om te melden, is dat methoden in een controller die toegankelijk moeten zijn via een url nu "actions" worden genoemd. Ze krijgen een voorvoegsel 'action_'. Bijvoorbeeld in het bovenstaande voorbeeld, als de user de url `admin/posts/1/edit` aanroept dan is de actie `edit` maar is de methode die wordt aangeroepen in de controller `action_edit`. Zie de [url tutorial](tutorials.urls) voor meer informatie.
## Sessies
De volgende methoden worden niet meer ondersteund: Session::set_flash(), Session::keep_flash() or Session::expire_flash(), inde plaats daarvan gebruik je nu [Session::get_once].
## URL Helper
Er zijn maar een aantal kleinere dingen veranderd in de url helper. `url::redirect()` werd vervangen door `$this->request->redirect()` (binnenin controllers) en `Request::instance()->redirect()`.
`url::current` werd nu vervangen door `$this->request->uri()`
## Valid / Validation
Deze twee classes zijn nu samengevoegd in één enkele class met de naam `Validate`.
De syntax om arrays te valideren is een klein beetje gewijzigd:
$validate = new Validate($_POST);
// Pas een filter toe op alle waarden in de array
$validate->filter(TRUE, 'trim');
// Om enkel rules te definiëren gebruik je rule()
$validate
->rule('field', 'not_empty')
->rule('field', 'matches', array('another_field'));
// Om meerdere rules te definiëren voor een veld gebruik je rules(), je geeft een array mee met `passing an array of rules => params als tweede argument
$validate->rules('field', array(
'not_empty' => NULL,
'matches' => array('another_field')
));
De 'required' rule is ook verandert van naam. Nu wordt voor de duidelijkheid 'not_empty' gebruikt.
## View Library
Er zijn enkele kleine wijzigingen aangebracht aan de View library die de moeite zijn om even te melden.
In 2.3 werden views gegenereerd binnenin de scope van de controller, dit liet je toe om `$this` te gebruiken als referentie naar de controller vanuit je view, dit is verandert in 3.0. Views worden nu gegenereerd in een lege scope. Als je nog `$this` wilt gebruiken in je view, moet je een referentie leggen via [View::bind]: `$view->bind('this', $this)`.
Het moet wel gezegd worden dat dit een *erg* slechte manier van werken is omdat het je view koppelt aan de controller wat tegenhoud om deze view opnieuw te gebruiken. Het is aan te raden om de noodzakelijke variabelen voor je view als volgt door te sturen:
$view = View::factory('my/view');
$view->variable = $this->property;
// OF als je dit wilt "chainen"
$view
->set('variable', $this->property)
->set('another_variable', 42);
// NIET aangeraden
$view->bind('this', $this);
Omdat de view gegenereerd wordt in een lege scope, is `Controller::_kohana_load_view` nu overtollig. Als je de view moet aanpassen vooraleer het word gegenereerd (bijvoorbeeld om een menu te gereneren over de gehele site) kan je [Controller::after] gebruiken.
Class Controller_Hello extends Controller_Template
{
function after()
{
$this->template->menu = '...';
return parent::after();
}
}

18
includes/kohana/modules/userguide/guide/nl/debugging.code.md Normal file
View File

@@ -0,0 +1,18 @@
# Debuggen
Kohana heeft verschillende goede tools om je te helpen met het debuggen van je applicatie.
De meest gebruikte is [Kohana::debug]. Deze eenvoudige methode geef alle variablen terug, vergelijkbaar met [var_export](http://php.net/var_export) of [print_r](http://php.net/print_r), maar het gebruikt HTML voor extra opmaak.
// Toon een dump van de variabelen $foo en $bar
echo Kohana::debug($foo, $bar);
Kohana biedt ook een methode aan om de broncode van een bepaald bestand te tonen via [Kohana::debug_source].
// Toon deze lijn van de broncode
echo Kohana::debug_source(__FILE__, __LINE__);
Als je informatie wilt tonen over uw applicatie bestanden zonder te vertellen wat de installatie folder is, kan je [Kohana::debug_path] gebruiken:
// Toont "APPPATH/cache" in plaats van het echte path
echo Kohana::debug_path(APPPATH.'cache');

22
includes/kohana/modules/userguide/guide/nl/debugging.errors.md Normal file
View File

@@ -0,0 +1,22 @@
# Error/Exception Handling
Kohana biedt zowel een exception handler als een error handler aan die errors transformeert in exceptions met behulp van PHP's [ErrorException](http://php.net/errorexception) class. Veel details over de error en de interne toestand van de applicatie wordt weergegeven door de handler:
1. Exception class
2. Error niveau
3. Error bericht
4. Bron van de error, met de errorlijn gehighlight
5. Een [debug backtrace](http://php.net/debug_backtrace) van de uitvoerings flow
6. Ingeladen bestanden, extensies en globale variablen
## Voorbeeld
Klik op een van de links om extra informatie te tonen:
<div>{{userguide/examples/error}}</div>
## Error/Exception Handling uitzetten
Als je niet de interne error handling wilt gebruiken, kan je deze uitschakelen wanneer je [Kohana::init] aanroept:
Kohana::init(array('errors' => FALSE));

20
includes/kohana/modules/userguide/guide/nl/debugging.profiling.md Normal file
View File

@@ -0,0 +1,20 @@
# Profiling
Kohana biedt een zeer eenvoudige manier aan om statistieken over uw aanvraag te tonen:
1. Gewone [Kohana] methodes dat aangeroepen worden
2. Requests
3. [Database] queries
4. Gemiddelde uitvoeringstijden voor uw applicatie
## Voorbeeld
Je kan op elk tijdstip de huidige [profiler] statistieken tonen of opvragen:
<div id="kohana-profiler">
<?php echo View::factory('profiler/stats') ?>
</div>
## Voorbeeld
{{profiler/stats}}

1
includes/kohana/modules/userguide/guide/nl/features.md Normal file
View File

@@ -0,0 +1 @@
This page lists the features of Kohana v3

31
includes/kohana/modules/userguide/guide/nl/menu.md Normal file
View File

@@ -0,0 +1,31 @@
1. **Ga aan de slag**
- [Wat is Kohana?](about.kohana)
- [Conventies and Codeerstijl](about.conventions)
- [Model View Controller](about.mvc)
- [Cascading Filesystem](about.filesystem)
- [Request Flow](about.flow)
- [Installatie](about.install)
- [Upgraden](about.upgrading)
- [API Browser](api)
3. **Basis gebruik**
- [Configuratie](using.configuration)
- [Laden van classes](using.autoloading)
- [Views en HTML](using.views)
- [Sessies en Cookies](using.sessions)
- [Berichten (Messages)](using.messages)
4. **Debuggen**
- [Code](debugging.code)
- [Error Handling](debugging.errors)
- [Profiling](debugging.profiling)
5. **Beveiliging**
- [XSS](security.xss)
- [Validatie](security.validation)
- [Cookies](security.cookies)
- [Database](security.database)
6. **Tutorials**
- [Hello, World](tutorials.helloworld)
- [Routes, URLs en Links](tutorials.urls)
- [URLs opschonen](tutorials.removeindex)
- [Databases](tutorials.databases)
- [ORM](tutorials.orm)
- [Werken met Git](tutorials.git)

3
includes/kohana/modules/userguide/guide/nl/security.cookies.md Normal file
View File

@@ -0,0 +1,3 @@
# Cookie Veiligheid
[!!] Nog niet beschikbaar

3
includes/kohana/modules/userguide/guide/nl/security.database.md Normal file
View File

@@ -0,0 +1,3 @@
# Database Veiligheid
[!!] Nog niet beschikbaar

244
includes/kohana/modules/userguide/guide/nl/security.validation.md Normal file
View File

@@ -0,0 +1,244 @@
# Validatie
Validatie kan uitgevoerd worden op elke array met behulp van de [Validate] class. Labels, filters, regels en callbacks kunnen aan het Validate object worden toegevoegd via een array key, zogenaamd een "veldnaam".
labels
: Een label is een gebruiksvriendelijke leesbare versie van de veldnaam.
filters
: Een filter wijzigt de waarde van een veld voordat de regels en callbacks worden uitgevoerd.
rules
: Een regel is een controle op een veld dat "TRUE" of "FALSE" teruggeeft. A rule is a check on a field that returns `TRUE` or `FALSE`. Als een regel `FALSE` teruggeeft, wordt er een error toegevoegd aan het veld.
callbacks
: Een callback is een zelfgeschreven methode die het gehele Validate object tot zijn beschikking heeft. De return value van een callback wordt genegeerd. In plaats daarvan moet de callback handmatig een error toevoegen aan het object met behulp van [Validate::error] wanneer een fout optreedt.
[!!] Merk op dat de [Validate] callbacks en de [PHP callbacks](http://php.net/manual/language.pseudo-types.php#language.types.callback) niet hetzelfde zijn.
Waneer je `TRUE` als veldnaam gebruikt bij het toevoegen van een filter, regel of callback, dan zal deze worden toegepast op alle velden met een naam.
**Het [Validate] object zal alle velden verwijderen van de array wanneer deze niet specifiek een naam hebben gekregen via een label, filter, regel of callback. Dit voorkomt toegang tot velden die niet gevalideerd zijn als een veiligheidsmaatregel.**
Een validatie object maken wordt gedaan door de [Validate::factory] methode:
$post = Validate::factory($_POST);
[!!] Het `$post` object zal worden gebruikt voor de rest van deze tutorial. Deze tutorial zal je tonen hoe je een registratie van een nieuwe gebruiker valideert.
### Standaard regels
Validatie heeft standaard altijd enkele regels:
Naam van de regel | Functie
------------------------- |---------------------------------------------------
[Validate::not_empty] | Waarde moet een niet-lege waarde zijn
[Validate::regex] | Waarde moet voldoen aan de reguliere expressie
[Validate::min_length] | Minimum aantal karakters voor een waarde
[Validate::max_length] | Maximum aantal karakters voor een waarde
[Validate::exact_length] | Waarde moet een exact aantal karakters bevatten
[Validate::email] | Een emailadres is vereist
[Validate::email_domain] | Controleer of het domein van het email bestaat
[Validate::url] | Waarde moet een URL zijn
[Validate::ip] | Waarde moet een IP address zijn
[Validate::phone] | Waarde moet een telefoonnummer zijn
[Validate::credit_card] | Waarde moet een credit card zijn
[Validate::date] | Waarde moet een datum (en tijd) zijn
[Validate::alpha] | Alleen alpha karakters toegelaten
[Validate::alpha_dash] | Alleen alpha karakters en koppeltekens toegelaten
[Validate::alpha_numeric] | Alleen alpha karakters en nummers toegelaten
[Validate::digit] | Waarde moet een geheel getal zijn
[Validate::decimal] | Waarde moet een decimaal of float getal zijn
[Validate::numeric] | Alleen nummers toegelaten
[Validate::range] | Waarde moet zich bevinden binnenin een range
[Validate::color] | Waarde moet een geldige HEX kleurencode zijn
[Validate::matches] | Waarde moet gelijk zijn aan een ander veld
[!!] Iedere methode dat bestaat binnenin de [Validate] class kan gebruikt worden als validatie-regel zonder een volledige callback te definiëren. Bijvoorbeeld, `'not_empty'` toevoegen is hetzelfde als `array('Validate', 'not_empty')`.
## Toevoegen van filters
Alle validatie-filters worden gedefineerd als een veldnaam, een methode of een functie (gebruik makend van [PHP callback](http://php.net/manual/language.pseudo-types.php#language.types.callback) syntax) en een array van parameters:
$object->filter($field, $callback, $parameter);
Filters veranderen de waarde van een veld vooraleer deze gecontoleerd zijn via regels of callbacks.
Indien we het veld "username" willen omvormen naar kleine letters:
$post->filter('username', 'strtolower');
Als we alle witruimtes voor en na de waarde willen verwijderen voor *alle* velden:
$post->filter(TRUE, 'trim');
## Toevoegen van regels
Alle validatieregels worden gedefineerd als een veldnaam, een methode of een functie (gebruik makend van [PHP callback](http://php.net/manual/language.pseudo-types.php#language.types.callback) syntax) en een array van parameters:
$object->rule($field, $callback, $parameter);
Om ons voorbeeld te starten, zullen we validatie uitvoeren op een `$_POST` array die gebruikers registratie gegevens bevat:
$post = Validate::factory($_POST);
Vervolgens moeten we de POST-informatie met behulp van [Validate] doorlopen. Om te beginnen moeten we een aantal regels toevoegen:
$post
->rule('username', 'not_empty')
->rule('username', 'regex', array('/^[a-z_.]++$/iD'))
->rule('password', 'not_empty')
->rule('password', 'min_length', array('6'))
->rule('confirm', 'matches', array('password'))
->rule('use_ssl', 'not_empty');
Iedere bestaande PHP functie kan worden gebruikt als regel. Bijvoorbeeld, als we willen controleren of een gebruiker een correcte waarde heeft ingevuld als antwoord op de SSL question:
$post->rule('use_ssl', 'in_array', array(array('yes', 'no')));
Merk op dat alle array parameters steeds moeten "verpakt" worden door een array! Zonder die array, `in_array` zou worden aangeroepen als `in_array($value, 'yes', 'no')`, wat een PHP error zou teruggeven.
Je kan eigen regels toevoegen met behulp van een [PHP callback](http://php.net/manual/language.pseudo-types.php#language.types.callback]:
$post->rule('username', 'User_Model::unique_username');
[!!] Momenteel (v3.0.7) is het niet mogelijk om een object te gebruiken als rule, enkel statische methodes en functies.
De methode `User_Model::unique_username()` zal ongeveer gedefinieerd worden als:
public static function unique_username($username)
{
// Controleer of de username al bestaat in de database
return ! DB::select(array(DB::expr('COUNT(username)'), 'total'))
->from('users')
->where('username', '=', $username)
->execute()
->get('total');
}
[!!] Zelfgeschreven regels laten toe om de vele extra controles te hergebruiken voor verschillende doeleinden. Deze functies zullen meestal bestaan in een model, maar kunnen gedefinieerd worden in elke class.
## Toevoegen van callbacks
Alle validatie-callbacks worden gedefineerd als een veldnaam en een methode of een functie (gebruik makend van [PHP callback](http://php.net/manual/language.pseudo-types.php#language.types.callback) syntax):
$object->callback($field, $callback);
[!!] In tegenstelling tot filters en regels, kunnen geen parameters worden meegestuurd naar een callback.
Het gebruikers wachtwoord moet gehashed worden indien het gevalideerd is, dus zulen we dit doen met een callback:
$post->callback('password', array($model, 'hash_password'));
Dit in de veronderstelling dat de `$model->hash_password()` methode er gelijkaardig uitzien als:
public function hash_password(Validate $array, $field)
{
if ($array[$field])
{
// Hash het wachtwoord als het bestaat
$array[$field] = sha1($array[$field]);
}
}
# Een volledig voorbeeld
Eerst hewwen we een [View] nodig met daarin een HTML formulier, die we plaatsen in `application/views/user/register.php`:
<?php echo Form::open() ?>
<?php if ($errors): ?>
<p class="message">Er zijn enkele fouten opgelopen, gelieve je ingevoerde gegevens opnieuw te bekijken.</p>
<ul class="errors">
<?php foreach ($errors as $message): ?>
<li><?php echo $message ?></li>
<?php endforeach ?>
<?php endif ?>
<dl>
<dt><?php echo Form::label('username', 'Gebruikersnaam') ?></dt>
<dd><?php echo Form::input('username', $post['username']) ?></dd>
<dt><?php echo Form::label('password', 'Wachtwoord') ?></dt>
<dd><?php echo Form::password('password') ?></dd>
<dd class="help">Wachtwoord moet minstens 6 karakters lang zijn.</dd>
<dt><?php echo Form::label('confirm', 'Bevestig wachtwoord') ?></dt>
<dd><?php echo Form::password('confirm') ?></dd>
<dt><?php echo Form::label('use_ssl', 'Gebruik extra veiligheid?') ?></dt>
<dd><?php echo Form::select('use_ssl', array('yes' => 'Altijd', 'no' => 'Enkel indien nodig'), $post['use_ssl']) ?></dd>
<dd class="help">Voor uw veiligheid wordt SSL altijd gebruik bij betalingen.</dd>
</dl>
<?php echo Form::submit(NULL, 'Registreer') ?>
<?php echo Form::close() ?>
[!!] Dit voorbeeld maakt veel gebruik van de [Form] helper. Het gebruik van [Form] in plaats van HTML schrijven zorgt ervoor dat alle formuliervelden overweg kunnen met ingevoerde waardes die HTML karakters bevatten. Indien je liever zelf HTML schrijft, gebruik dan zeker [HTML::chars] om gebruikersgegevens te "escapen".
Vervolgens hebben we een controller nodig en een actie om de registratie uit te voeren, we plaatsen dit in `application/classes/controller/user.php`:
class Controller_User extends Controller {
public function action_register()
{
$user = Model::factory('user');
$post = Validate::factory($_POST)
->filter(TRUE, 'trim')
->filter('username', 'strtolower')
->rule('username', 'not_empty')
->rule('username', 'regex', array('/^[a-z_.]++$/iD'))
->rule('username', array($user, 'unique_username'))
->rule('password', 'not_empty')
->rule('password', 'min_length', array('6'))
->rule('confirm', 'matches', array('password'))
->rule('use_ssl', 'not_empty')
->rule('use_ssl', 'in_array', array(array('yes', 'no')))
->callback('password', array($user, 'hash_password'));
if ($post->check())
{
// Data is gevalideerd, registreer de gebruiker
$user->register($post);
// Altijd een redirect uitvoeren na een succesvolle POST om herladingsberichten te voorkomen.
$this->request->redirect('user/profile');
}
// Validatie is fout gelopen, verzamel alle errors
$errors = $post->errors('user');
// Toon het registratieformulier
$this->request->response = View::factory('user/register')
->bind('post', $post)
->bind('errors', $errors);
}
}
We hebben ook een user-model nodig, we plaatsen dit in `application/classes/model/user.php`:
class Model_User extends Model {
public function register($array)
{
// Maak een nieuw gebruikerslijn aan in de database
$id = DB::insert(array_keys($array))
->values($array)
->execute();
// Bewaar het nieuwe gebruikers id in een cookie
cookie::set('user', $id);
return $id;
}
}
Dat is het, we hebben een volledig gebruikersregistratie voorbeeld afgewerkt dat zorgvuldig ingevoerde gegevens controleert.

15
includes/kohana/modules/userguide/guide/nl/security.xss.md Normal file
View File

@@ -0,0 +1,15 @@
# Cross-Site Scripting (XSS) Veiligheid
De eerste stap om [XSS](http://wikipedia.org/wiki/Cross-Site_Scripting)-aanvallen te voorkomen is weten wanneer je jezelf moet beschermen. XSS kan enkel worden geactiveerd wanneer het wordt weergegeven in de HTML-inhoud, dit kan soms via een formulier-veld of worden getoond van database resultaten. Elke globale variabele dat gebruikersgegevens bevat kan worden aangetast. Dit omvat `$ _GET`, `$ _POST` en `$ _COOKIE` gegevens.
## Het voorkomen
Er zijn maar een paar eenvoudige regels te volgen om uw applicatie HTML te beschermen tegen XSS. De eerste stap is om de [Security::xss] methode te gebruiken om alle ingevoerde gegevens op te kuisen die afkomstig zijn van een globale variabele. Als je geen HTML wilt in een variable, gebruik dan [strip_tags](http://php.net/strip_tags) om alle ongewenste HTML tags te verwijderen van de ingevoerde waarde.
[!!] Als je gebruikers toelaat om HTML in te voeren in je applicatie, dan is het streng aanbevolen om een HTML "opkuis-tool" te gebruiken zoals [HTML Purifier](http://htmlpurifier.org/) of [HTML Tidy](http://php.net/tidy).
De tweede stap is om altijd de ingevoerde HTML te escapen. De [HTML] class voorziet generatoren voor veelvoorkomende tags, zo ook script en stylesheet links, ankers, afbeeldingen en e-mail (mailto) links. Elke niet-vertrouwde inhoud moet worden ge-escaped met [HTML::chars].
## Referenties
* [OWASP XSS Cheat Sheet](http://www.owasp.org/index.php/XSS_(Cross_Site_Scripting)_Prevention_Cheat_Sheet)

248
includes/kohana/modules/userguide/guide/nl/tutorials.databases.md Normal file
View File

@@ -0,0 +1,248 @@
# Databases {#top}
Kohana 3.0 heeft een goede module ingebouwd om te kunnen werken met databases. Standaard ondersteund de database module drivers voor [MySQL](http://php.net/mysql) en [PDO](http://php.net/pdo).
De database module zit bij de Kohana 3.0 installatie maar het moet nog worden ingesteld vooraleer je het kan gebruiken. In je `application/bootstrap.php` bestand moet je de aanroep naar [Kohana::modules] aanpassen en de database module eraan toevoegen:
Kohana::modules(array(
...
'database' => MODPATH.'database',
...
));
## Configuratie {#configuration}
Nadat de module is ingesteld moet je een configuratie bestand aanmaken zodat de module weet hoe het moet connecteren met je database. Een voorbeeld configuratie bestand kan je vinden in `modules/database/config/database.php`.
De structuur van een database configuratie groep, genoemd "instantie", ziet er als volgt uit:
string INSTANCE_NAME => array(
'type' => string DATABASE_TYPE,
'connection' => array CONNECTION_ARRAY,
'table_prefix' => string TABLE_PREFIX,
'charset' => string CHARACTER_SET,
'profiling' => boolean QUERY_PROFILING,
),
[!!] Meerdere instanties van deze instellingen kunnen worden gedefinieerd binnen het configuratie bestand.
Het verstaan van elk van deze instellingen is belangrijk.
INSTANCE_NAME
: Connecties kunnen elke naam hebben, maar je moet minstens één connectie hebben met de naam "default".
DATABASE_TYPE
: Eén van de geïnstalleerde database drivers. Kohana heeft standaard de "mysql" en "pdo" drivers.
CONNECTION_ARRAY
: Specifieke driver opties om te connecteren naar je database. (Driver opties worden uitgelegd [beneden](#connection_settings).)
TABLE_PREFIX
: Voorvoegsel dat wordt toegevoegd aan al je tabelnamen door de [query builder](#query_building).
QUERY_PROFILING
: Zet [profiling](debugging.profiling) aan van database queries.
### Voorbeeld
Het voorbeeld bestand hieronder toont 2 MySQL connecties, een lokale en één op afstand (=remote).
return array
(
'default' => array
(
'type' => 'mysql',
'connection' => array(
'hostname' => 'localhost',
'username' => 'dbuser',
'password' => 'mijnwachtwoord',
'persistent' => FALSE,
'database' => 'mijn_db_naam',
),
'table_prefix' => '',
'charset' => 'utf8',
'profiling' => TRUE,
),
'remote' => array(
'type' => 'mysql',
'connection' => array(
'hostname' => '55.55.55.55',
'username' => 'remote_user',
'password' => 'mijnwachtwoord',
'persistent' => FALSE,
'database' => 'mijn_remote_db_naam',
),
'table_prefix' => '',
'charset' => 'utf8',
'profiling' => TRUE,
),
);
### Connectie instellingen {#connection_settings}
Iedere database driver heeft verschillende connectie instellingen.
#### MySQL
Een MySQL database accepteert de volgende opties in de `connection` array:
Type | Optie | Omschrijving | Standaard Waarde
----------|------------|----------------------------| -------------------------
`string` | hostname | Hostname van de database | `localhost`
`integer` | port | Poort nummer | `NULL`
`string` | socket | UNIX socket | `NULL`
`string` | username | Database gebruikersnaam | `NULL`
`string` | password | Database wachtwoord | `NULL`
`boolean` | persistent | Persistente connecties | `FALSE`
`string` | database | Database naam | `kohana`
#### PDO
Een PDO database accepteert de volgende opties in de `connection` array:
Type | Optie | Omschrijving | Standaard Waarde
----------|------------|----------------------------| -------------------------
`string` | dsn | PDO data source identifier | `localhost`
`string` | username | Database gebruikersnaam | `NULL`
`string` | password | Database wachtwoord | `NULL`
`boolean` | persistent | Persistente connecties | `FALSE`
[!!] Als je PDO gebruikt en je bent niet zeker wat je moet gebruiken voor de `dsn` optie, bekijk dan [PDO::__construct](http://php.net/pdo.construct).
## Connecties en Instanties {#connections}
Iedere configuratie groep verwijst naar een database instantie. Iedere instantie kan worden aangesproken via [Database::instance]:
$default = Database::instance();
$remote = Database::instance('remote');
Om de database los te koppelen, moet je gewoonweg het object vernietigen:
unset($default, Database::$instances['default']);
Om all database instanties in één keer los te koppelen, gebruik je:
Database::$instances = array();
## Het maken van Queries {#making_queries}
Er zijn twee verschillende manieren om queries te maken. De eenvoudigste manier om een query te maken is het gebruik van [Database_Query], via [DB::query]. Deze queries worden "prepared statements" genoemd en laat je toe om query parameters instellen die automatisch worden "geescaped". De tweede manier om een query te maken is door deze op te bouwen met behulp van methode-aanroepen. Dit wordt gedaan met behulp van de [query builder](#query_building).
[!!] Alle queries worden uitgevoerd via de `execute` methode, deze verwacht een [Database] object of een instantienaam. Zie [Database_Query::execute] voor meer informatie.
### Prepared Statements
Het gebruik van prepared statements laat je toe om SQL queries manueel te schrijven terwijl de query waarden nog steeds automatisch worden "geescaped" om [SQL injectie](http://wikipedia.org/wiki/SQL_Injection) te voorkomen. Een query aanmaken is relatief gemakkelijk:
$query = DB::query(Database::SELECT, 'SELECT * FROM users WHERE username = :user');
De [DB::query] factory methode creëert een nieuwe [Database_Query] class voor ons, zodat "methode-chaining" mogelijk is. De query bevat een `:user` parameter, die we kunnen toewijzen aan een waarde:
$query->param(':user', 'john');
[!!] Parameter namen kunnen elke string zijn aangezien worden vervangen via het gebruik van [strtr](http://php.net/strtr). Het wordt ten zeerste aanbevolen om **geen** dollar tekens te gebruiken als parameter namen om verwarring te voorkomen.
Als je de SQL wilt tonen dat zal worden uitgevoerd, moet je het object gewoonweg casten naar een string:
echo Kohana::debug((string) $query);
// Zou moeten tonen:
// SELECT * FROM users WHERE username = 'john'
Je kan ook altijd de `:user` parameter aanpassen door de [Database_Query::param] opnieuw aan te roepen:
$query->param(':user', $_GET['search']);
[!!] Indien je meerdere paramters in één keer wilt instellen kan je dat doen met [Database_Query::parameters].
Eénmaal je iets hebt toegewezen aan elke parameter, kan je de query uitvoeren:
$query->execute();
Het is ook mogelijk om een parameter te "verbinden" met een variabele, door het gebruik van een [variabele referentie]((http://php.net/language.references.whatdo)). Dit kan extreem gebruikvol zijn wanneer je dezelfde query meerdere keren moet uitvoeren:
$query = DB::query(Database::INSERT, 'INSERT INTO users (username, password) VALUES (:user, :pass)')
->bind(':user', $username)
->bind(':pass', $password);
foreach ($new_users as $username => $password)
{
$query->execute();
}
In het bovenstaand voorbeeld worden de variabelen `$username` en `$password` gewijzigd in iedere loop van het `foreach` statement. Wanneer de parameter verandert, veranderen infeite de `:user` en `:pass` query parameters. Het zorgvuldig gebruik van parameter binding kan een pak code besparen.
### Query Building {#query_building}
Het maken van dynamische queries via objecten en methodes zorgt ervoor dat queries zeer snel kunnen worden geschreven op een agnostische manier. Query building voegt ook identifier (tabel en kolom naam) en value quoting toe.
[!!] Op dit moment, is het niet mogelijk om query building te combineren met prepared statements.
#### SELECT
Elk type database query wordt vertegenwoordigd door een andere class, elk met hun eigen methoden. Bijvoorbeeld, om een SELECT-query te maken, gebruiken we [DB::select]:
$query = DB::select()->from('users')->where('username', '=', 'john');
Standaard zal [DB::select] alle kolommen selecteren (`SELECT * ...`), maar je kan ook specificeren welke kolommen je wilt teruggeven:
$query = DB::select('username', 'password')->from('users')->where('username', '=', 'john');
Neem nu een minuut de tijd om te kijken wat deze methode-keten doet. Eerst maken we een selectie object met behulp van [DB::select]. Vervolgens stellen we tabel(len) in door de `from` methode te gebruiken. Als laatste stap zoeken we voor specifieke records door gebruik te maken van de `where` methode. We kunnen de SQL tonen dat zal worden uitgevoerd door deze te casten naar een string:
echo Kohana::debug((string) $query);
// Zou moeten tonen:
// SELECT `username`, `password` FROM `users` WHERE `username` = 'john'
Merk op hoe de kolom en tabel namen automatisch worden "geescaped", eveneens de waarden? Dit is een van de belangrijkste voordelen van het gebruik van de query builder.
Het is mogelijk om `AS` aliassen te maken wanneer je iets selecteert:
$query = DB::select(array('username', 'u'), array('password', 'p'))->from('users');
Deze query zal de volgende SQL genereren:
SELECT `username` AS `u`, `password` AS `p` FROM `users`
#### INSERT
Om records aan te maken in de database gebruik je [DB::insert] om een INSERT query aan te maken:
$query = DB::insert('users', array('username', 'password'))->values(array('fred', 'p@5sW0Rd'));
Deze query zal de volgende SQL genereren:
INSERT INTO `users` (`username`, `password`) VALUES ('fred', 'p@5sW0Rd')
#### UPDATE
Om een bestaande record aan te passen gebruik je [DB::update] om een UPDATE query aan te maken:
$query = DB::update('users')->set(array('username' => 'jane'))->where('username', '=', 'john');
Deze query zal de volgende SQL genereren:
UPDATE `users` SET `username` = 'jane' WHERE `username` = 'john'
#### DELETE
Om een bestaande record te verwijderen gebruik je [DB::delete] om een DELETE query aan te maken:
$query = DB::delete('users')->where('username', 'IN', array('john', 'jane'));
Deze query zal de volgende SQL genereren:
DELETE FROM `users` WHERE `username` IN ('john', 'jane')
#### Database Functies {#database_functions}
Uiteindelijk zal je waarschijnlijk uitdraaien in een situatie waar je beroep moet doen op `COUNT` of een andere database functie binnenin je query. De query builder ondersteunt deze functies op twee manieren. De eerste mogelijkheid is met behulp van aanhalingstekens binnenin de aliassen:
$query = DB::select(array('COUNT("username")', 'total_users'))->from('users');
Dit ziet er bijna precies hetzelfde uit als een standaard "AS" alias, maar let op hoe de kolom naam is verpakt in dubbele aanhalingstekens. Iedere keer als er een waarde met dubbele aanhalingstekens verschijnt binnenin een kolom naam, wordt **alleen** het gedeelte binnen de dubbele aanhalingstekens "geescaped". Deze query zal de volgende SQL genereren:
SELECT COUNT(`username`) AS `total_users` FROM `users`
#### Complexe Expressies
Aliassen met aanhalingstekens zullen de meeste problemen oplossen, maar van tijd tot tijd kan je in een situatie komen waar je een complexe expressie kunt gebruiken. In deze gevallen moet je een database expressie gebruiken die je kan creëren met [DB::expr]. Een database expressie wordt als directe input genomen en er wordt geen "escaping" uitgevoerd.

149
includes/kohana/modules/userguide/guide/nl/tutorials.git.md Normal file
View File

@@ -0,0 +1,149 @@
# Werken met Git
Kohana gebruikt [git](http://git-scm.com/) als versie controle systeem en [github](http://github.com/kohana) voor community-bijdragen. Deze tutorial zal je tonen hoe je beide platformen kunt gebruiken om een applicatie op te zetten.
## Het installeren en instellen van Git op uw computer
### Installeren van Git
- OSX: [Git-OSX](http://code.google.com/p/git-osx-installer/)
- Windows: [Msygit](http://code.google.com/p/msysgit/)
- Of download het van de [git-site](http://git-scm.com/) en installeer het manueel (zie de git website)
### Basis globale instellingen
git config --global user.name "Uw Naam"
git config --global user.email "uwemail@website.com"
### Extra, maar aan te raden instellingen
Om een beter visueel overzicht te hebben van de git commando's en repositories in je console stel je best volgende in:
git config --global color.diff auto
git config --global color.status auto
git config --global color.branch auto
### Automatische aanvulling installeren
[!!] Deze lijnen code zijn enkel van toepassing voor OSX
Deze lijnen code doen al het vuile werk voor je zodat automatische aanvulling kan werken voor uw git-omgeving
cd /tmp
git clone git://git.kernel.org/pub/scm/git/git.git
cd git
git checkout v`git --version | awk '{print $3}'`
cp contrib/completion/git-completion.bash ~/.git-completion.bash
cd ~
rm -rf /tmp/git
echo -e "source ~/.git-completion.bash" >> .profile
### Gebruik altijd LF als regeleinden
Dit is de conventie die we maken met Kohana. Stel deze instellingen voor uw eigen goed en vooral als je wilt bijdragen aan de Kohana community.
git config --global core.autocrlf input
git config --global core.savecrlf true
[!!] Meer informatie over regeleinden kan je vinden op [github](http://help.github.com/dealing-with-lineendings/)
### Meer informatie op je op weg te zetten
- [Git Screencasts](http://www.gitcasts.com/)
- [Git Reference](http://gitref.org/)
- [Pro Git book](http://progit.org/book/)
## Initi<74>le structuur
[!!] Deze tutorial zal ervan uitgaan dat uw webserver al is ingesteld, en dat je een nieuwe applicatie zal maken op <http://localhost/gitorial/>.
Met behulp van je console, ga naar de lege map `gitorial` en voer `git init` uit. Dit zal een ruwe structuur voor een nieuwe git repository aanmaken.
Vervolgend zullen we een [submodule](http://www.kernel.org/pub/software/scm/git/docs/git-submodule.html) maken voor de `system` folder. Ga naar <http://github.com/kohana/core> en kopieer de "Clone URL":
![Github Clone URL](http://img.skitch.com/20091019-rud5mmqbf776jwua6hx9nm1n.png)
Gebruik nu de URL om de submodule aan te maken voor `system`:
git submodule add git://github.com/kohana/core.git system
[!!] Dit cre<72>ert een link naar de huidige ontwikkelingsversie voor de volgende stabiele uitgave. De ontwikkelingsversie is meestal veilig om te gebruiken, het heeft dezelfde API als de huidige stabiele download maar met bugfixes al toegepast.
Voeg nu elke submodule toe dat je wil. Bijvoorbeeld als je de [Database] module nodig hebt:
git submodule add git://github.com/kohana/database.git modules/database
Nadat de submodules zijn toegevoegd, moet je ze nog initialiseren:
git submodule init
Nu dat de submodules zijn toegevoegd en geinitialiseerd, kan je ze commit'en:
git commit -m 'Added initial submodules'
Vervolgens cre<72>ren we de applicatie folder structuur. Hier is een absoluut minimum vereist:
mkdir -p application/classes/{controller,model}
mkdir -p application/{config,views}
mkdir -m 0777 -p application/{cache,logs}
Als je nu `find application` uitvoert, moet je dit zien:
application
application/cache
application/config
application/classes
application/classes/controller
application/classes/model
application/logs
application/views
We willen niet dat git de log of cache bestanden volgt dus voegen we een `.gitignore` bestand toe aan deze folders. Dit zal alle niet-verborgen bestanden negeren:
echo '[^.]*' > application/{logs,cache}/.gitignore
[!!] Git negeert lege folders, dus het toevoegen van een `.gitignore` bestand zorgt er voor dat git de folder volgt maar niet de bestanden er in.
Nu hebben we nog de `index.php` en `bootstrap.php` bestanden nodig:
wget http://github.com/kohana/kohana/raw/master/index.php
wget http://github.com/kohana/kohana/raw/master/application/bootstrap.php -O application/bootstrap.php
Commit deze veranderingen ook:
git add application
git commit -m 'Added initial directory structure'
Dit is alles wat je nodig hebt. Je hebt nu een applicatie dat Git gebruikt als versiesysteem.
## Updaten van Submodules
Op een gegeven moment zal je waarschijnlijk ook je submodules willen upgraden. Om al je submodules te updaten naar de laatste "HEAD" versie:
git submodule foreach 'git checkout master && git pull origin master'
Om een enkele submodule te update, bijvoorbeel `system`:
cd system
git checkout master
git pull origin master
cd ..
git add system
git commit -m 'Updated system to latest version'
Als je een enkele submodule wilt updaten naar een specifieke commit:
cd modules/database
git pull origin master
git checkout fbfdea919028b951c23c3d99d2bc1f5bbeda0c0b
cd ../..
git add database
git commit -m 'Updated database module'
Merk op dat je ook een commit kunt uitchecken via een tag, zoals een officieel versie, bijvoorbeeld:
git checkout 3.0.6
Voer gewoon `git tag` uit zonder parameters om een lijst van alle tags te krijgen.
U weet nu "alles" over git!

106
includes/kohana/modules/userguide/guide/nl/tutorials.helloworld.md Normal file
View File

@@ -0,0 +1,106 @@
# Hello, World
Aangezien bijna ieder framework een soort van "hello world" voorbeeld heeft, zou het onbeleefd van ons zijn om deze traditie te doorbreken!
We gaan starten met het maken van een zeer basis hello world, om vervolgens uit te breiden om het MVC principe te volgen.
## Tot op het bot
Eerst moeten we een controller maken dat Kohana kan gebruiken om de request af te handelen.
Maak het bestand `application/classes/controller/hello.php` in uw applicatie folder en zorg voor deze code erin:
<?php defined('SYSPATH') OR die('No Direct Script Access');
Class Controller_Hello extends Controller
{
function action_index()
{
echo 'hello, world!';
}
}
Eens bekijken wat er hier allemaal gebeurd:
`<?php defined('SYSPATH') OR die('No Direct Script Access');`
: Je zou de eerste tag moeten herkennen als een php openings-tag (indien niet, leer je best [php](http://php.net)). Wat volgt is een kleine controle dat er voor zorgt dat dit bestand enkel kan uitgevoerd worden indien het ingesloten is in Kohana. Op die manier kunnen mensen er niet direct naartoe surfen.
`Class Controller_Hello extends Controller`
: Deze lijn declareert onze controller, iedere controller class moet een voorvoegsel `Controller_` hebben en een met-underscore-afgescheiden path naar de folder waarin de controller zich bevindt (zie [Conventies en codeerstijl](about.conventions) voor meer informatie). Iedere controller moet ook de basis `Controller` class uitbreiden, deze zorgt voor een standaard structuur voor controllers.
`function action_index()`
: Dit definieerd de "index" actie van onze controller. Kohana zal proberen deze actie aan te roepen als de gebruiker geen actie heeft gespecifieerd. (Zie [Routes, URLs en Links](tutorials.urls))
`echo 'hello, world!';`
: En dit is de lijn die zorgt voor de weergave van onze zin
Als je nu je browser opent en suft naar http://localhost/index.php/hello zou je zoiets moeten zien:
![Hello, World!](img/hello_world_1.png "Hello, World!")
## Dit was al goed maar we kunnen beter
Wat we deden in de vorige paragraaf was een goed voorbeeld van hoe gemakkelijk het is om een *zeer* elementaire Kohana applicatie te maken. (In feite is het zo basis, dat je het nooit meer opnieuw mag maken!)
Als je ooit al eens gehoord hebt over MVC, dan zal je jezelf waarschijlijk al gerealiseerd hebben dat content tonen aan de hand van "echo" tegenstrijdig is met de principes van MVC.
De goede manier van coderen met een MVC framework is het gebruik van _views_ om je applicatie te visualiseren en de controller laten doen waar hij goed in is, het controleren van de flow van het request!
Laten we onze originele controller lichtjes aanpassen:
<?php defined('SYSPATH') OR die('No Direct Script Access');
Class Controller_Hello extends Controller_Template
{
public $template = 'site';
function action_index()
{
$this->template->message = 'hello, world!';
}
}
`extends Controller_Template`
: We breiden nu uit van de template controller, dit maakt het meer logisch om views te gebruiken in onze controller.
`public $template = 'site';`
: De template controller moet weten welke template we willen gebruiken. Het zal automatisch de view inladen die gedefinieerd is in deze variabele en het view object eraan toewijzen.
`$this->template->message = 'hello, world!';`
: `$this->template` is een referentie naar het view object voor onze site template. Wat we hier doen is een variabele "message", met waarde "hello, world", toewijzen aan de view.
Laten we nu proberen onze code uit te voeren...
<div>{{userguide/examples/hello_world_error}}</div>
Voor de één of andere reden geeft Kohana een error en toont het niet ons cool bericht.
Als we kijken naar het error-bericht kunnen we zien dat de View library onze site template niet kon vinden, waarschijnlijk omdat we er nog geen aangemaakt hebben - *doh*!
Laten we het view bestand `application/views/site.php` aanmaken voor ons bericht:
<html>
<head>
<title>We've got a message for you!</title>
<style type="text/css">
body {font-family: Georgia;}
h1 {font-style: italic;}
</style>
</head>
<body>
<h1><?php echo $message; ?></h1>
<p>We just wanted to say it! :)</p>
</body>
</html>
Als we de pagina vernieuwen dan kunnen we de vruchten zien van ons *zwaar" werk:
![hello, world! We just wanted to say it!](img/hello_world_2.png "hello, world! We just wanted to say it!")
## Stage 3 – Profit!
In deze tutorial heb je geleerd hoe je een controller maakt en een view gebruikt om je logica te scheiden van het visuele.
Dit is natuurlijk een zeer elementaire inleiding over het werken met Kohana en toont zelfs niet de sterkte van het framework voor wanneer je applicaties hiermee ontwikkelt.

298
includes/kohana/modules/userguide/guide/nl/tutorials.orm.md Normal file
View File

@@ -0,0 +1,298 @@
# ORM {#top}
Kohana 3.0 bevat een krachtige ORM-module die het "active record"-patroon gebruikt en database introspectie gebruikt om kolominformatie te bepalen van een model.
De ORM-module is opgenomen in de Kohana 3.0 installatie maar moet worden ingeschakeld vooraleer je het kunt gebruiken. In je `application/bootstrap.php` bestand moet je de oproen naar [Kohana::modules] aanpassen en de ORM-module insluiten:
Kohana::modules(array(
...
'orm' => MODPATH.'orm',
...
));
## Configuratie {#configuration}
ORM vergt weinig configuratie om aan de slag te kunnen. Breid uw model classes uit met ORM om de module te kunnen gebruiken:
class Model_User extends ORM
{
...
}
In het voorbeeld hierboven zal het model zoeken naar een tabel `users` in de standaard database.
### Model Configuratie Properties
De volgende eigenschappen worden gebruikt om ieder model te configureren:
Type | Eigenschap | Omschrijving | Standaard waarde
----------|---------------------|--------------------------------------| -------------------------
`string` | _table_name | Tabelnaam om te gebruiken | `singular model name`
`string` | _db | Naam van de database om te gebruiken | `default`
`string` | _primary_key | Kolom die dient als primary key | `id`
`string` | _primary_val | Kolom die dient als primary value | `name`
`bool` | _table_names_plural | Zijn de tabelnamen meervoudig? | `TRUE`
`array` | _sorting | Array met kolom => volgorde | `primary key => ASC`
`string` | _foreign_key_suffix | Achtervoegsel voor foreign keys | `_id`
## Het gebruik van ORM
### Een Record inladen
Om een instantie van een model aan te maken, kan je de [ORM::factory] methode of [ORM::__construct] gebruiken:
$user = ORM::factory('user');
// of
$user = new Model_User();
De constructor en factory methodes accepteren ook een primary key waarde om het gegeven model's data in te laden:
// Laad gebruiker met ID 5
$user = ORM::factory('user', 5);
// Kijk of de gebruiker succesvol werd ingeladen
if ($user->loaded()) { ... }
Je kan optioneel een array met keys => value paren meegeven om een data object in te laden die voldoet aan de gegeven criteria:
// Laad een gebruiker met email joe@example.com
$user = ORM::factory('user', array('email' => 'joe@example.com'));
### Zoeken naar één of meerdere records
ORM ondersteunt de meeste krachtige [Database] methoden voor het doorzoeken van gegevens van uw model. Zie de `_db_methods` eigenschap voor een volledige lijst van ondersteunde methode oproepen. Records worden opgehaald met behulp van de [ORM::find] en [ORM::find_all] functies.
// Dit zal de eerste actieve gebruiker nemen met de naam Bob
$user = ORM::factory('user')
->where('active', '=', TRUE)
->where('name', '=', 'Bob')
->find();
// Dit zal alle gebruikers nemen met de naam Bob
$users = ORM::factory('user')
->where('name', '=', 'Bob')
->find_all();
Wanneer je een lijst van modellen ontvangt met behulp van [ORM::find_all], kan je deze doorlopen zoals je doet met database resultaten:
foreach ($users as $user)
{
...
}
Een zeer handige functie van ORM is de [ORM::as_array] methode die het record zal teruggeven als een array. Indien je dit gebruikt met [ORM::find_all], zal een array van alle records worden teruggegeven. Een goed voorbeeld van wanneer dit nuttig is, is voor select in het HTML formulier:
// Toon een dropdown/select met daarin alle gebruikersnamen (id als value van de options)
echo Form::select('user', ORM::factory('user')->find_all()->as_array('id', 'username'));
### Het aantal records tellen
Gebruik [ORM::count_all] om het aantal records terug te geven voor een bepaalde query.
// Aantal actieve gebruikers
$count = ORM::factory('user')->where('active', '=', TRUE)->count_all();
Als je het totaal aantal gebruikers wilt tellen voor een bepaalde query, terwijl je enkel een bepaalde set van deze gebruikers wilt tonen, gebruik dan de [ORM::reset] methode met `FALSE` vooraleer je `count_all` gebruikt:
$user = ORM::factory('user');
// Totaal aantal gebruikers (reset FALSE zorgt ervoor dat het query object dat het query object niet geleegd wordt)
$count = $user->where('active', '=', TRUE)->reset(FALSE)->count_all();
// Geef enkel de eerste 10 resultaten terug van deze resultaten
$users = $user->limit(10)->find_all();
### Properties van een model aanspreken
Alle model properties zijn toegankelijk via de `__get` en `__set` magic methodes.
$user = ORM::factory('user', 5);
// Geef de gebruikersnaam terug
echo $user->name;
// Verander de gebruiker zijn naam
$user->name = 'Bob';
Voor het opslaan van gegevens/properties die niet bestaan in de tabel van het model, kan je gebruik maken van het `_ignored_columns` data member. De gegevens zullen worden opgeslagen in het interne `_object` member, maar zal worden genegeerd op database-niveau.
class Model_User extends ORM
{
...
protected $_ignored_columns = array('field1', 'field2', …);
...
}
Meerdere key => value paren kunnen worden ingesteld door gebruik te maken van de [ORM::values] methode.
$user->values(array('username' => 'Joe', 'password' => 'bob'));
### Aanmaken en opslaan van records
De methode [ORM::save] wordt gebruikt om zowel nieuwe records aan te maken als het upaten van bestaande.
// Nieuw record aanmaken
$user = ORM::factory('user');
$user->name = 'Nieuwe gebruiker';
$user->save();
// Aanpassen van een bestaand record
$user = ORM::factory('user', 5);
$user->name = 'Gebruiker 2';
$user->save();
// Controleer of het record opgeslagen is
if ($user->saved()) { ... }
Je kan meerdere records tegelijk veranderen met de [ORM::save_all] methode:
$user = ORM::factory('user');
$user->name = 'Bob';
// Verander bij alle actieve gebruikers de naam naar 'Bob'
$user->where('active', '=', TRUE)->save_all();
#### Gebruik `Updated` en `Created` kolommen
De `_updated_column` en `_created_column` members staan ter beschikking om automatisch aangepast te worden wanneer een model wordt gecreëerd of aangepast. Ze worden standaard niet gebruikt. Om ze te gebruiken:
// date_created is de kolom die wordt gebruikt om de aanmaak datum op te slaan. Gebruik format => TRUE om een timestamp op te slaan
protected $_created_column = array('date_created', 'format' => TRUE);
// date_modified is de kolom die wordt gebruikt om de datum op te slaan wanneer het item is aangepast. In dit geval wordt een string gebruikt om een date() formaat te specificeren
protected $_updated_column = array('date_modified', 'format' => 'm/d/Y');
### Verwijderen van records
Records worden verwijderd met [ORM::delete] en [ORM::delete_all]. Deze methoden werken op dezelfde manier als het opslaan van records zoals hierboven beschreven, met de uitzondering dat [ORM::delete] nog een optionele parameter heeft, het `id` van het record om te verwijderen. Anders wordt het huidig ingeladen record verwijderd.
### Relaties
ORM ondersteunt zeer goed relateies. Ruby heeft een [goede tutorial omtrent relaties](http://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html).
#### Belongs-To en Has-Many
We gaan er van uit dat we werken met een school dat veel (has many) studenten heeft. Iedere student kan enkel maar tot één school behoren (belong to). Dan zullen de relaties als volgt gedefinieerd worden:
// In het model "school"
protected $_has_many = array('students' => array());
// In het model "student"
protected $_belongs_to = array('school' => array());
Om een student zijn school te verkrijgen gebruik je:
$school = $student->school;
Om een school zijn studenten te verkrijgen gebruik je:
// Merk op dat find_all is vereist na "students"
$students = $school->students->find_all();
// Om resultaten te "filteren":
$students = $school->students->where('active', '=', TRUE)->find_all();
Standaard zal ORM willen zoeken naar een `school_id` model in de studenten tabel. Dit kan worden overschreven door gebruik te maken van het `foreign_key` attribuut:
protected $_belongs_to = array('school' => array('foreign_key' => 'schoolID'));
De foreign key moet overschreven worden in zowel het student als school model.
#### Has-One
Has-One is een speciale versie van Has-Many, het enige verschil is dat er maar één enkel record is. In het bovenstaande voorbeeld zou iedere school maar één student hebben (al is dat wel een slecht voorbeeld).
// In het model "school"
protected $_has_one = array('student' => array());
Je moet niet zoals bij Belongs-To de `find` methode gebruiken wanneer je verwijst naar een het Has-One gerelateerd object, dit gebeurt automatisch.
#### Has-Many "Through"
De Has-Many "through" relatie (ook bekend als Has-And-Belongs-To-Many) wordt gebruikt in het geval dat één object gerelateerd is met meerdere objecten van verschillende types en omgekeerd. Bijvoorbeeld, een student kan verschillende klassen volgen en een klass kan verschillende studenten hebben. In dit geval wordt een derde tabel gebruikt en een model die dienst doet als `pivot`. In dit geval noemen we het pivot object/model `enrollment` (=inschrijving).
// In het model "student"
protected $_has_many = array('classes' => array('through' => 'enrollment'));
// In het model "class"
protected $_has_many = array('students' => array('through' => 'enrollment'));
De inschrijvingstabel (`enrollment`) moet twee foreign keys hebben, een voor `class_id` en de andere voor `student_id`. Deze kunnen worden overschreven door `foreign_key` en `far_key` te gebruiken bij het definiëren van de relatie. Bijvoorbeeld:
// In het model "student" (de foreign key verwijst naar dit model [student], terwijl de far key verwijst naar het andere model [class])
protected $_has_many = array('classes' => array('through' => 'enrollment', 'foreign_key' => 'studentID', 'far_key' => 'classID'));
// In het model "class"
protected $_has_many = array('students' => array('through' => 'enrollment', 'foreign_key' => 'classID', 'far_key' => 'studentID'));
Het inschrijvings model (enrollment) zal als volgt gedefinieerd worden:
// Het model "enrollment" hoort bij zowel "student" als "class"
protected $_belongs_to = array('student' => array(), 'class' => array());
Om de gerelateerde objecten te bereiken, gebruik je:
// Om de klassen van een student te verkrijgen
$student->classes->find_all();
// Om studenten te verkrijven vanuit de klas
$class->students->find_all();
### Validatie
ORM werkt nauw samen met de [Validate] library. ORM biedt de volgende members aan voor validatie
* _rules
* _callbacks
* _filters
* _labels
#### `_rules`
protected $_rules = array
(
'username' => array('not_empty' => array()),
'email' => array('not_empty' => array(), 'email' => array()),
);
`username` zal gecontroleerd worden om zeker niet leeg te zijn. `email` zal ook gecontroleerd worden om te verzekeren dat het een geldig emailadres is. De lege arrays die als values worden meegestuurd, kunnen worden gebruikt om optionele parameters mee te geven aan deze functie aanroepen.
#### `_callbacks`
protected $_callbacks = array
(
'username' => array('username_unique'),
);
`username` zal worden meegestuurd naar een callback methode `username_unique`. Als de methode bestaat in het huidige model, zal het worden gebruikt, anders zal een globale functie worden opgeroepen. Hier is een voorbeeld van z'n methode:
public function username_unique(Validate $data, $field)
{
// Logica om te controleren of de gebruikersnaam uniek is
...
}
#### `_filters`
protected $_filters = array
(
TRUE => array('trim' => array()),
'username' => array('stripslashes' => array()),
);
`TRUE` slaat erop dat de `trim` filter wordt gebruikt voor alle velden. `username` zal ook gefilterd worden door `stripslashes` vooraleer het gevalideerd wordt. De lege arrays die als values worden meegestuurd, kunnen worden gebruikt om optionele parameters mee te geven aan deze filter-functie aanroepen.
#### Controleren of een Object Valid is
Gebruik [ORM::check] om te kijken of het object momenteel valid is.
// Een object zijn values instellen en dan controleren of het valid is
if ($user->values($_POST)->check())
{
$user->save();
}
Je kan de `validate()` methode gebruiken om een model zijn validatie object aan te roepen.
// Een optionele filter manueel toevoegen
$user->validate()->filter('username', 'trim');

88
includes/kohana/modules/userguide/guide/nl/tutorials.removeindex.md Normal file
View File

@@ -0,0 +1,88 @@
# `index.php` verwijderen uit de URL
Om uw URLs proper te houden, wil je hoogtswaarschijnlijk je applicatie kunnen benaderen zonder /index.php/` in uw URL te gebruiken. Er zijn twee stappen om `index.php` te verwijderen uit de URL.
1. Het bootstrap bestand aanpassen
2. Herschrijven van URL's instellen
# Configuratie van de Bootstrap
Het eerste dat je moet veranderen is de `index_file` instelling van [Kohana::init]:
Kohana::init(array(
'base_url' => '/myapp/',
'index_file' => FALSE,
));
Nu zullen alle links die gegeneerd worden met [URL::site], [URL::base] en [HTML::anchor] niet meer "index.php" gebruiken in de URL. Alle gegenereerde links zullen starten met `/myapp/` in plaats van `/myapp/index.php/`.
# URL Herschrijven
Het herschrijven van URL kan verschillen, naargelang je web server.
## Apache
Hernoem `example.htaccess` naar `.htaccess` en verander de volgende regel code:
RewriteBase /kohana/
Dit moet gelijk zijn met de `base_url` instelling van [Kohana::init]:
RewriteBase /myapp/
In de meeste gevallen is dit het enige dat je moet veranderen.
### Er loopt iets fout!
Als je een "Internal Server Error" of "No input file specified" error krijgt, probeer dan hetvolgende te veranderen:
RewriteRule ^(?:application|modules|system)\b - [F,L]
Door enkel een slash te gebruiken:
RewriteRule ^(application|modules|system)/ - [F,L]
Als het nog steeds niet werkt, probeer dan hetvolgende te veranderen:
RewriteRule .* index.php/$0 [PT]
Naar iets simpeler:
RewriteRule .* index.php [PT]
### Nog steeds niet loopt het fout!
Als je nog steeds fouten krijgt, controleer dan zeker dat je host wel URL `mod_rewrite` ondersteund. Als je de Apache configuratie kunt aanpassen, voeg dan deze lijnen toe aan de configuratie, meestal in `httpd.conf`:
<Directory "/var/www/html/myapp">
Order allow,deny
Allow from all
AllowOverride All
</Directory>
## NGINX
Het is moeilijk om voorbeelden te geven van een nginx configuratie, maar hier is een voorbeeld voor een server:
location / {
index index.php index.html index.htm;
try_files $uri $uri/ index.php$uri?$args;
}
location ~ ^(.+\.php)(.*)$ {
fastcgi_split_path_info ^(.+\.php)(.*)$;
fastcgi_param SCRIPT_NAME $fastcgi_script_name;
fastcgi_param SCRIPT_FILENAME $document_root/$fastcgi_script_name;
fastcgi_param PATH_INFO $fastcgi_path_info;
include fastcgi.conf;
fastcgi_pass 127.0.0.1:9000;
fastcgi_index index.php;
}
Er zijn twee dingen te melden: het gebruik van [try_files](http://wiki.nginx.org/NginxHttpCoreModule#try_files) en [fastcgi_split_path_info](http://wiki.nginx.org/NginxHttpFcgiModule#fastcgi_split_path_info).
[!!] Dit in de veronderstelling dat je PHP draait als een FastCGI server op poort 9000 en dat je nginx v0.7.31 of later gebruikt.
Als je problemen hebt om dit te laten werken, zet dan het deub level logging aan in nginx en controleer de toegangs- en foutenlogs.

159
includes/kohana/modules/userguide/guide/nl/tutorials.urls.md Normal file
View File

@@ -0,0 +1,159 @@
# Routes, URLs en Links
Dit onderdeel zal je een basis idee geven achter Kohana's request routing, de generatie van url's en links.
## Routing
Zoals gezegd in de [Request Flow](about.flow) sectie, wordt een request afgehandeld door de [Request] class die een juiste [Route] vindt en de juiste controller inlaadt om het request af te handelen. Dit systeem biedt veel flexibiliteit en een logische manier van werken.
Als je kijkt in `APPPATH/bootstrap.php` zal je zien dat de volgende code onmiddelijk wordt aangeroepen vooraleer de request wordt toegewezen aan [Request::instance]:
Route::set('default', '(<controller>(/<action>(/<id>)))')
->defaults(array(
'controller' => 'welcome',
'action' => 'index',
));
Dit stelt de `default` route in voor een uri met het formaat `(<controller>(/<action>(/<id>)))`. De karakters omringd met `<>` zijn *keys* en de karakters omringd met `()` zijn optionele onderdelen van de uri. In dit geval is de gehele uri optioneel, zodat bij een lege uri de standaard controller en actie worden uitgevoerd wat ervoor zou zorgen dat de `Controller_Welcome` class wordt ingeladen en eventueel wordt de methode `action_index` aangeroepen om de request af te handelen.
Merk op dat in Kohana routes, alle karakters zijn toegestaan behalve `()<>` en de `/`, die hebben namelijk een speciale betekenis. In de standaard route wordt de "/" gebruikt als scheidingsteken, maar zolang de reguliere expressie logisch en doordacht is, kan je kiezen hoe je routes er laat uitzien.
### Folders
Om je controllers wat meer te gaan organiseren kan je ervoor kiezen om ze te plaatsen in subfolders. Een veel voorkomend geval is voor een backend van je website:
Route::set('admin', 'admin(/<controller>(/<action>(/<id>)))')
->defaults(array(
'directory' => 'admin',
'controller' => 'home',
'action' => 'index',
));
Deze route vereist dat de uri moet beginnen met `admin` en dat de folder statisch wordt toegewezen aan `admin` in de standaard instellingen van de route. Een request naar `admin/users/create` zal nu de `Controller_Admin_Users` class laden en de methode `action_create` aanroepen.
### Patronen
Het Kohana route systeem gebruikt perl compatibele reguliere expressies in zijn vergelijkings proces. Standaar worden de *keys* (omringd door `<>`) vergeleken met `[a-zA-Z0-9_]++` maar je kan je eigen patronen defini<6E>ren voor elke key door een associatieve array mee te geven als extra argument aan [Route::set] met daarin de keys and patronen. We kunnen het vorige voorbeeld uitbreiden met een admin sectie en een filialen (affliates) sectie. Je kan deze in verschillende routes specificeren of je kan iets doen zoals dit:
Route::set('sections', '<directory>(/<controller>(/<action>(/<id>)))',
array(
'directory' => '(admin|affiliate)'
))
->defaults(array(
'controller' => 'home',
'action' => 'index',
));
Dit zorgt voor twee secties van uw site, 'admin' en 'affiliate', deze laten je toe om de controllers te organiseren in subfolders voor elk maar dat ze nog steeds blijven werken als de standaard route.
### Meer Route voorbeelden
Er zijn oneindig veel andere mogelijkheden voor routes. Hier zijn er enkele:
/*
* Authenticatie
*/
Route::set('auth', '<action>',
array(
'action' => '(login|logout)'
))
->defaults(array(
'controller' => 'auth'
));
/*
* Multi-formaat feeds
* 452346/comments.rss
* 5373.json
*/
Route::set('feeds', '<user_id>(/<action>).<format>',
array(
'user_id' => '\d+',
'format' => '(rss|atom|json)',
))
->defaults(array(
'controller' => 'feeds',
'action' => 'status',
));
/*
* Statische pagina's
*/
Route::set('static', '<path>.html',
array(
'path' => '[a-zA-Z0-9_/]+',
))
->defaults(array(
'controller' => 'static',
'action' => 'index',
));
/*
* Je houdt niet van slashes?
* EditGallery:bahamas
* Watch:wakeboarding
*/
Route::set('gallery', '<action>(<controller>):<id>',
array(
'controller' => '[A-Z][a-z]++',
'action' => '[A-Z][a-z]++',
))
->defaults(array(
'controller' => 'Slideshow',
));
/*
* Vlug zoeken
*/
Route::set('search', ':<query>', array('query' => '.*'))
->defaults(array(
'controller' => 'search',
'action' => 'index',
));
Routes worden vergeleken in de gespecifieerde volgorde dus wees er van bewust dat als je routes insteld nadat de modules zijn ingeladen, een module een route kan specifi<66>ren dat voor een conflict zorgt met een route van jezelf. Dit is ook de reden waarom de standaard route als laatste wordt ingesteld, zodat zelfgeschreven routes eerst worden getest.
### Request Parameters
De directory, controller en action kunnen worden benaderd via de [Request] instantie op de volgende manieren:
$this->request->action;
Request::instance()->action;
Alle andere gespecifieerde keys in een route kunnen worden benaderd van binnenin de controller via:
$this->request->param('key_name');
De [Request::param] methode heeft een optioneel tweede argument om een standaard waarde terug te geven indien de key niet is ingesteld door de route. Indien er geen argumenten worden gegeven, worden alle keys als teruggegeven als een associatieve array.
### Conventie
De gebruikelijke conventie is je eigen routes te plaatsen in het `MODPATH/<module>/init.php` bestand van je module als de routes bij een module horen, of gewoonweg te plaatsen in het `APPPATH/bootstrap.php` bestand boven de standaard route als de routes specifiek voor de applicatie zijn. Natuurlijk kunnen ze ook worden geimporteerd vanuit een extern bestand of zelfs dynamisch gegenereerd worden.
## URLs
Naast Kohana's sterke routing mogelijkheden zitten er ook enkele methodes in om URLs te genereren voor je routes' uris. Je kan je uris altijd specificeren als een string door gebruik te maken van [URL::site] om een volledige URL te maken:
URL::site('admin/edit/user/'.$user_id);
Kohana biedt echter ook een methode om de URI genereren op basis van de route's definitie. Dit is zeer handig als je routing ooit zou veranderen omdat het je zou verlossen van om overal uw code te veranderen waar je de URI als string hebt gespecificeerd. Hier is een voorbeeld van dynamische generatie die overeenkomt met het `feeds`-route voorbeeld van hierboven:
Route::get('feeds')->uri(array(
'user_id' => $user_id,
'action' => 'comments',
'format' => 'rss'
));
Laten we zeggen dat je later zou besluiten om die route definitie meer verstaanbaar te maken door ze te veranderen in `feeds/<user_id>(/<action>).<format>`. Wanneer je je code hebt geschreven met de uri generatie methode van hierboven dan zal je niets moeten veranderen aan je code! Wanneer een deel van de URI tussen haakjes staat en waarvoor er geen waarde is meegegeven voor uri generatie en er geen standaard waarde is meegegeven in de route, dan zal dat stuk verwijderd worden van de uri. Een voorbeeld hiervan is het `(/<id>)` deel van de standaard route, dit zal niet worden opgenomen in de gegenereerde uri als er geen id is voorzien.
De methode [Request::uri] zal er <20><>n zijn dat je regelmatig zult gebruiken, het heeft dezelfde functionaliteit als hierboven maar het gaat gebruikt de huidige route, directory, controller en action. Als onze huidige route de standaard route is en de uri `users/list` is, dan kunnen we het volgende doen om uris te genereren in het formaat `users/view/$id`:
$this->request->uri(array('action' => 'view', 'id' => $user_id));
Of een meer aangeraden methode voor in een view:
Request::instance()->uri(array('action' => 'view', 'id' => $user_id));
## Links
[!!] Nog geen informatie beschikbaar.

95
includes/kohana/modules/userguide/guide/nl/using.autoloading.md Normal file
View File

@@ -0,0 +1,95 @@
# Laden van Classes
Kohana maakt dankbaar gebruik van PHP [autoloading](http://php.net/manual/language.oop5.autoload.php). Dit zorgt ervoor dat je niet [include](http://php.net/include) of [require](http://php.net/require) moet gebruiken vooraleer je de klasse kunt gebruiken. Bijvoorbeeld als je de [Cookie::set] method wilt gebruiken doe je:
Cookie::set('mycookie', 'any string value');
Of om een [Encrypt] instantie in te laten, gewoon [Encrypt::instance] aanroepen:
$encrypt = Encrypt::instance();
Classes worden ingeladen via de [Kohana::auto_load] methode, deze maakt een simpele conversie van de class naam naar de naam van het bestand:
1. Classes worden geplaatst in de `classes/` folder van het [bestandssysteem](about.filesystem)
2. Ieder underscore karakter wordt omgezet naar een slash.
2. De bestandsnaam is met kleine letters
Wanneer je een class aanroept die nog niet is ingeladen (vb. `Session_Cookie`), zal Kohana zoeken in het bestandssysteem via [Kohana::find_file] voor een bestand met de naam `classes/session/cookie.php`.
## Zelfgeschreven Autoloaders
De standaard autoloader wordt ingesteld in `application/bootstrap.php` via [spl_autoload_register](http://php.net/spl_autoload_register):
spl_autoload_register(array('Kohana', 'auto_load'));
Dit laat [Kohana::auto_load] toe om te proberen eender welke class in te laden dat nog niet bestaat wanneer de class voor het eerst wordt gebruikt.
# Transparante Class Uitbreiding {#class-extension}
Het [cascading bestandssyteem](about.filesystem) laat transparante class uitbreiding toe. Bijvoorbeeld, de class [Cookie] is gedefinieerd in `SYSPATH/classes/cookie.php` als:
class Cookie extends Kohana_Cookie {}
De standaard Kohana classes, en vele uitbreidingen, gebruiken deze manier van defini<6E>ren zodat bijna alle classes kunnen worden uitgebreid. Je kan elke class transparant uitbreiden, door een eigen class te defini<6E>ren in `APPPATH/classes/cookie.php` om je eigen methodes toe te voegen.
[!!] Je past best **nooit** bestanden aan die standaard in Kohana zitten. Maak aanpassingen aan classes altijd door ze uit te breiden om upgrade-problemen te vermijden.
Bijvoorbeeld, als je een methode wilt maken dat gecodeerde cookies maakt via de [Encrypt] class:
<?php defined('SYSPATH') or die('No direct script access.');
class Cookie extends Kohana_Cookie {
/**
* @var mixed default encryption instance
*/
public static $encryption = 'default';
/**
* Maakt een gecodeerde cookie aan.
*
* @uses Cookie::set
* @uses Encrypt::encode
*/
public static function encrypt($name, $value, $expiration = NULL)
{
$value = Encrypt::instance(Cookie::$encrpytion)->encode((string) $value);
parent::set($name, $value, $expiration);
}
/**
* Krijg de inhoud van een gecodeerde cookie.
*
* @uses Cookie::get
* @uses Encrypt::decode
*/
public static function decrypt($name, $default = NULL)
{
if ($value = parent::get($name, NULL))
{
$value = Encrypt::instance(Cookie::$encryption)->decode($value);
}
return isset($value) ? $value : $default;
}
} // End Cookie
Als je nu `Cookie::encrypt('secret', $data)` aanroept zal die een een gecodeerde cookie aanmaken die je kan decoderen met `$data = Cookie::decrypt('secret')`.
## Meerdere niveau's van uitbreidingen {#multiple-extensions}
Als je een Kohana class in een module uitbreidt, maak je best gebruik van transparante uitbreidingen. In plaats van de [Cookie] uitbreiding Kohana te laten uitbreiden, kan je `MODPATH/mymod/encrypted/cookie.php` aanmaken:
class Encrypted_Cookie extends Kohana_Cookie {
// Gebruik de encrypt() en decrypt() methodes van hierboven
}
En maak `MODPATH/mymod/cookie.php` aan:
class Cookie extends Encrypted_Cookie {}
Dit laat nog steeds toe om gebruikers hun eigen uitbreidingen te laten doen op [Cookie] zodat jouw uitbreidingen nog behouden blijven. Let wel, de volgende uitbreiding van [Cookie] zal `Encrypted_Cookie` moeten uitbreiden in plaats van `Kohana_Cookie`.

57
includes/kohana/modules/userguide/guide/nl/using.configuration.md Normal file
View File

@@ -0,0 +1,57 @@
# Algemene Configuratie
Kohana gebruikt zowel static properties als bestanden worden gebruikt voor de configuratie. Static properties zijn worden meestal gebruikt voor static classes, zoals [Cookie], [Security] en [Upload]. Bestanden worden meestal gebruikt voor objecten zoals [Database], [Encrypt] en [Session].
Static properties kunnen ingesteld worden in `APPPATH/bootstrap.php` of door [class uitbreding](using.autoloading#class-extension). Het voordeel van static properties is dat er geen extra bestanden moeten worden ingeladen. Het probleem met deze methode is dat de class ingeladen word wanneer een property is ingesteld, als je geen uitbreiding gebruikt. Echter, met gebruik van uitbreidingen worden uitbreidingen uit modules overladen. Het is aanbevolen om static property te gebruiken voor configuraties in de bootstrap.
[!!] Wanneer je opcode caching gebruikt, zoals [APC](http://php.net/apc) of [eAccelerator](http://eaccelerator.net/), dan is het inladen van classes merkbaar vermindert. Het is dan ook streng aanbevolen om opcode caching te bruiken bij *elke* website in productie, of die nu groot of klein is.
## Noodzakelijke instellingen
Bij iedere nieuwe Kohana installatie is het vereist om de [Kohana::init] instellingen aan te passen in `APPPATH/bootstrap.php`. Iedere instelling die niet specifiek is ingesteld zal de standaard instelling gebruiken. Deze instellingen kunnen aangeroepen worden en/of aangepast worden op een later tijdstip door de static property van de [Kohana] class te gebruiken. Bijvoorbeeld, om de huidige karakterset te verkrijgen lees je de [Kohana::$charset] property in.
## Veiligheids instellingen
Er zijn verschillende instellingen dat je moet veranden om Kohana veilig te maken. De belangrijkste is [Cookie::$salt], deze wordt gebruikt om een "handtekening" te maken op cookies zodat ze niet kunnen worden aangepast van buiten Kohana.
Als je de [Encrypt] class wilt gebruiken, maak je best ook een `encrypt` configuratie bestand en stel je een encryption `key` in. Deze key bevat best letters, nummers en symbolen om de veiligheid te optimaliseren.
[!!] **Gebruik geen hash als encryption key!** Indien je dit doet zal de encryption key gemakkelijker te kraken zijn.
# Configuratie bestanden {#config-files}
Configuratie bestanden zijn licht anders dan andere bestanden in het [cascading bestandssyteem](about.filesystem). Configuratie bestanden worden **gemerged** in plaats van overladen. Dit wil zeggen dat alle configuratie bestanden hetzelfde path worden gecombineerd om <20><> configuratie te vormen. Wat wil zeggen dat je *individuele* instellingen kan overladen in plaats van een volledig bestand te dupliceren.
Configuratie bestanden zijn pure PHP bestanden, opgeslaan in de `config/` folder, die een associatieve array teruggeven:
<?php defined('SYSPATH') or die('No direct script access.');
return array(
'setting' => 'value',
'options' => array(
'foo' => 'bar',
),
);
Als het bovenstaande bestand `myconf.php` werd genoemd, dan kon je deze benaderen via:
$config = Kohana::config('myconf');
$options = $config['options'];
[Kohana::config] biedt ook een shortcut om individuele keys van configuratie arrays te benaderen door gebruik te maken van "dot paths".
Verkrijg de "options" array:
$options = Kohana::config('myconf.options');
Verkrijg de "foo" key van de "options" array:
$foo = Kohana::config('myconf.options.foo');
Configuratie arrays kunnen ook worden benaderd als objecten, indien je deze manier wilt gebruiken:
$options = Kohana::config('myconf')->options;
Let wel, je kan enkel keys op het bovenste niveau aanspreken als object properties, alle lagere keys moeten benaderd worden via de standaard array syntax:
$foo = Kohana::config('myconf')->options['foo'];

26
includes/kohana/modules/userguide/guide/nl/using.messages.md Normal file
View File

@@ -0,0 +1,26 @@
# Berichten (Messages): de basis
Kohana berichten zijn mensvriendelijke stukjes tekst voorgesteld door een korter woord of zin, een "key" genaamd. Berichten worden benaderd via de [Kohana::message] methode, die <20><>n enkel of een hele groep van berichten teruggeeft.
Bijvoorbeeld, als een gebruiker niet is ingelogd en een pagina dat authenticatie vereist probeert te benaderen, dan moet een error zoals "U moet ingelogd zijn om toegang te hebben tot deze pagina" getoond worden. Dit bericht kan opgeslagen worden in het `auth` bestand met een `must_login` key:
$message = Kohana::message('auth', 'must_login');
Berichten worden niet vertaald. Om een bericht te vertalen, gebruik dan de [translation function](using.translation):
$translated = __(Kohana::message('auth', 'must_login'));
[!!] In Kohana v2 werd het berichten-systeem gebruikt voor vertalingen. Echter is het ten zeerste aanbevolen om het nieuwe vertalingssysteem te gebruiken in plaats van berichten, aangezien het leesbare tekst teruggeeft wanneer zelfs geen vertaling beschikbaar is.
## Berichten: de bestanden
Alle berichten bestanden zijn pure PHP files, opgeslaan in de `messages/` folder, die een associatieve array teruggeven:
<?php defined('SYSPATH') or die('No direct script access.');
return array(
'must_login' => 'U moet ingelogd zijn om toegang te hebben tot deze pagina',
'no_access' => 'U heeft geen bevoegdheden om deze pagina te bekijken',
);
Berichten bestanden zijn gelijkaardig aan [configuratie bestanden](using.configuration#config-files) omdat ze ook worden samengevoegd. Dit betekent dat alle berichten die opgeslaan zijn in het bestand `auth` zullen worden gecombineerd in <20><>n enkele array, het is dus niet noodzakelijk om alle berichten te kopi<70>ren wanneer je een nieuw `auth` bestand aanmaakt.

223
includes/kohana/modules/userguide/guide/nl/using.sessions.md Normal file
View File

@@ -0,0 +1,223 @@
# Gebruik van Sessies en Cookies
Kohana biedt een paar classes die het gemakkelijk maken om te werken met cookies en sessies. Op een hoog niveau, zowel sessies en cookies geven dezelfde functionaliteit. Ze laten de ontwikkelaar toe om tijdelijke of blijvende informatie over een specifieke klant voor later op te slaan.
Cookies moeten worden gebruikt voor de opslag van niet-private gegevens die persistent is voor een lange periode van tijd. Bijvoorbeeld het opslaan van een gebruikers-id of een taalvoorkeur. Gebruik de [Cookie] class voor het verkrijgen en instellen van cookies.
[!!] Kohana gebruikt "ondertekende" cookies. Elke cookie die wordt opgeslagen wordt gecombineerd met een veilige hash om een wijziging van de cookie te voorkomen. Deze hash wordt gegenereerd met behulp van [Cookie:: salt], die de [Cookie::$salt] property gebruikt. Je moet [deze instelling] (using.configuration) veranderen wanneer je applicatie live staat.
Sessies worden gebruikt voor het opslaan van tijdelijke of prive-gegevens. Zeer gevoelige gegevens moeten worden opgeslagen met behulp van de [Session] class met de "database" of "native" adapters. Bij gebruik van de "cookie"-adapter, moet de sessie altijd worden versleuteld.
[!!] Voor meer informatie over de beste manieren van werken met sessie-variabelen, zie [the seven deadly sins of sessions](http://lists.nyphp.org/pipermail/talk/2006-December/020358.html).
# Het opslaan, ophalen en verwijderen van gegevens
[Cookie] en [Session] bieden een zeer gelijkaardige API voor het opslaan van gegevens. Het belangrijkste verschil tussen hen is dat sessies benaderd kunnen worden met behulp van een object, en cookies met behulp van een statische class.
De sessie instantie benaderen wordt gedaan met de [Session::instance] methode:
// Verkrijg de sessie instantie
$session = Session::instance();
Bij het gebruik van sessies, kan je alle huidige sessiegegevens krijgen met behulp van de [Session::as_array] methode:
// Verkrijg alle sessiegegevens als een array
$data = $session->as_array();
Je kan dit ook gebruiken om de `$_SESSION` global te overladen om data te krijgen en in te stellen in verlijkbare manier zoals standaard PHP:
// Overlaad $_SESSION met sessiegegevens
$_SESSION =& $session->as_array();
// Stel de sessiegegevens in
$_SESSION[$key] = $value;
## Gegevens opslaan {#setting}
Het opslaan van sessie- of cookie-gegevens wordt gedaan met behulp van de `set`-methode:
// Sla sessiegegevens op
$session->set($key, $value);
// Sla cookiegegevens op
Cookie::set($key, $value);
// Sla een gebruikers id op
$session->set('user_id', 10);
Cookie::set('user_id', 10);
## Verkrijgen van gegevens {#getting}
Verkrijgen van sessie- of cookie-gegevens wordt gedaan met behulp van de `get`-methode:
// Verkrijg sessiegegevens
$data = $session->get($key, $default_value);
// Verkrijg cookiegegevens
$data = Cookie::get($key, $default_value);
// Verkrijg het gebruikers id
$user = $session->get('user_id');
$user = Cookie::get('user_id');
## Verwijderen van gegevens {#deleting}
Het verwijderen van sessie- of cookie-gegevens wordt gedaan met behulp van de `delete`-methode:
// Verwijderen van sessiegegevens
$session->delete($key);
// Verwijderen van cookiegegevens
Cookie::delete($key);
// Verwijder een gebruikers id
$session->delete('user_id');
Cookie::delete('user_id');
# Configuratie {#configuration}
Zowel cookies als sessies hebben verschillende configuratie-instellingen die van invloed zijn hoe gegevens worden opgeslagen. Controleer altijd deze instellingen voordat u uw applicatie live zet, omdat veel van die instellingen een rechtstreeks effect zal hebben op de veiligheid van uw applicatie.
## Cookie Instellingen {#cookie-settings}
Al de cookie instellingen worden verandert met behulp van statische properties. Je kan deze instellingen veranderen in `bootstrap.php` of door een [class extension](using.autoloading#class-extension) te gebruiken.
De meest belangrijke instelling is [Cookie::$salt], die wordt gebruikt om veilig te ondertekenen. Deze waarde zou moeten gewijzigd en geheim gehouden worden:
Cookie::$salt = 'Uw geheim is veilig bij mij';
[!!] Door het veranderen van deze waarde zullen alle bestaande cookies niet meer geldig zijn.
Standaard worden cookies bewaard tot het browservenster wordt gesloten. Om een specifieke leeftijd te gebruiken, verander de [Cookie::$expiration] instelling:
// Stel in dat cookies vervallen na <20><>n week
Cookie::$expiration = 604800;
// Alternatief voor het gebruik van getallen, voor meer duidelijkheid
Cookie::$expiration = Date::WEEK;
Het path waarvan de cookie kan worden opgevraagd kan worden beperkt met behulp van de [Cookie::$path] instelling.
// Enkel cookies toelaten wanneer je gaat naar /public/*
Cookie::$path = '/public/';
Het domein waarvan de cookie kan worden geopend kan ook worden beperkt, met behulp van de [Cookie::$domain] instelling.
// Enkel cookies toelaten voor www.example.com
Cookie::$domain = 'www.example.com';
Als u de cookie toegankelijk wilt maken op alle subdomeinen, gebruik dan een punt aan het begin van het domein.
// Cookies toegankelijk maken voor example.com en *.example.com
Cookie::$domain = '.example.com';
Als je de cookie alleen wilt kunnen benaderen via een beveiligde (HTTPS) verbinding, gebruik dan de [Cookie::$secure] instelling.
// Cookies enkel toegangekijk maken via een beveiligde verbinding
Cookie::$secure = TRUE;
// Cookies toegankelijk maken voor elke verbinding
Cookie::$secure = FALSE;
Om te voorkomen dat cookies worden geopend met behulp van Javascript, kunt u de [Cookie::$httponly] instelling aanpassen.
// Maak cookies niet toegankelijk via Javascript
Cookie::$httponly = TRUE;
## Sessie Adapters {#adapters}
Bij het maken van of het aanroepen van een instantie van de [Sessie] class kan je kiezen welke sessie adapter je wilt gebruiken. De sessie adapters die beschikbaar zijn voor je:
Native
: Slaat sessiegegevens op in de standaard locatie voor uw web server. De opslaglocatie is gedefinieerd door [session.save_path](http://php.net/manual/session.configuration.php#ini.session.save-path) in `php.ini` of gedefinieerd door [ini_set](http://php.net/ini_set).
Database
: Slaat de sessiesgegevens op in een database tabel door gebruik te maken van de [Session_Database] class. De [Database] module is vereist.
Cookie
: Slaat de sessiegegevens op in een cookie door gebruikt te maken van de [Cookie] class. **Sessies hebben een 4KB limiet wanneer je deze adapter gebruikt.**
De standaard adapter kan ingesteld worden door de waarde aan te passen van [Session::$default]. De standaard adapter is "native".
[!!] Zoals bij cookies bekent een "lifetime" instelling van "0" dat de sessie zal vervallen bij het sluiten van de het browservenster.
### Sessie Adapter Instellingen
Je kan configuratie-instellingen voor elk van de sessie adapters instellen door het cre<72>ren van een sessie configuratiebestand in `APPPATH/config/session.php`. Het volgende voorbeeld van een configuratie bestand defini<6E>ert alle instellingen voor elke adapter:
return array(
'native' => array(
'name' => 'session_name',
'lifetime' => 43200,
),
'cookie' => array(
'name' => 'cookie_name',
'encrypted' => TRUE,
'lifetime' => 43200,
),
'database' => array(
'name' => 'cookie_name',
'encrypted' => TRUE,
'lifetime' => 43200,
'group' => 'default',
'table' => 'table_name',
'columns' => array(
'session_id' => 'session_id',
'last_active' => 'last_active',
'contents' => 'contents'
),
'gc' => 500,
),
);
#### Native Adapter {#adapter-native}
Type | Instelling | Omschrijving | Standaard
----------|------------|-----------------------------------------------------|-----------
`string` | name | naam van de sessie | `"session"`
`integer` | lifetime | aantal seconden dat de sessie moet bestaan | `0`
#### Cookie Adapter {#adapter-cookie}
Type | Instelling | Omschrijving | Standaard
----------|------------|-----------------------------------------------------|-----------
`string` | name | naam van de cookie om de sessiegegevens op te slaan | `"session"`
`boolean` | encrypted | de sessiegegevens coderen met [Encrypt]? | `FALSE`
`integer` | lifetime | aantal seconden dat de sessie moet bestaan | `0`
#### Database Adapter {#adapter-database}
Type | Instelling | Omschrijving | Standaard
----------|------------|-----------------------------------------------------|-----------
`string` | group | [Database::instance] groep naam | `"default"`
`string` | table | de tabelnaam waar de gegevens worden in opgeslagen | `"sessions"`
`array` | columns | associatieve array met kolom aliassen | `array`
`integer` | gc | 1:x kans dat de garbage collection uitgevoerd wordt | `500`
`string` | name | naam van de cookie om de sessiegegevens op te slaan | `"session"`
`boolean` | encrypted | de sessiegegevens coderen met [Encrypt]? | `FALSE`
`integer` | lifetime | aantal seconden dat de sessie moet bestaan | `0`
##### Tabel Schema
Je moet de sessie-opslag tabel in de database aanmaken. Dit is het standaard schema:
CREATE TABLE `sessions` (
`session_id` VARCHAR(24) NOT NULL,
`last_active` INT UNSIGNED NOT NULL,
`contents` TEXT NOT NULL,
PRIMARY KEY (`session_id`),
INDEX (`last_active`)
) ENGINE = MYISAM;
##### Tabel kolommen
Je kunt de namen van kolommen aanpassen om overeen te komen met een bestaand database-schema. De standaard waarde is hetzelfde als de key waarde.
session_id
: de naam van de "id" kolom
last_active
: UNIX timestamp van het laatste tijdstip dat de sessie werd aangepast
contents
: sessiongegevens opgeslaan in een serialized string, en optioneel gecodeerd

118
includes/kohana/modules/userguide/guide/nl/using.views.md Normal file
View File

@@ -0,0 +1,118 @@
# Het gebruik van Views
Views zijn bestanden die de visuele informatie bevatten voor je applicatie. Dit is meestal HTML, CSS en Javascript maar kan van alles zijn die je nodig hebt zoals XML of JSON voor AJAX output. Het doel van views is om deze informatie af te scheiden van de applicatie logica zodat je nettere code hebt en deze gemakkelijker kunt hergebruiken.
Hoewel dit waar is, kunnen views zelf ook code bevatten die je gebruikt om gegevens te tonen die je meegestuurd hebt met de view. Bijvoorbeeld, het loopen door een array met producten en voor elk product een nieuwe tabelrij tonen. Views zijn nog altijd PHP bestanden dus kan je erin coderen zoals je normaal zou doen.
# Aanmaken van View bestanden
De View bestanden worden opgeslagen in de `views` folder van het [bestandssysteem](about.filesystem). Je kan ook subfolders aanmaken in de `views` folder om je bestanden meer te organiseren. Alle mogelijkheden uit de volgende voorbeelden zijn goed:
APPPATH/views/home.php
APPPATH/views/pages/about.php
APPPATH/views/products/details.php
MODPATH/error/views/errors/404.php
MODPATH/common/views/template.php
## Inladen van Views
[View] objecten worden gewoonlijk aangemaakt binnenin een [Controller] via de [View::factory] methode. De view wordt dan gewoonlijk aan de [Request::$response] property toegewezen of aan een andere view.
public function action_about()
{
$this->request->response = View::factory('pages/about');
}
Wanneer een view wordt toegewezen aan de [Request::$response], zoals in bovenstaand voorbeeld, dan zal het automatisch worden gerenderd wanneer noodzakelijk. Om het gerenderde resultaat van een view te verkrijgen kan je de [View::render] methode aanspreken of gewoon laten casten naar een string. Wanneer een view gerenderd is, wordt de view ingeladen en wordt de HTML gegenereerd.
public function action_index()
{
$view = View::factory('pages/about');
// View wordt gerenderd
$about_page = $view->render();
// Of gewoon laten casten naar een string
$about_page = (string) $view;
$this->request->response = $about_page;
}
## Variabelen in Views
Eenmaal een view is ingeladen, kunnen variabelen eraan toegewezen worden door de [View::set] en [View::bind] methodes.
public function action_roadtrip()
{
$view = View::factory('user/roadtrip')
->set('places', array('Rome', 'Paris', 'London', 'New York', 'Tokyo'));
->bind('user', $this->user);
// De view zal de variabelen $places en $user hebben
$this->request->response = $view;
}
[!!] Het enige verschil tussen `set()` en `bind()` is dat `bind()` de variabele toewijst via referentie. Als je een variabele `bind()` vooraleer ze gedefineerd is, zal de variable als `NULL` worden gecre<72>erd.
### Globale Variabelen
Een applicatie kan verschillende views hebben die toegang hebben tot dezelfde variabelen. Bijvoorbeeld, een titel van een pagina wil je zowel tonen in de header van je template als in de body van de pagina inhoud. Je kan variabelen cre<72>ren dat toegankelijk zijn in elke view dankzij de [View::set_global] en [View::bind_global] methoden.
// Wijs $page_title toe aan alle views
View::bind_global('page_title', $page_title);
Als de applicatie drie views heeft die gerenderd zijn voor de home-pagina: `template`, `template/sidebar` en `pages/home`. Eerst zal je een abstracte controller maken om de template te maken:
abstract class Controller_Website extends Controller_Template {
public $page_title;
public function before()
{
parent::before();
// Maak $page_title toegankelijk in alle views
View::bind_global('page_title', $this->page_title);
// Laad $sidebar in de template als een view
$this->template->sidebar = View::factory('template/sidebar');
}
}
Dan moet de home controller de `Controller_Website` uitbreiden:
class Controller_Home extends Controller_Website {
public function action_index()
{
$this->page_title = 'Home';
$this->template->content = View::factory('pages/home');
}
}
## Views in Views
Als je een andere view wilt gebruiken in een view heb je twee keuzes. Door [View::factory] aan te roepen kan je de opgenomen view sandboxen. Dit betekent dat je alle variabelen moet meegeven aan de view door middel van [View::set] of [View::bind]:
// Enkel de $user variabele zal toegankelijk zijn in "views/user/login.php"
<?php echo View::factory('user/login')->bind('user', $user) ?>
De andere optie is om de view rechtstreeks in te voegen, dat maakt alle huidige variabelen beschikbaar in de ingesloten view:
// Elke variabele gedefinieerd in deze view zal worden ingesloten in "views/message.php"
<?php include Kohana::find_file('views', 'user/login') ?>
Natuurlijk kan je ook een volledige [Request] inladen in een view:
<?php echo Request::factory('user/login')->execute() ?>
Dit is een voorbeeld van [HMVC](about.mvc), dit maakt het mogelijk om aanroepingen te maken en te lezen via andere URLs binnenin je applicatie.
# Upgraden van v2.x
In tegenstelling tot versie 2.x van Kohana, wordt de view niet ingeladen in de context van de [Controller], dus is het niet mogelijk om `$this` aan te spreken als controller binnenin de view. De controller doorgeven aan de view moet nu expliciet worden gedaan:
$view->bind('controller', $this);