Conventions and Coding Style

Conventions and Coding Style
     Class Names and File Location
         Examples
     Coding Standards
         Brackets
         Naming Conventions
             Classes
             Functions and Methods
             Variables
         Indentation
         String concatenation
         Single Line Statements
         Comparison Operations
         Switch structures
         Parentheses
         Ternaries
         Type Casting
         Constants
         Comments
             One-line comments
         Regular expressions

It is encouraged that you follow Kohana's coding style. This makes code more readable and allows for easier code sharing and contributing.

Class Names and File Location

Class names in Kohana follow a strict convention to facilitate autoloading. Class names should have uppercase first letters with underscores to separate words. Underscores are significant as they directly reflect the file location in the filesystem.

The following conventions apply:

  1. CamelCased class names should not be used, except when it is undesirable to create a new directory level.
  2. All class file names and directory names are lowercase.
  3. All classes should be in the classes directory. This may be at any level in the cascading filesystem.

Unlike Kohana v2.x, there is no separation between "controllers", "models", "libraries" and "helpers". All classes are placed in the "classes/" directory, regardless if they are static "helpers" or object "libraries". You can use whatever kind of class design you want: static, singleton, adapter, etc.

Examples

Remember that in a class, an underscore means a new directory. Consider the following examples:

Class Name File Path
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 Standards

In order to produce highly consistent source code, we ask that everyone follow the coding standards as closely as possible.

Brackets

Please use BSD/Allman Style bracketing. Brackets are always on their own line. The exception to this rule is the opening bracket for a class, which can be on the same line.

if ($foo == 'bar')
{
    $baz->bar();
}
else
{
    $baz->default();
}

// The opening bracket for a class can be on the same line
Class Foobar {

Naming Conventions

Kohana uses under_score naming, not camelCase naming.

Classes

// Controller class, uses Controller_ prefix
class Controller_Apple extends Controller {

// Model class, uses Model_ prefix
class Model_Cheese extends Model {

// Regular class
class Peanut {

When creating an instance of a class, don't use parentheses if you're not passing something on to the constructor:

// Correct:
$db = new Database;

// Incorrect:
$db = new Database();

Functions and Methods

Functions should be all lowercase, and use under_scores to separate words:

function drink_beverage($beverage)
{

Variables

All variables should be lowercase and use under_score, not camelCase:

// Correct:
$foo = 'bar';
$long_example = 'uses underscores';

// Incorrect:
$weDontWantThis = 'understood?';

Indentation

You must use tabs to indent your code. Using spaces for tabbing is strictly forbidden.

Vertical spacing (for multi-line) is done with spaces. Tabs are not good for vertical alignment because different people have different tab widths.

$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 concatenation

Do not put spaces around the concatenation operator:

// Correct:
$str = 'one'.$var.'two';

// Incorrect:
$str = 'one'. $var .'two';
$str = 'one' . $var . 'two';

Single Line Statements

Single-line IF statements should only be used when breaking normal execution (e.g. return or continue):

// Acceptable:
if ($foo == $bar)
    return $foo;

if ($foo == $bar)
    continue;

if ($foo == $bar)
    break;

if ($foo == $bar)
    throw new Exception('You screwed up!');

// Not acceptable:
if ($baz == $bun)
    $baz = $bar + 2;

Comparison Operations

Please use OR and AND for comparison:

// Correct:
if (($foo AND $bar) OR ($b AND $c))

// Incorrect:
if (($foo && $bar) || ($b && $c))

Please use elseif, not else if:

// Correct:
elseif ($bar)

// Incorrect:
else if($bar)

Switch structures

Each case, break and default should be on a separate line. The block inside a case or default must be indented by 1 tab.

switch ($var)
{
    case 'bar':
    case 'foo':
        echo 'hello';
    break;
    case 1:
        echo 'one';
    break;
    default:
        echo 'bye';
    break;
}

Parentheses

There should be one space after statement name, followed by a parenthesis. The ! (bang) character must have a space on either side to ensure maximum readability. Except in the case of a bang or type casting, there should be no whitespace after an opening parenthesis or before a closing parenthesis.

// Correct:
if ($foo == $bar)
if ( ! $foo)

// Incorrect:
if($foo == $bar)
if(!$foo)
if ((int) $foo)
if ( $foo == $bar )
if (! $foo)

Ternaries

All ternary operations should follow a standard format. Use parentheses around expressions only, not around just variables.

$foo = ($bar == $foo) ? $foo : $bar;
$foo = $bar ? $foo : $bar;

All comparisons and operations must be done inside of a parentheses group:

$foo = ($bar > 5) ? ($bar + $foo) : strlen($bar);

When separating complex ternaries (ternaries where the first part goes beyond ~80 chars) into multiple lines, spaces should be used to line up operators, which should be at the front of the successive lines:

$foo = ($bar == $foo)
     ? $foo
     : $bar;

Type Casting

Type casting should be done with spaces on each side of the cast:

// Correct:
$foo = (string) $bar;
if ( (string) $bar)

// Incorrect:
$foo = (string)$bar;

When possible, please use type casting instead of ternary operations:

// Correct:
$foo = (bool) $bar;

// Incorrect:
$foo = ($bar == TRUE) ? TRUE : FALSE;

When casting type to integer or boolean, use the short format:

// Correct:
$foo = (int) $bar;
$foo = (bool) $bar;

// Incorrect:
$foo = (integer) $bar;
$foo = (boolean) $bar;

Constants

Always use uppercase for constants:

// Correct:
define('MY_CONSTANT', 'my_value');
$a = TRUE;
$b = NULL;

// Incorrect:
define('MyConstant', 'my_value');
$a = True;
$b = null;

Place constant comparisons at the end of tests:

// Correct:
if ($foo !== FALSE)

// Incorrect:
if (FALSE !== $foo)

This is a slightly controversial choice, so I will explain the reasoning. If we were to write the previous example in plain English, the correct example would read:

if variable $foo is not exactly FALSE

And the incorrect example would read:

if FALSE is not exactly variable $foo

Since we are reading left to right, it simply doesn't make sense to put the constant first.

Comments

One-line comments

Use //, preferably above the line of code you're commenting on. Leave a space after it and start with a capital. Never use #.

// Correct

//Incorrect
// incorrect
# Incorrect

Regular expressions

When coding regular expressions please use PCRE rather than the POSIX flavor. PCRE is considered more powerful and faster.

// Correct:
if (preg_match('/abc/i', $str))

// Incorrect:
if (eregi('abc', $str))

Use single quotes around your regular expressions rather than double quotes. Single-quoted strings are more convenient because of their simplicity. Unlike double-quoted strings they don't support variable interpolation nor integrated backslash sequences like \n or \t, etc.

// Correct:
preg_match('/abc/', $str);

// Incorrect:
preg_match("/abc/", $str);

When performing a regular expression search and replace, please use the $n notation for backreferences. This is preferred over \n.

// Correct:
preg_replace('/(\d+) dollar/', '$1 euro', $str);

// Incorrect:
preg_replace('/(\d+) dollar/', '\\1 euro', $str);

Finally, please note that the $ character for matching the position at the end of the line allows for a following newline character. Use the D modifier to fix this if needed. More info.

$str = "[email protected]\n";

preg_match('/^.+@.+$/', $str);  // TRUE
preg_match('/^.+@.+$/D', $str); // FALSE