Kohana 3.0.6 (sumar hiti) CheatSheet

Designation: <item> — static property/method; # <item> — protected property/method

arr
methods
binary_search
close

Arr::binary_search(mixed $needle, array $haystack, boolean $sort = bool FALSE)

Binary search algorithm.

callback
close

Arr::callback(string $str)

Creates a callable function and parameter list from a string representation. Note that this function does not validate the callback string.

// Get the callback function and parameters
list($func, $params) = Arr::callback('Foo::bar(apple,orange)');

// Get the result of the callback
$result = call_user_func_array($func, $params);
extract
close

Arr::extract(array $array, array $keys, mixed $default = NULL)

Retrieves multiple keys from an array. If the key does not exist in the array, the default value will be added instead.

// Get the values "username", "password" from $_POST
$auth = Arr::extract($_POST, array('username', 'password'));
flatten
close

Arr::flatten(array $array)

Convert a multi-dimensional array into a single-dimensional array.

$array = array('set' => array('one' => 'something'), 'two' => 'other');

// Flatten the array
$array = Arr::flatten($array);

// The array will now be
array('one' => 'something', 'two' => 'other');

The keys of array values will be discarded.

get
close

Arr::get(array $array, string $key, mixed $default = NULL)

Retrieve a single key from an array. If the key does not exist in the array, the default value will be returned instead.

// Get the value "username" from $_POST, if it exists
$username = Arr::get($_POST, 'username');

// Get the value "sorting" from $_GET, if it exists
$sorting = Arr::get($_GET, 'sorting');
is_assoc
close

Arr::is_assoc(array $array)

Tests if an array is associative or not.

// Returns TRUE
Arr::is_assoc(array('username' => 'john.doe'));

// Returns FALSE
Arr::is_assoc('foo', 'bar');
map
close

Arr::map(mixed $callback, array $array)

Recursive version of array_map, applies the same callback to all elements in an array, including sub-arrays.

// Apply "strip_tags" to every element in the array
$array = Arr::map('strip_tags', $array);

Unlike array_map, this method requires a callback and will only map a single array.

merge
close

Arr::merge(array $a1, array $a2)

Merges one or more arrays recursively and preserves all keys. Note that this does not work the same as array_merge_recursive!

$john = array('name' => 'john', 'children' => array('fred', 'paul', 'sally', 'jane'));
$mary = array('name' => 'mary', 'children' => array('jane'));

// John and Mary are married, merge them together
$john = Arr::merge($john, $mary);

// The output of $john will now be:
array('name' => 'mary', 'children' => array('fred', 'paul', 'sally', 'jane'))
overwrite
close

Arr::overwrite(array $array1, array $array2)

Overwrites an array with values from input arrays. Keys that do not exist in the first array will not be added!

$a1 = array('name' => 'john', 'mood' => 'happy', 'food' => 'bacon');
$a2 = array('name' => 'jack', 'food' => 'tacos', 'drink' => 'beer');

// Overwrite the values of $a1 with $a2
$array = Arr::overwrite($a1, $a2);

// The output of $array will now be:
array('name' => 'jack', 'mood' => 'happy', 'food' => 'bacon')
path
close

Arr::path(array $array, string $path, mixed $default = NULL)

Gets a value from an array using a dot separated path.

// Get the value of $array['foo']['bar']
$value = Arr::path($array, 'foo.bar');

Using a wildcard "*" will search intermediate arrays and return an array.

// Get the values of "color" in theme
$colors = Arr::path($array, 'theme.*.color');
range
close

Arr::range(integer $step = integer 10, integer $max = integer 100)

Fill an array with a range of numbers.

// Fill an array with values 5, 10, 15, 20
$values = Arr::range(5, 20);
unshift
close

Arr::unshift(array $array, string $key, mixed $val)

Adds a value to the beginning of an associative array.

// Add an empty value to the start of a select list
Arr::unshift_assoc($array, 'none', 'Select a value');
cli
methods
options
close

CLI::options(string $options)

Returns one or more command-line options. Options are specified using standard CLI syntax:

php index.php --username "john.smith" --password "secret"

// Get the values of "username" and "password"
$auth = CLI::options('username', 'password');
cookie
properties
domain
close

Cookie::domain

Restrict the domain that the cookie is available to
expiration
close

Cookie::expiration

Number of seconds before the cookie expires
httponly
close

Cookie::httponly

Only transmit cookies over HTTP, disabling Javascript access
path
close

Cookie::path

Restrict the path that the cookie is available to
salt
close

Cookie::salt

Magic salt to add to the cookie
secure
close

Cookie::secure

Only transmit cookies over secure connections
methods
delete
close

Cookie::delete(string $name)

Deletes a cookie by making the value NULL and expiring it.

Cookie::delete('theme');
get
close

Cookie::get(string $key, mixed $default = NULL)

Gets the value of a signed cookie. Cookies without signatures will not be returned. If the cookie signature is present, but invalid, the cookie will be deleted.

// Get the "theme" cookie, or use "blue" if the cookie does not exist
$theme = Cookie::get('theme', 'blue');
salt
close

Cookie::salt(string $name, string $value)

Generates a salt string for a cookie based on the name and value.

$salt = Cookie::salt('theme', 'red');
set
close

Cookie::set(string $name, string $value, integer $expiration = NULL)

Sets a signed cookie. Note that all cookie values must be strings and no automatic serialization will be performed!

// Set the "theme" cookie
Cookie::set('theme', 'red');
date
methods
adjust
close

Date::adjust(integer $hour, string $ampm)

Adjusts a non-24-hour number into a 24-hour number.

$hour = Date::adjust(3, 'pm'); // 15
ampm
close

Date::ampm(integer $hour)

Returns AM or PM, based on a given hour (in 24 hour format).

$type = Date::ampm(12); // PM
$type = Date::ampm(1);  // AM
days
close

Date::days(integer $month, integer $year = bool FALSE)

Number of days in a given month and year. Typically used as a shortcut for generating a list that can be used in a form.

Date::days(4, 2010); // 1, 2, 3, ..., 28, 29, 30
dos2unix
close

Date::dos2unix(integer $timestamp = bool FALSE)

Converts a DOS timestamp to UNIX format.There are very few cases where this is needed, but some binary formats use it (eg: zip files.) Converting the other direction is done using {@link Date::unix2dos}.

$unix = Date::dos2unix($dos);
fuzzy_span
close

Date::fuzzy_span(integer $timestamp)

Returns the difference between a time and now in a "fuzzy" way. Note that unlike Date::span, the "local" timestamp will always be the current time. Displaying a fuzzy time instead of a date is usually faster to read and understand.

$span = Date::fuzzy_span(time() - 10); // "moments ago"
$span = Date::fuzzy_span(time() + 20); // "in moments"
hours
close

Date::hours(integer $step = integer 1, boolean $long = bool FALSE, integer $start = NULL)

Number of hours in a day. Typically used as a shortcut for generating a list that can be used in a form.

$hours = Date::hours(); // 01, 02, 03, ..., 10, 11, 12
minutes
close

Date::minutes(integer $step = integer 5)

Number of minutes in an hour, incrementing by a step. Typically used as a shortcut for generating a list that can be used in a form.

$minutes = Date::minutes(); // 05, 10, 15, ..., 50, 55, 60
months
close

Date::months()

Number of months in a year. Typically used as a shortcut for generating a list that can be used in a form.

Date::months(); // 01, 02, 03, ..., 10, 11, 12
offset
close

Date::offset(string $remote, string $local = NULL, mixed $now = NULL)

Returns the offset (in seconds) between two time zones. Use this to display dates to users in different time zones.

$seconds = Date::offset('America/Chicago', 'GMT');

A list of time zones that PHP supports can be found at http://php.net/timezones.

seconds
close

Date::seconds(integer $step = integer 1, integer $start = integer 0, integer $end = integer 60)

Number of seconds in a minute, incrementing by a step. Typically used as a shortcut for generating a list that can used in a form.

$seconds = Date::seconds(); // 01, 02, 03, ..., 58, 59, 60
span
close

Date::span(integer $remote, integer $local = NULL, string $output = string(45) "years,months,weeks,days,hours,minutes,seconds")

Returns time difference between two timestamps, in human readable format. If the second timestamp is not given, the current time will be used. Also consider using Date::fuzzy_span when displaying a span.

$span = Date::span(60, 182, 'minutes,seconds'); // array('minutes' => 2, 'seconds' => 2)
$span = Date::span(60, 182, 'minutes'); // 2
unix2dos
close

Date::unix2dos(integer $timestamp = bool FALSE)

Converts a UNIX timestamp to DOS format. There are very few cases where this is needed, but some binary formats use it (eg: zip files.) Converting the other direction is done using {@link Date::dos2unix}.

$dos = Date::unix2dos($unix);
years
close

Date::years(integer $start = bool FALSE, integer $end = bool FALSE)

Returns an array of years between a starting and ending year. By default, the the current year - 5 and current year + 5 will be used. Typically used as a shortcut for generating a list that can be used in a form.

$years = Date::years(2000, 2010); // 2000, 2001, ..., 2009, 2010
encrypt
properties
default
close

Encrypt::default

default instance name
instances
close

Encrypt::instances

Encrypt class instances
methods
decode
close

Encrypt::decode(string $data)

Decrypts an encoded string back to its original value.

$data = $encrypt->decode($data);
encode
close

Encrypt::encode(string $data)

Encrypts a string and returns an encrypted string that can be decoded.

$data = $encrypt->encode($data);

The encrypted binary data is encoded using base64 to convert it to a string. This string can be stored in a database, displayed, and passed using most other means without corruption.

instance
close

Encrypt::instance(string $name = NULL)

Returns a singleton instance of Encrypt. An encryption key must be provided in your "encrypt" configuration file.

$encrypt = Encrypt::instance();
feed
methods
create
close

Feed::create(array $info, array $items, string $format = string(4) "rss2", string $encoding = string(5) "UTF-8")

Creates a feed from the given parameters.

parse
close

Feed::parse(string $feed, integer $limit = integer 0)

Parses a remote feed into an array.

file
methods
join
close

File::join(string $filename)

Join a split file into a whole file. Does the reverse of File::split.

$count = File::join($file);
mime
close

File::mime(string $filename)

Attempt to get the mime type from a file. This method is horribly unreliable, due to PHP being horribly unreliable when it comes to determining the mime type of a file.

$mime = File::mime($file);
mime_by_ext
close

File::mime_by_ext(string $extension)

Return the mime type of an extension.

$mime = File::mime_by_ext('png'); // "image/png"
split
close

File::split(string $filename, string $piece_size = integer 10)

Split a file into pieces matching a specific size. Used when you need to split large files into smaller pieces for easy transmission.

$count = File::split($file);
form
methods
button
close

Form::button(string $name, string $body, array $attributes = NULL)

Creates a button form input. Note that the body of a button is NOT escaped, to allow images and other HTML to be used.

echo Form::button('save', 'Save Profile', array('type' => 'submit'));
checkbox
close

Form::checkbox(string $name, string $value = NULL, boolean $checked = bool FALSE, array $attributes = NULL)

Creates a checkbox form input.

echo Form::checkbox('remember_me', 1, (bool) $remember);
close
close

Form::close()

Creates the closing form tag.

echo Form::close();
file
close

Form::file(string $name, array $attributes = NULL)

Creates a file upload form input. No input value can be specified.

echo Form::file('image');
hidden
close

Form::hidden(string $name, string $value = NULL, array $attributes = NULL)

Creates a hidden form input.

echo Form::hidden('csrf', $token);
image
close

Form::image(string $name, string $value, array $attributes = NULL)

Creates a image form input.

echo Form::image(NULL, NULL, array('src' => 'media/img/login.png'));
input
close

Form::input(string $name, string $value = NULL, array $attributes = NULL)

Creates a form input. If no type is specified, a "text" type input will be returned.

echo Form::input('username', $username);
label
close

Form::label(string $input, string $text = NULL, array $attributes = NULL)

Creates a form label. Label text is not automatically translated.

echo Form::label('username', 'Username');
open
close

Form::open(string $action = NULL, array $attributes = NULL)

Generates an opening HTML form tag.

// Form will submit back to the current page using POST
echo Form::open();

// Form will submit to 'search' using GET
echo Form::open('search', array('method' => 'get'));

// When "file" inputs are present, you must include the "enctype"
echo Form::open(NULL, array('enctype' => 'multipart/form-data'));
password
close

Form::password(string $name, string $value = NULL, array $attributes = NULL)

Creates a password form input.

echo Form::password('password');
radio
close

Form::radio(string $name, string $value = NULL, boolean $checked = bool FALSE, array $attributes = NULL)

Creates a radio form input.

echo Form::radio('like_cats', 1, $cats);
echo Form::radio('like_cats', 0, ! $cats);
select
close

Form::select(string $name, array $options = NULL, string $selected = NULL, array $attributes = NULL)

Creates a select form input.

echo Form::select('country', $countries, $country);
submit
close

Form::submit(string $name, string $value, array $attributes = NULL)

Creates a submit form input.

echo Form::submit(NULL, 'Login');
textarea
close

Form::textarea(string $name, string $body = string(0) "", array $attributes = NULL, boolean $double_encode = bool TRUE)

Creates a textarea form input.

echo Form::textarea('about', $about);
fragment
properties
i18n
close

Fragment::i18n

use multilingual fragment support?
lifetime
close

Fragment::lifetime

default number of seconds to cache for
methods
# _cache_key
close

Fragment::_cache_key(string $name, boolean $i18n = NULL)

Generate the cache key name for a fragment.

$key = Fragment::_cache_key('footer', TRUE);
delete
close

Fragment::delete(string $name, boolean $i18n = NULL)

Delete a cached fragment.

Fragment::delete($key);
load
close

Fragment::load(string $name, integer $lifetime = NULL, boolean $i18n = NULL)

Load a fragment from cache and display it. Multiple fragments can be nested with different life times.

if ( ! Fragment::load('footer')) {
    // Anything that is echo'ed here will be saved
    Fragment::save();
}
save
close

Fragment::save()

Saves the currently open fragment in the cache.

Fragment::save();
html
properties
attribute_order
close

HTML::attribute_order

preferred order of attributes
windowed_urls
close

HTML::windowed_urls

automatically target external URLs to a new window?
methods
anchor
close

HTML::anchor(string $uri, string $title = NULL, array $attributes = NULL, string $protocol = NULL)

Create HTML link anchors. Note that the title is not escaped, to allow HTML elements within links (images, etc).

echo HTML::anchor('/user/profile', 'My Profile');
attributes
close

HTML::attributes(array $attributes = NULL)

Compiles an array of HTML attributes into an attribute string. Attributes will be sorted using HTML::$attribute_order for consistency.

echo '<div'.HTML::attributes($attrs).'>'.$content.'</div>';
chars
close

HTML::chars(string $value, boolean $double_encode = bool TRUE)

Convert special characters to HTML entities. All untrusted content should be passed through this method to prevent XSS injections.

echo HTML::chars($username);
email
close

HTML::email(string $email)

Generates an obfuscated version of an email address. Helps prevent spam robots from finding email addresses.

echo HTML::email($address);
entities
close

HTML::entities(string $value, boolean $double_encode = bool TRUE)

Convert all applicable characters to HTML entities. All characters that cannot be represented in HTML with the current character set will be converted to entities.

echo HTML::entities($username);
file_anchor
close

HTML::file_anchor(string $file, string $title = NULL, array $attributes = NULL, string $protocol = NULL)

Creates an HTML anchor to a file. Note that the title is not escaped, to allow HTML elements within links (images, etc).

echo HTML::file_anchor('media/doc/user_guide.pdf', 'User Guide');
image
close

HTML::image(string $file, array $attributes = NULL, $index = bool FALSE)

Creates a image link.

echo HTML::image('media/img/logo.png', array('alt' => 'My Company'));
mailto
close

HTML::mailto(string $email, string $title = NULL, array $attributes = NULL)

Creates an email (mailto:) anchor. Note that the title is not escaped, to allow HTML elements within links (images, etc).

echo HTML::mailto($address);
obfuscate
close

HTML::obfuscate(string $string)

Generates an obfuscated version of a string. Text passed through this method is less likely to be read by web crawlers and robots, which can be helpful for spam prevention, but can prevent legitimate robots from reading your content.

echo HTML::obfuscate($text);
script
close

HTML::script(string $file, array $attributes = NULL, boolean $index = bool FALSE)

Creates a script link.

echo HTML::script('media/js/jquery.min.js');
style
close

HTML::style(string $file, array $attributes = NULL, boolean $index = bool FALSE)

Creates a style sheet link element.

echo HTML::style('media/css/screen.css');
i18n
properties
lang
close

I18n::lang

target language: en-us, es-es, zh-cn, etc
methods
get
close

I18n::get(string $string)

Returns translation of a string. If no translation exists, the original string will be returned. No parameters are replaced.

$hello = I18n::get('Hello friends, my name is :name');
lang
close

I18n::lang(string $lang = NULL)

Get and set the target language.

// Get the current language
$lang = I18n::lang();

// Change the current language to Spanish
I18n::lang('es-es');
load
close

I18n::load(string $lang)

Returns the translation table for a given language.

// Get all defined Spanish messages
$messages = I18n::load('es-es');
inflector
methods
camelize
close

Inflector::camelize(string $str)

Makes a phrase camel case. Spaces and underscores will be removed.

$str = Inflector::camelize('mother cat');     // "motherCat"
$str = Inflector::camelize('kittens in bed'); // "kittensInBed"
humanize
close

Inflector::humanize(string $str)

Makes an underscored or dashed phrase human-readable.

$str = Inflector::humanize('kittens-are-cats'); // "kittens are cats"
$str = Inflector::humanize('dogs_as_well');     // "dogs as well"
plural
close

Inflector::plural(string $str, $count = NULL)

Makes a singular word plural.

echo Inflector::plural('fish'); // "fish", uncountable
echo Inflector::plural('cat');  // "cats"

You can also provide the count to make inflection more intelligent. In this case, it will only return the plural value if the count is not one.

echo Inflector::singular('cats', 3); // "cats"

Special inflections are defined in config/inflector.php.

singular
close

Inflector::singular(string $str, integer $count = NULL)

Makes a plural word singular.

echo Inflector::singular('cats'); // "cat"
echo Inflector::singular('fish'); // "fish", uncountable

You can also provide the count to make inflection more intelligent. In this case, it will only return the singular value if the count is greater than one and not zero.

echo Inflector::singular('cats', 2); // "cats"

Special inflections are defined in config/inflector.php.

uncountable
close

Inflector::uncountable(string $str)

Checks if a word is defined as uncountable. An uncountable word has a single form. For instance, one "fish" and many "fish", not "fishes".

Inflector::uncountable('fish'); // TRUE
Inflector::uncountable('cat');  // FALSE

If you find a word is being pluralized improperly, it has probably not been defined as uncountable in config/inflector.php. If this is the case, please report an issue.

underscore
close

Inflector::underscore(string $str)

Makes a phrase underscored instead of spaced.

$str = Inflector::underscore('five cats'); // "five_cats";
kohana_config
methods
attach
close

Kohana_Config::attach(object $reader, boolean $first = bool TRUE)

Attach a configuration reader. By default, the reader will be added as the first used reader. However, if the reader should be used only when all other readers fail, use FALSE for the second parameter.

$config->attach($reader);        // Try first
$config->attach($reader, FALSE); // Try last
copy
close

Kohana_Config::copy(string $group)

Copy one configuration group to all of the other readers.

$config->copy($name);
detach
close

Kohana_Config::detach(object $reader)

Detach a configuration reader.

$config->detach($reader);
instance
close

Kohana_Config::instance()

Get the singleton instance of Kohana_Config.

$config = Kohana_Config::instance();
load
close

Kohana_Config::load(string $group)

Load a configuration group. Searches the readers in order until the group is found. If the group does not exist, an empty configuration array will be loaded using the first reader.

$array = $config->load($name);
kohana_core
properties
base_url
close

Kohana_Core::base_url

base URL to the application
cache_dir
close

Kohana_Core::cache_dir

cache directory
caching
close

Kohana_Core::caching

enabling internal caching?
charset
close

Kohana_Core::charset

character set of input and output
config
close

Kohana_Core::config

config object
environment
close

Kohana_Core::environment

current environment name
errors
close

Kohana_Core::errors

enable error handling?
index_file
close

Kohana_Core::index_file

application index file
is_cli
close

Kohana_Core::is_cli

command line environment?
is_windows
close

Kohana_Core::is_windows

Windows environment?
log
close

Kohana_Core::log

logging object
log_errors
close

Kohana_Core::log_errors

log errors and exceptions?
magic_quotes
close

Kohana_Core::magic_quotes

magic quotes enabled?
php_errors
close

Kohana_Core::php_errors

PHP error code => human readable name
profiling
close

Kohana_Core::profiling

enable core profiling?
shutdown_errors
close

Kohana_Core::shutdown_errors

types of errors to display at shutdown
methods
# _dump
close

Kohana_Core::_dump(mixed $var, integer $length = integer 128, integer $level = integer 0)

Helper for Kohana::dump(), handles recursion in arrays and objects.

auto_load
close

Kohana_Core::auto_load(string $class)

Provides auto-loading support of Kohana classes, as well as transparent extension of classes that have a _Core suffix.

Class names are converted to file names by making the class name lowercase and converting underscores to slashes:

// Loads classes/my/class/name.php
Kohana::auto_load('My_Class_Name');
cache
close

Kohana_Core::cache(string $name, mixed $data = NULL, integer $lifetime = integer 60)

Provides simple file-based caching for strings and arrays:

// Set the "foo" cache
Kohana::cache('foo', 'hello, world');

// Get the "foo" cache
$foo = Kohana::cache('foo');

All caches are stored as PHP code, generated with var_export. Caching objects may not work as expected. Storing references or an object or array that has recursion will cause an E_FATAL.

config
close

Kohana_Core::config(string $group)

Creates a new configuration object for the requested group.

debug
close

Kohana_Core::debug()

Returns an HTML string of debugging information about any number of variables, each wrapped in a "pre" tag:

// Displays the type and value of each variable
echo Kohana::debug($foo, $bar, $baz);
debug_path
close

Kohana_Core::debug_path(string $file)

Removes application, system, modpath, or docroot from a filename, replacing them with the plain text equivalents. Useful for debugging when you want to display a shorter path.

// Displays SYSPATH/classes/kohana.php
echo Kohana::debug_path(Kohana::find_file('classes', 'kohana'));
debug_source
close

Kohana_Core::debug_source(string $file, integer $line_number, integer $padding = integer 5)

Returns an HTML string, highlighting a specific line of a file, with some number of lines padded above and below.

// Highlights the current line of the current file
echo Kohana::debug_source(__FILE__, __LINE__);
deinit
close

Kohana_Core::deinit()

Cleans up the environment:

  • Restore the previous error and exception handlers
  • Destroy the Kohana::$log and Kohana::$config objects
dump
close

Kohana_Core::dump(mixed $value, integer $length = integer 128)

Returns an HTML string of information about a single variable.

Borrows heavily on concepts from the Debug class of Nette.

error_handler
close

Kohana_Core::error_handler()

PHP error handler, converts all errors into ErrorExceptions. This handler respects error_reporting settings.

exception_handler
close

Kohana_Core::exception_handler(object $e)

Inline exception handler, displays the error message, source of the exception, and the stack trace of the error.

exception_text
close

Kohana_Core::exception_text(object $e)

Get a single line of text representing the exception:

Error [ Code ]: Message ~ File [ Line ]

find_file
close

Kohana_Core::find_file(string $dir, string $file, string $ext = NULL, boolean $array = bool FALSE)

Finds the path of a file by directory, filename, and extension. If no extension is given, the default EXT extension will be used.

When searching the "config" or "i18n" directories, or when the $aggregate_files flag is set to true, an array of files will be returned. These files will return arrays which must be merged together.

// Returns an absolute path to views/template.php
Kohana::find_file('views', 'template');

// Returns an absolute path to media/css/style.css
Kohana::find_file('media', 'css/style', 'css');

// Returns an array of all the "mimes" configuration file
Kohana::find_file('config', 'mimes');
globals
close

Kohana_Core::globals()

Reverts the effects of the register_globals PHP setting by unsetting all global varibles except for the default super globals (GPCS, etc).

if (ini_get('register_globals'))
{
    Kohana::globals();
}
include_paths
close

Kohana_Core::include_paths()

Returns the the currently active include paths, including the application and system paths.

init
close

Kohana_Core::init(array $settings = NULL)

Initializes the environment:

  • Disables register_globals and magic_quotes_gpc
  • Determines the current environment
  • Set global settings
  • Sanitizes GET, POST, and COOKIE variables
  • Converts GET, POST, and COOKIE variables to the global character set

Any of the global settings can be set here:

Type Setting Description Default Value
boolean errors use internal error and exception handling? TRUE
boolean profile do internal benchmarking? TRUE
boolean caching cache the location of files between requests? FALSE
string charset character set used for all input and output "utf-8"
string base_url set the base URL for the application "/"
string index_file set the index.php file name "index.php"
string cache_dir set the cache directory path APPPATH."cache"
list_files
close

Kohana_Core::list_files(string $directory = NULL, array $paths = NULL)

Recursively finds all of the files in the specified directory.

$views = Kohana::list_files('views');
load
close

Kohana_Core::load(string $file)

Loads a file within a totally empty scope and returns the output:

$foo = Kohana::load('foo.php');
message
close

Kohana_Core::message(string $file, string $path = NULL, mixed $default = NULL)

Get a message from a file. Messages are arbitary strings that are stored in the messages/ directory and reference by a key. Translation is not performed on the returned values.

// Get "username" from messages/text.php
$username = Kohana::message('text', 'username');
modules
close

Kohana_Core::modules(array $modules = NULL)

Changes the currently enabled modules. Module paths may be relative or absolute, but must point to a directory:

Kohana::modules(array('modules/foo', MODPATH.'bar'));
sanitize
close

Kohana_Core::sanitize(mixed $value)

Recursively sanitizes an input variable:

  • Strips slashes if magic quotes are enabled
  • Normalizes all newlines to LF
shutdown_handler
close

Kohana_Core::shutdown_handler()

Catches errors that are not caught by the error handler, such as E_PARSE.

trace
close

Kohana_Core::trace(string $trace = NULL)

Returns an array of HTML strings that represent each step in the backtrace.

// Displays the entire current backtrace
echo implode('<br/>', Kohana::trace());
kohana_log
properties
timestamp
close

Kohana_Log::timestamp

timestamp format
timezone
close

Kohana_Log::timezone

timezone for dates logged
methods
add
close

Kohana_Log::add(string $type, string $message, array $values = NULL)

Adds a message to the log. Replacement values must be passed in to be replaced using strtr.

$log->add('error', 'Could not locate user: :user', array(
    ':user' => $username,
));
attach
close

Kohana_Log::attach(object $writer, array $types = NULL)

Attaches a log writer, and optionally limits the types of messages that will be written by the writer.

$log->attach($writer);
detach
close

Kohana_Log::detach(object $writer)

Detaches a log writer. The same writer object must be used.

$log->detach($writer);
instance
close

Kohana_Log::instance()

Get the singleton instance of this class and enable writing at shutdown.

$log = Kohana_Log::instance();
write
close

Kohana_Log::write()

Write and clear all of the messages.

$log->write();
kohana
properties
base_url
close

Kohana::base_url

base URL to the application
cache_dir
close

Kohana::cache_dir

cache directory
caching
close

Kohana::caching

enabling internal caching?
charset
close

Kohana::charset

character set of input and output
config
close

Kohana::config

config object
environment
close

Kohana::environment

current environment name
errors
close

Kohana::errors

enable error handling?
index_file
close

Kohana::index_file

application index file
is_cli
close

Kohana::is_cli

command line environment?
is_windows
close

Kohana::is_windows

Windows environment?
log
close

Kohana::log

logging object
log_errors
close

Kohana::log_errors

log errors and exceptions?
magic_quotes
close

Kohana::magic_quotes

magic quotes enabled?
php_errors
close

Kohana::php_errors

PHP error code => human readable name
profiling
close

Kohana::profiling

enable core profiling?
shutdown_errors
close

Kohana::shutdown_errors

types of errors to display at shutdown
methods
# _dump
close

Kohana::_dump(mixed $var, integer $length = integer 128, integer $level = integer 0)

Helper for Kohana::dump(), handles recursion in arrays and objects.

auto_load
close

Kohana::auto_load(string $class)

Provides auto-loading support of Kohana classes, as well as transparent extension of classes that have a _Core suffix.

Class names are converted to file names by making the class name lowercase and converting underscores to slashes:

// Loads classes/my/class/name.php
Kohana::auto_load('My_Class_Name');
cache
close

Kohana::cache(string $name, mixed $data = NULL, integer $lifetime = integer 60)

Provides simple file-based caching for strings and arrays:

// Set the "foo" cache
Kohana::cache('foo', 'hello, world');

// Get the "foo" cache
$foo = Kohana::cache('foo');

All caches are stored as PHP code, generated with var_export. Caching objects may not work as expected. Storing references or an object or array that has recursion will cause an E_FATAL.

config
close

Kohana::config(string $group)

Creates a new configuration object for the requested group.

debug
close

Kohana::debug()

Returns an HTML string of debugging information about any number of variables, each wrapped in a "pre" tag:

// Displays the type and value of each variable
echo Kohana::debug($foo, $bar, $baz);
debug_path
close

Kohana::debug_path(string $file)

Removes application, system, modpath, or docroot from a filename, replacing them with the plain text equivalents. Useful for debugging when you want to display a shorter path.

// Displays SYSPATH/classes/kohana.php
echo Kohana::debug_path(Kohana::find_file('classes', 'kohana'));
debug_source
close

Kohana::debug_source(string $file, integer $line_number, integer $padding = integer 5)

Returns an HTML string, highlighting a specific line of a file, with some number of lines padded above and below.

// Highlights the current line of the current file
echo Kohana::debug_source(__FILE__, __LINE__);
deinit
close

Kohana::deinit()

Cleans up the environment:

  • Restore the previous error and exception handlers
  • Destroy the Kohana::$log and Kohana::$config objects
dump
close

Kohana::dump(mixed $value, integer $length = integer 128)

Returns an HTML string of information about a single variable.

Borrows heavily on concepts from the Debug class of Nette.

error_handler
close

Kohana::error_handler()

PHP error handler, converts all errors into ErrorExceptions. This handler respects error_reporting settings.

exception_handler
close

Kohana::exception_handler(object $e)

Inline exception handler, displays the error message, source of the exception, and the stack trace of the error.

exception_text
close

Kohana::exception_text(object $e)

Get a single line of text representing the exception:

Error [ Code ]: Message ~ File [ Line ]

find_file
close

Kohana::find_file(string $dir, string $file, string $ext = NULL, boolean $array = bool FALSE)

Finds the path of a file by directory, filename, and extension. If no extension is given, the default EXT extension will be used.

When searching the "config" or "i18n" directories, or when the $aggregate_files flag is set to true, an array of files will be returned. These files will return arrays which must be merged together.

// Returns an absolute path to views/template.php
Kohana::find_file('views', 'template');

// Returns an absolute path to media/css/style.css
Kohana::find_file('media', 'css/style', 'css');

// Returns an array of all the "mimes" configuration file
Kohana::find_file('config', 'mimes');
globals
close

Kohana::globals()

Reverts the effects of the register_globals PHP setting by unsetting all global varibles except for the default super globals (GPCS, etc).

if (ini_get('register_globals'))
{
    Kohana::globals();
}
include_paths
close

Kohana::include_paths()

Returns the the currently active include paths, including the application and system paths.

init
close

Kohana::init(array $settings = NULL)

Initializes the environment:

  • Disables register_globals and magic_quotes_gpc
  • Determines the current environment
  • Set global settings
  • Sanitizes GET, POST, and COOKIE variables
  • Converts GET, POST, and COOKIE variables to the global character set

Any of the global settings can be set here:

Type Setting Description Default Value
boolean errors use internal error and exception handling? TRUE
boolean profile do internal benchmarking? TRUE
boolean caching cache the location of files between requests? FALSE
string charset character set used for all input and output "utf-8"
string base_url set the base URL for the application "/"
string index_file set the index.php file name "index.php"
string cache_dir set the cache directory path APPPATH."cache"
list_files
close

Kohana::list_files(string $directory = NULL, array $paths = NULL)

Recursively finds all of the files in the specified directory.

$views = Kohana::list_files('views');
load
close

Kohana::load(string $file)

Loads a file within a totally empty scope and returns the output:

$foo = Kohana::load('foo.php');
message
close

Kohana::message(string $file, string $path = NULL, mixed $default = NULL)

Get a message from a file. Messages are arbitary strings that are stored in the messages/ directory and reference by a key. Translation is not performed on the returned values.

// Get "username" from messages/text.php
$username = Kohana::message('text', 'username');
modules
close

Kohana::modules(array $modules = NULL)

Changes the currently enabled modules. Module paths may be relative or absolute, but must point to a directory:

Kohana::modules(array('modules/foo', MODPATH.'bar'));
sanitize
close

Kohana::sanitize(mixed $value)

Recursively sanitizes an input variable:

  • Strips slashes if magic quotes are enabled
  • Normalizes all newlines to LF
shutdown_handler
close

Kohana::shutdown_handler()

Catches errors that are not caught by the error handler, such as E_PARSE.

trace
close

Kohana::trace(string $trace = NULL)

Returns an array of HTML strings that represent each step in the backtrace.

// Displays the entire current backtrace
echo implode('<br/>', Kohana::trace());
model
methods
factory
close

Model::factory(string $name, mixed $db = NULL)

Create a new model instance. A Database instance or configuration group name can be passed to the model. If no database is defined, the "default" database group will be used.

$model = Model::factory($name);
num
methods
format
close

Num::format(float $number, integer $places, boolean $monetary = bool FALSE)

Locale-aware number and monetary formatting.

// In English, "1,200.05"
// In Spanish, "1200,05"
// In Portuguese, "1 200,05"
echo Num::format(1200.05, 2);

// In English, "1,200.05"
// In Spanish, "1.200,05"
// In Portuguese, "1.200.05"
echo Num::format(1200.05, 2, TRUE);
ordinal
close

Num::ordinal(integer $number)

Returns the English ordinal suffix (th, st, nd, etc) of a number.

echo 2, Num::ordinal(2);   // "2nd"
echo 10, Num::ordinal(10); // "10th"
echo 33, Num::ordinal(33); // "33rd"
profiler
properties
rollover
close

Profiler::rollover

maximium number of application stats to keep
methods
application
close

Profiler::application()

Gets the total application run time and memory usage. Caches the result so that it can be compared between requests.

list($time, $memory) = Profiler::application();
delete
close

Profiler::delete(string $token)

Deletes a benchmark. If an error occurs during the benchmark, it is recommended to delete the benchmark to prevent statistics from being adversely affected.

Profiler::delete($token);
group_stats
close

Profiler::group_stats(mixed $groups = NULL)

Gets the min, max, average and total of profiler groups as an array.

$stats = Profiler::group_stats('test');
groups
close

Profiler::groups()

Returns all the benchmark tokens by group and name as an array.

$groups = Profiler::groups();
start
close

Profiler::start(string $group, string $name)

Starts a new benchmark and returns a unique token. The returned token must be used when stopping the benchmark.

$token = Profiler::start('test', 'profiler');
stats
close

Profiler::stats(array $tokens)

Gets the min, max, average and total of a set of tokens as an array.

$stats = Profiler::stats($tokens);
stop
close

Profiler::stop(string $token)

Stops a benchmark.

Profiler::stop($token);
total
close

Profiler::total(string $token)

Gets the total execution time and memory usage of a benchmark as a list.

list($time, $memory) = Profiler::total($token);
remote
properties
default_options
close

Remote::default_options

methods
get
close

Remote::get(string $url, array $options = NULL)

Returns the output of a remote URL. Any curl option may be used.

// Do a simple GET request
$data = Remote::get($url);

// Do a POST request
$data = Remote::get($url, array(
    CURLOPT_POST       => TRUE,
    CURLOPT_POSTFIELDS => http_build_query($array),
));
status
close

Remote::status(string $url)

Returns the status code (200, 500, etc) for a URL.

$status = Remote::status($url);
request
properties
action
close

Request::action

action to be executed in the controller
client_ip
close

Request::client_ip

client IP address
controller
close

Request::controller

controller to be executed
current
close

Request::current

currently executing request instance
directory
close

Request::directory

controller directory
headers
close

Request::headers

headers to send with the response body
instance
close

Request::instance

main request instance
is_ajax
close

Request::is_ajax

AJAX-generated request
messages
close

Request::messages

method
close

Request::method

method: GET, POST, PUT, DELETE, etc
protocol
close

Request::protocol

protocol: http, https, ftp, cli, etc
referrer
close

Request::referrer

referring URL
response
close

Request::response

response body
route
close

Request::route

route matched for this request
status
close

Request::status

HTTP response code: 200, 404, 500, etc
uri
close

Request::uri

the URI of the request
user_agent
close

Request::user_agent

client user agent
methods
# _parse_accept
close

Request::_parse_accept(string $header, array $accepts = NULL)

Parses an accept header and returns an array (type => quality) of the accepted types, ordered by quality.

$accept = Request::_parse_accept($header, $defaults);
accept_encoding
close

Request::accept_encoding(string $type = NULL)

Returns the accepted encodings. If a specific encoding is defined, the quality of that encoding will be returned. If the encoding is not accepted, FALSE will be returned.

$encodings = Request::accept_encoding();
accept_lang
close

Request::accept_lang(string $lang = NULL)

Returns the accepted languages. If a specific language is defined, the quality of that language will be returned. If the language is not accepted, FALSE will be returned.

$langs = Request::accept_lang();
accept_type
close

Request::accept_type(string $type = NULL)

Returns the accepted content types. If a specific type is defined, the quality of that type will be returned.

$types = Request::accept_type();
check_cache
close

Request::check_cache(string $etag = NULL)

Checks the browser cache to see the response needs to be returned.

$request->check_cache($etag);

If the cache check succeeds, no further processing can be done!

current
close

Request::current()

Return the currently executing request. This is changed to the current request when Request::execute is called and restored when the request is completed.

$request = Request::current();
execute
close

Request::execute()

Processes the request, executing the controller action that handles this request, determined by the Route.

  1. Before the controller action is called, the Controller::before method will be called.
  2. Next the controller action will be called.
  3. After the controller action is called, the Controller::after method will be called.

By default, the output from the controller is captured and returned, and no headers are sent.

$request->execute();
factory
close

Request::factory(string $uri)

Creates a new request object for the given URI. This differs from Request::instance in that it does not automatically detect the URI and should only be used for creating HMVC requests.

$request = Request::factory($uri);
generate_etag
close

Request::generate_etag()

Generates an ETag from the request response.

$etag = $request->generate_etag();

If the request response is empty when this method is called, an exception will be thrown!

instance
close

Request::instance(string $uri = bool TRUE)

Main request singleton instance. If no URI is provided, the URI will be automatically detected using PATH_INFO, REQUEST_URI, or PHP_SELF.

$request = Request::instance();
param
close

Request::param(string $key = NULL, mixed $default = NULL)

Retrieves a value from the route parameters.

$id = $request->param('id');
redirect
close

Request::redirect(string $url, integer $code = integer 302)

Redirects as the request response. If the URL does not include a protocol, it will be converted into a complete URL.

$request->redirect($url);

No further processing can be done after this method is called!

send_file
close

Request::send_file(string $filename, string $download = NULL, array $options = NULL)

Send file download as the response. All execution will be halted when this method is called! Use TRUE for the filename to send the current response as the file content. The third parameter allows the following options to be set:

Type Option Description Default Value
boolean inline Display inline instead of download FALSE
string mime_type Manual mime type Automatic
boolean delete Delete the file after sending FALSE

Download a file that already exists:

$request->send_file('media/packages/kohana.zip');

Download generated content as a file:

$request->response = $content;
$request->send_file(TRUE, $filename);

No further processing can be done after this method is called!

send_headers
close

Request::send_headers()

Sends the response status and all set headers. The current server protocol (HTTP/1.0 or HTTP/1.1) will be used when available. If not available, HTTP/1.1 will be used.

$request->send_headers();
uri
close

Request::uri(array $params = NULL)

Generates a relative URI for the current route.

$request->uri($params);
user_agent
close

Request::user_agent(string $value)

Returns information about the client user agent.

// Returns "Chrome" when using Google Chrome
$browser = Request::user_agent('browser');
route
properties
default_action
close

Route::default_action

default action for all routes
methods
# _compile
close

Route::_compile()

Returns the compiled regular expression for the route. This translates keys and optional groups to a proper PCRE regular expression.

$regex = $route->_compile();
all
close

Route::all()

Retrieves all named routes.

$routes = Route::all();
cache
close

Route::cache(boolean $save = bool FALSE)

Saves or loads the route cache. If you routes will remain the same for an long period of time, use this to reload the routes from the cache rather than redefining them on every page load.

if ( ! Route::cache())
{
    // Set routes here
    Route::cache(TRUE);
}
defaults
close

Route::defaults(array $defaults = NULL)

Provides default values for keys when they are not present. The default action will always be "index" unless it is overloaded here.

$route->defaults(array(
    'controller' => 'welcome',
    'action'     => 'index'
));
get
close

Route::get(string $name)

Retrieves a named route.

$route = Route::get('default');
matches
close

Route::matches(string $uri)

Tests if the route matches a given URI. A successful match will return all of the routed parameters as an array. A failed match will return boolean FALSE.

// Params: controller = users, action = edit, id = 10
$params = $route->matches('users/edit/10');

This method should almost always be used within an if/else block:

if ($params = $route->matches($uri))
{
    // Parse the parameters
}
name
close

Route::name(object $route)

Get the name of a route.

$name = Route::name($route)
set
close

Route::set(string $name, string $uri, array $regex = NULL)

Stores a named route and returns it. The "action" will always be set to "index" if it is not defined.

Route::set('default', '(<controller>(/<action>(/<id>)))')
    ->defaults(array(
        'controller' => 'welcome',
    ));
uri
close

Route::uri(array $params = NULL)

Generates a URI for the current route based on the parameters given.

// Using the "default" route: "users/profile/10"
$route->uri(array(
    'controller' => 'users',
    'action'     => 'profile',
    'id'         => '10'
));
security
properties
token_name
close

Security::token_name

key name used for token storage
methods
check
close

Security::check(string $token)

Check that the given token matches the currently stored security token.

if (Security::check($token))
{
    // Pass
}
encode_php_tags
close

Security::encode_php_tags(string $str)

Encodes PHP tags in a string.

$str = Security::encode_php_tags($str);
strip_image_tags
close

Security::strip_image_tags(string $str)

Remove image tags from a string.

$str = Security::strip_image_tags($str);
token
close

Security::token(boolean $new = bool FALSE)

Generate and store a unique token which can be used to help prevent CSRF attacks.

$token = Security::token();

You can insert this token into your forms as a hidden field:

echo Form::hidden('csrf', Security::token());

And then check it when using Validate:

$array->rules('csrf', array(
    'not_empty'       => NULL,
    'Security::check' => NULL,
));

This provides a basic, but effective, method of preventing CSRF attacks.

xss_clean
close

Security::xss_clean(mixed $str)

Remove XSS from user input.

$str = Security::xss_clean($str);
session_cookie
properties
default
close

Session_Cookie::default

default session adapter
methods
# _destroy
close

Session_Cookie::_destroy()

Destroys the current session.

# _read
close

Session_Cookie::_read(string $id = NULL)

Loads the raw session data string and returns it.

# _regenerate
close

Session_Cookie::_regenerate()

Generate a new session id and return it.

# _write
close

Session_Cookie::_write()

Writes the current session.

as_array
close

Session_Cookie::as_array()

Returns the current session array. The returned array can also be assigned by reference.

// Get a copy of the current session data
$data = $session->as_array();

// Assign by reference for modification
$data =& $session->as_array();
delete
close

Session_Cookie::delete(string $key)

Removes a variable in the session array.

$session->delete('foo');
destroy
close

Session_Cookie::destroy()

Completely destroy the current session.

$success = $session->destroy();
get
close

Session_Cookie::get(string $key, mixed $default = NULL)

Get a variable from the session array.

$foo = $session->get('foo');
instance
close

Session_Cookie::instance(string $type = NULL, string $id = NULL)

Creates a singleton session of the given type. Some session types (native, database) also support restarting a session by passing a session id as the second parameter.

$session = Session::instance();

Session::write will automatically be called when the request ends.

read
close

Session_Cookie::read(string $id = NULL)

Loads existing session data.

$session->read();
regenerate
close

Session_Cookie::regenerate()

Generates a new session id and returns it.

$id = $session->regenerate();
set
close

Session_Cookie::set(string $key, mixed $value)

Set a variable in the session array.

$session->set('foo');
write
close

Session_Cookie::write()

Sets the last_active timestamp and saves the session.

$session->write();

Any errors that occur during session writing will be logged, but not displayed, because sessions are written after output has been sent.

session_native
properties
default
close

Session_Native::default

default session adapter
methods
# _destroy
close

Session_Native::_destroy()

Destroys the current session.

# _read
close

Session_Native::_read(string $id = NULL)

Loads the raw session data string and returns it.

# _regenerate
close

Session_Native::_regenerate()

Generate a new session id and return it.

# _write
close

Session_Native::_write()

Writes the current session.

as_array
close

Session_Native::as_array()

Returns the current session array. The returned array can also be assigned by reference.

// Get a copy of the current session data
$data = $session->as_array();

// Assign by reference for modification
$data =& $session->as_array();
delete
close

Session_Native::delete(string $key)

Removes a variable in the session array.

$session->delete('foo');
destroy
close

Session_Native::destroy()

Completely destroy the current session.

$success = $session->destroy();
get
close

Session_Native::get(string $key, mixed $default = NULL)

Get a variable from the session array.

$foo = $session->get('foo');
instance
close

Session_Native::instance(string $type = NULL, string $id = NULL)

Creates a singleton session of the given type. Some session types (native, database) also support restarting a session by passing a session id as the second parameter.

$session = Session::instance();

Session::write will automatically be called when the request ends.

read
close

Session_Native::read(string $id = NULL)

Loads existing session data.

$session->read();
regenerate
close

Session_Native::regenerate()

Generates a new session id and returns it.

$id = $session->regenerate();
set
close

Session_Native::set(string $key, mixed $value)

Set a variable in the session array.

$session->set('foo');
write
close

Session_Native::write()

Sets the last_active timestamp and saves the session.

$session->write();

Any errors that occur during session writing will be logged, but not displayed, because sessions are written after output has been sent.

session
properties
default
close

Session::default

default session adapter
methods
# _destroy
close

Session::_destroy()

Destroys the current session.

# _read
close

Session::_read(string $id = NULL)

Loads the raw session data string and returns it.

# _regenerate
close

Session::_regenerate()

Generate a new session id and return it.

# _write
close

Session::_write()

Writes the current session.

as_array
close

Session::as_array()

Returns the current session array. The returned array can also be assigned by reference.

// Get a copy of the current session data
$data = $session->as_array();

// Assign by reference for modification
$data =& $session->as_array();
delete
close

Session::delete(string $key)

Removes a variable in the session array.

$session->delete('foo');
destroy
close

Session::destroy()

Completely destroy the current session.

$success = $session->destroy();
get
close

Session::get(string $key, mixed $default = NULL)

Get a variable from the session array.

$foo = $session->get('foo');
instance
close

Session::instance(string $type = NULL, string $id = NULL)

Creates a singleton session of the given type. Some session types (native, database) also support restarting a session by passing a session id as the second parameter.

$session = Session::instance();

Session::write will automatically be called when the request ends.

read
close

Session::read(string $id = NULL)

Loads existing session data.

$session->read();
regenerate
close

Session::regenerate()

Generates a new session id and returns it.

$id = $session->regenerate();
set
close

Session::set(string $key, mixed $value)

Set a variable in the session array.

$session->set('foo');
write
close

Session::write()

Sets the last_active timestamp and saves the session.

$session->write();

Any errors that occur during session writing will be logged, but not displayed, because sessions are written after output has been sent.

text
methods
alternate
close

Text::alternate()

Alternates between two or more strings.

echo Text::alternate('one', 'two'); // "one"
echo Text::alternate('one', 'two'); // "two"
echo Text::alternate('one', 'two'); // "one"

Note that using multiple iterations of different strings may produce unexpected results.

auto_link
close

Text::auto_link(string $text)

Converts text email addresses and anchors into links. Existing links will not be altered.

echo Text::auto_link($text);
auto_link_emails
close

Text::auto_link_emails(string $text)

Converts text email addresses into links. Existing links will not be altered.

echo Text::auto_link_emails($text);
auto_link_urls
close

Text::auto_link_urls(string $text)

Converts text anchors into links. Existing links will not be altered.

echo Text::auto_link_urls($text);
auto_p
close

Text::auto_p(string $str, boolean $br = bool TRUE)

Automatically applies "p" and "br" markup to text. Basically nl2br on steroids.

echo Text::auto_p($text);

This method is not foolproof since it uses regex to parse HTML.

bytes
close

Text::bytes(integer $bytes, string $force_unit = NULL, string $format = NULL, boolean $si = bool TRUE)

Returns human readable sizes. Based on original functions written by Aidan Lister and Quentin Zervaas.

echo Text::bytes(filesize($file));
censor
close

Text::censor(string $str, array $badwords, string $replacement = string(1) "#", boolean $replace_partial_words = bool TRUE)

Replaces the given words with a string.

// Displays "What the #####, man!"
echo Text::censor('What the frick, man!', array(
    'frick' => '#####',
));
limit_chars
close

Text::limit_chars(string $str, integer $limit = integer 100, string $end_char = NULL, boolean $preserve_words = bool FALSE)

Limits a phrase to a given number of characters.

$text = Text::limit_chars($text);
limit_words
close

Text::limit_words(string $str, integer $limit = integer 100, string $end_char = NULL)

Limits a phrase to a given number of words.

$text = Text::limit_words($text);
random
close

Text::random(string $type = string(5) "alnum", integer $length = integer 8)

Generates a random string of a given type and length.

$str = Text::random(); // 8 character random string

The following types are supported:

alnum
Upper and lower case a-z, 0-9
alpha
Upper and lower case a-z
hexdec
Hexadecimal characters a-f, 0-9
distinct
Uppercase characters and numbers that cannot be confused

You can also create a custom type by providing the "pool" of characters as the type.

reduce_slashes
close

Text::reduce_slashes(string $str)

Reduces multiple slashes in a string to single slashes.

$str = Text::reduce_slashes('foo//bar/baz'); // "foo/bar/baz"
similar
close

Text::similar(array $words)

Finds the text that is similar between a set of words.

$match = Text::similar(array('fred', 'fran', 'free'); // "fr"
widont
close

Text::widont(string $str)

Prevents widow words by inserting a non-breaking space between the last two words.

echo Text::widont($text);
upload
properties
default_directory
close

Upload::default_directory

default upload directory
remove_spaces
close

Upload::remove_spaces

remove spaces in uploaded files
methods
not_empty
close

Upload::not_empty(array $file)

Tests if a successful upload has been made.

$array->rule('file', 'Upload::not_empty');
save
close

Upload::save(array $file, string $filename = NULL, string $directory = NULL, integer $chmod = integer 420)

Save an uploaded file to a new location. If no filename is provided, the original filename will be used, with a unique prefix added.

This method should be used after validating the $_FILES array:

if ($array->check())
{
    // Upload is valid, save it
    Upload::save($_FILES['file']);
}
size
close

Upload::size(array $file, string $size)

Validation rule to test if an uploaded file is allowed by file size. File sizes are defined as: SB, where S is the size (1, 15, 300, etc) and B is the byte modifier: (B)ytes, (K)ilobytes, (M)egabytes, (G)igabytes.

$array->rule('file', 'Upload::size', array('1M'))
type
close

Upload::type(array $file, array $allowed)

Test if an uploaded file is an allowed file type, by extension.

$array->rule('file', 'Upload::type', array(array('jpg', 'png', 'gif')));
valid
close

Upload::valid(array $file)

Tests if upload data is valid, even if no file was uploaded. If you do require a file to be uploaded, add the Upload::not_empty rule before this rule.

$array->rule('file', 'Upload::valid')
url
methods
base
close

URL::base(boolean $index = bool FALSE, mixed $protocol = bool FALSE)

Gets the base URL to the application. To include the current protocol, use TRUE. To specify a protocol, provide the protocol as a string. If a protocol is used, a complete URL will be generated using the $_SERVER['HTTP_HOST'] variable.

// Absolute relative, no host or protocol
echo URL::base();

// Complete relative, with host and protocol
echo URL::base(TRUE, TRUE);

// Complete relative, with host and "https" protocol
echo URL::base(TRUE, 'https');
query
close

URL::query(array $params = NULL)

Merges the current GET parameters with an array of new or overloaded parameters and returns the resulting query string.

// Returns "?sort=title&limit=10" combined with any existing GET values
$query = URL::query(array('sort' => 'title', 'limit' => 10));

Typically you would use this when you are sorting query results, or something similar.

Parameters with a NULL value are left out.

site
close

URL::site(string $uri = string(0) "", mixed $protocol = bool FALSE)

Fetches an absolute site URL based on a URI segment.

echo URL::site('foo/bar');
title
close

URL::title(string $title, string $separator = string(1) "-", boolean $ascii_only = bool FALSE)

Convert a phrase to a URL-safe title.

echo URL::title('My Blog Post'); // "my-blog-post"
utf8
properties
called
close

UTF8::called

list of called methods
server_utf8
close

UTF8::server_utf8

does the server support UTF-8 natively?
methods
clean
close

UTF8::clean(mixed $var, string $charset = string(5) "UTF-8")

Recursively cleans arrays, objects, and strings. Removes ASCII control codes and converts to the requested charset while silently discarding incompatible characters.

UTF8::clean($_GET); // Clean GET data

This method requires Iconv

from_unicode
close

UTF8::from_unicode(array $arr)

Takes an array of ints representing the Unicode characters and returns a UTF-8 string. Astral planes are supported i.e. the ints in the input can be > 0xFFFF. Occurrances of the BOM are ignored. Surrogates are not allowed.

$str = UTF8::to_unicode($array);

The Original Code is Mozilla Communicator client code. The Initial Developer of the Original Code is Netscape Communications Corporation. Portions created by the Initial Developer are Copyright (C) 1998 the Initial Developer. Ported to PHP by Henri Sivonen hsivonen@iki.fi, see http://hsivonen.iki.fi/php-utf8/ Slight modifications to fit with phputf8 library by Harry Fuecks hfuecks@gmail.com.

is_ascii
close

UTF8::is_ascii(string $str)

Tests whether a string contains only 7-bit ASCII bytes. This is used to determine when to use native functions or UTF-8 functions.

$ascii = UTF8::is_ascii($str);
ltrim
close

UTF8::ltrim(string $str, string $charlist = NULL)

Strips whitespace (or other UTF-8 characters) from the beginning of a string. This is a UTF8-aware version of ltrim.

$str = UTF8::ltrim($str);
ord
close

UTF8::ord(string $chr)

Returns the unicode ordinal for a character. This is a UTF8-aware version of ord.

$digit = UTF8::ord($character);
rtrim
close

UTF8::rtrim(string $str, string $charlist = NULL)

Strips whitespace (or other UTF-8 characters) from the end of a string. This is a UTF8-aware version of rtrim.

$str = UTF8::rtrim($str);
str_ireplace
close

UTF8::str_ireplace(string|array $search, string|array $replace, string|array $str, integer $count = NULL)

Returns a string or an array with all occurrences of search in subject (ignoring case) and replaced with the given replace value. This is a UTF8-aware version of str_ireplace.

This function is very slow compared to the native version. Avoid using it when possible.

str_pad
close

UTF8::str_pad(string $str, integer $final_str_length, string $pad_str = string(1) " ", string $pad_type = integer 1)

Pads a UTF-8 string to a certain length with another string. This is a UTF8-aware version of str_pad.

$str = UTF8::str_pad($str, $length);
str_split
close

UTF8::str_split(string $str, integer $split_length = integer 1)

Converts a UTF-8 string to an array. This is a UTF8-aware version of str_split.

$array = UTF8::str_split($str);
strcasecmp
close

UTF8::strcasecmp(string $str1, string $str2)

Case-insensitive UTF-8 string comparison. This is a UTF8-aware version of strcasecmp.

$compare = UTF8::strcasecmp($str1, $str2);
strcspn
close

UTF8::strcspn(string $str, string $mask, integer $offset = NULL, integer $length = NULL)

Finds the length of the initial segment not matching mask. This is a UTF8-aware version of strcspn.

$found = UTF8::strcspn($str, $mask);
strip_ascii_ctrl
close

UTF8::strip_ascii_ctrl(string $str)

Strips out device control codes in the ASCII range.

$str = UTF8::strip_ascii_ctrl($str);
strip_non_ascii
close

UTF8::strip_non_ascii(string $str)

Strips out all non-7bit ASCII bytes.

$str = UTF8::strip_non_ascii($str);
stristr
close

UTF8::stristr(string $str, string $search)

Case-insenstive UTF-8 version of strstr. Returns all of input string from the first occurrence of needle to the end. This is a UTF8-aware version of stristr.

$found = UTF8::stristr($str, $search);
strlen
close

UTF8::strlen(string $str)

Returns the length of the given string. This is a UTF8-aware version of strlen.

$length = UTF8::strlen($str);
strpos
close

UTF8::strpos(string $str, string $search, integer $offset = integer 0)

Finds position of first occurrence of a UTF-8 string. This is a UTF8-aware version of strpos.

$position = UTF8::strpos($str, $search);
strrev
close

UTF8::strrev(string $str)

Reverses a UTF-8 string. This is a UTF8-aware version of strrev.

$str = UTF8::strrev($str);
strrpos
close

UTF8::strrpos(string $str, string $search, integer $offset = integer 0)

Finds position of last occurrence of a char in a UTF-8 string. This is a UTF8-aware version of strrpos.

$position = UTF8::strrpos($str, $search);
strspn
close

UTF8::strspn(string $str, string $mask, integer $offset = NULL, integer $length = NULL)

Finds the length of the initial segment matching mask. This is a UTF8-aware version of strspn.

$found = UTF8::strspn($str, $mask);
strtolower
close

UTF8::strtolower(string $str)

Makes a UTF-8 string lowercase. This is a UTF8-aware version of strtolower.

$str = UTF8::strtolower($str);
strtoupper
close

UTF8::strtoupper(string $str)

Makes a UTF-8 string uppercase. This is a UTF8-aware version of strtoupper.

substr
close

UTF8::substr(string $str, integer $offset, integer $length = NULL)

Returns part of a UTF-8 string. This is a UTF8-aware version of substr.

$sub = UTF8::substr($str, $offset);
substr_replace
close

UTF8::substr_replace(string $str, string $replacement, integer $offset, $length = NULL)

Replaces text within a portion of a UTF-8 string. This is a UTF8-aware version of substr_replace.

$str = UTF8::substr_replace($str, $replacement, $offset);
to_unicode
close

UTF8::to_unicode(string $str)

Takes an UTF-8 string and returns an array of ints representing the Unicode characters. Astral planes are supported i.e. the ints in the output can be > 0xFFFF. Occurrences of the BOM are ignored. Surrogates are not allowed.

$array = UTF8::to_unicode($str);

The Original Code is Mozilla Communicator client code. The Initial Developer of the Original Code is Netscape Communications Corporation. Portions created by the Initial Developer are Copyright (C) 1998 the Initial Developer. Ported to PHP by Henri Sivonen hsivonen@iki.fi, see http://hsivonen.iki.fi/php-utf8/ Slight modifications to fit with phputf8 library by Harry Fuecks hfuecks@gmail.com

transliterate_to_ascii
close

UTF8::transliterate_to_ascii(string $str, integer $case = integer 0)

Replaces special/accented UTF-8 characters by ASCII-7 "equivalents".

$ascii = UTF8::transliterate_to_ascii($utf8);
trim
close

UTF8::trim(string $str, string $charlist = NULL)

Strips whitespace (or other UTF-8 characters) from the beginning and end of a string. This is a UTF8-aware version of trim.

$str = UTF8::trim($str);
ucfirst
close

UTF8::ucfirst(string $str)

Makes a UTF-8 string's first character uppercase. This is a UTF8-aware version of ucfirst.

$str = UTF8::ucfirst($str);
ucwords
close

UTF8::ucwords(string $str)

Makes the first character of every word in a UTF-8 string uppercase. This is a UTF8-aware version of ucwords.

$str = UTF8::ucwords($str);
validate
methods
alpha
close

Validate::alpha(string $str, boolean $utf8 = bool FALSE)

Checks whether a string consists of alphabetical characters only.

alpha_dash
close

Validate::alpha_dash(string $str, boolean $utf8 = bool FALSE)

Checks whether a string consists of alphabetical characters, numbers, underscores and dashes only.

alpha_numeric
close

Validate::alpha_numeric(string $str, boolean $utf8 = bool FALSE)

Checks whether a string consists of alphabetical characters and numbers only.

append
close

Validate::append()

append
close

Validate::append()

as_array
close

Validate::as_array()

Returns the array representation of the current object.

asort
close

Validate::asort()

asort
close

Validate::asort()

callback
close

Validate::callback(string $field, mixed $callback)

Adds a callback to a field. Each callback will be executed only once. No extra parameters can be passed as the format for callbacks is predefined as (Validate $array, $field, array $errors).

// The "username" must be checked with a custom method
$validation->callback('username', array($this, 'check_username'));

To add a callback to every field already set, use TRUE for the field name.

callbacks
close

Validate::callbacks(string $field, array $callbacks)

Add callbacks using an array.

check
close

Validate::check()

Executes all validation filters, rules, and callbacks. This should typically be called within an if/else block.

if ($validation->check())
{
     // The data is valid, do something here
}
color
close

Validate::color(string $str)

Checks if a string is a proper hexadecimal HTML color value. The validation is quite flexible as it does not require an initial "#" and also allows for the short notation using only three instead of six hexadecimal characters.

copy
close

Validate::copy(array $array)

Copies the current filter/rule/callback to a new array.

$copy = $array->copy($new_data);
count
close

Validate::count()

count
close

Validate::count()

credit_card
close

Validate::credit_card(integer $number, string|array $type = NULL)

Validates a credit card number using the Luhn (mod10) formula.

date
close

Validate::date(string $str)

Tests if a string is a valid date string.

decimal
close

Validate::decimal(string $str, integer $places = integer 2, integer $digits = NULL)

Checks if a string is a proper decimal format. Optionally, a specific number of digits can be checked too.

digit
close

Validate::digit(string $str, boolean $utf8 = bool FALSE)

Checks whether a string consists of digits only (no dots or dashes).

email
close

Validate::email(string $email, boolean $strict = bool FALSE)

Check an email address for correct format.

email_domain
close

Validate::email_domain(string $email)

Validate the domain of an email address by checking if the domain has a valid MX record.

error
close

Validate::error(string $field, string $error, $params = NULL)

Add an error to a field.

errors
close

Validate::errors(string $file = NULL, mixed $translate = bool TRUE)

Returns the error messages. If no file is specified, the error message will be the name of the rule that failed. When a file is specified, the message will be loaded from "field/rule", or if no rule-specific message exists, "field/default" will be used. If neither is set, the returned message will be "file/field/rule".

By default all messages are translated using the default language. A string can be used as the second parameter to specified the language that the message was written in.

// Get errors from messages/forms/login.php
$errors = $validate->errors('forms/login');
exact_length
close

Validate::exact_length(string $value, integer $length)

Checks that a field is exactly the right length.

exchangeArray
close

Validate::exchangeArray()

exchangeArray
close

Validate::exchangeArray()

factory
close

Validate::factory(array $array)

Creates a new Validation instance.

filter
close

Validate::filter(string $field, mixed $filter, array $params = NULL)

Overwrites or appends filters to a field. Each filter will be executed once. All rules must be valid callbacks.

// Run trim() on all fields
$validation->filter(TRUE, 'trim');
filters
close

Validate::filters(string $field, array $filters)

Add filters using an array.

getArrayCopy
close

Validate::getArrayCopy()

getArrayCopy
close

Validate::getArrayCopy()

getFlags
close

Validate::getFlags()

getFlags
close

Validate::getFlags()

getIterator
close

Validate::getIterator()

getIterator
close

Validate::getIterator()

getIteratorClass
close

Validate::getIteratorClass()

getIteratorClass
close

Validate::getIteratorClass()

ip
close

Validate::ip(string $ip, boolean $allow_private = bool TRUE)

Validate an IP.

ksort
close

Validate::ksort()

ksort
close

Validate::ksort()

label
close

Validate::label(string $field, string $label)

Sets or overwrites the label name for a field.

labels
close

Validate::labels(array $labels)

Sets labels using an array.

# matches
close

Validate::matches(string $value, string $match)

Checks if a field matches the value of another field.

max_length
close

Validate::max_length(string $value, integer $length)

Checks that a field is short enough.

min_length
close

Validate::min_length(string $value, integer $length)

Checks that a field is long enough.

natcasesort
close

Validate::natcasesort()

natcasesort
close

Validate::natcasesort()

natsort
close

Validate::natsort()

natsort
close

Validate::natsort()

not_empty
close

Validate::not_empty()

Checks if a field is not empty.

numeric
close

Validate::numeric(string $str)

Checks whether a string is a valid number (negative and decimal numbers allowed).

Uses {@link http://www.php.net/manual/en/function.localeconv.php locale conversion} to allow decimal point to be locale specific.

offsetExists
close

Validate::offsetExists()

offsetExists
close

Validate::offsetExists()

offsetGet
close

Validate::offsetGet()

offsetGet
close

Validate::offsetGet()

offsetSet
close

Validate::offsetSet()

offsetSet
close

Validate::offsetSet()

offsetUnset
close

Validate::offsetUnset()

offsetUnset
close

Validate::offsetUnset()

phone
close

Validate::phone(string $number, $lengths = NULL)

Checks if a phone number is valid.

range
close

Validate::range(string $number, integer $min, integer $max)

Tests if a number is within a range.

regex
close

Validate::regex(string $value, string $expression)

Checks a field against a regular expression.

rule
close

Validate::rule(string $field, string $rule, array $params = NULL)

Overwrites or appends rules to a field. Each rule will be executed once. All rules must be string names of functions method names.

// The "username" must not be empty and have a minimum length of 4
$validation->rule('username', 'not_empty')
           ->rule('username', 'min_length', array(4));
rules
close

Validate::rules(string $field, array $rules)

Add rules using an array.

setFlags
close

Validate::setFlags()

setFlags
close

Validate::setFlags()

setIteratorClass
close

Validate::setIteratorClass()

setIteratorClass
close

Validate::setIteratorClass()

uasort
close

Validate::uasort()

uasort
close

Validate::uasort()

uksort
close

Validate::uksort()

uksort
close

Validate::uksort()

url
close

Validate::url(string $url)

Validate a URL.

view
methods
bind
close

View::bind(string $key, mixed $value)

Assigns a value by reference. The benefit of binding is that values can be altered without re-setting them. It is also possible to bind variables before they have values. Assigned values will be available as a variable within the view file:

// This reference can be accessed as $ref within the view
$view->bind('ref', $bar);
bind_global
close

View::bind_global(string $key, mixed $value)

Assigns a global variable by reference, similar to View::bind, except that the variable will be accessible to all views.

View::bind_global($key, $value);
# capture
close

View::capture(string $kohana_view_filename, array $kohana_view_data)

Captures the output that is generated when a view is included. The view data will be extracted to make local variables. This method is static to prevent object scope resolution.

$output = View::capture($file, $data);
factory
close

View::factory(string $file = NULL, array $data = NULL)

Returns a new View object. If you do not define the "file" parameter, you must call View::set_filename.

$view = View::factory($file);
render
close

View::render(string $file = NULL)

Renders the view object to a string. Global and local data are merged and extracted to create local variables within the view file.

$output = $view->render();

Global variables with the same key name as local variables will be overwritten by the local variable.

set
close

View::set(string $key, mixed $value = NULL)

Assigns a variable by name. Assigned values will be available as a variable within the view file:

// This value can be accessed as $foo within the view
$view->set('foo', 'my value');

You can also use an array to set several values at once:

// Create the values $food and $beverage in the view
$view->set(array('food' => 'bread', 'beverage' => 'water'));
set_filename
close

View::set_filename(string $file)

Sets the view filename.

$view->set_filename($file);
set_global
close

View::set_global(string $key, mixed $value = NULL)

Sets a global variable, similar to View::set, except that the variable will be accessible to all views.

View::set_global($name, $value);
Execution time: 0.296 seconds — Memory: 3904 kb
Data loaded from cache
Invalidate cache