Modules

Kodoc_Method
extends Kohana_Kodoc_Method
extends Kodoc
extends Kohana_Kodoc

Class method documentation generator.

package: Kohana/Userguide
category: Base
author: Kohana Team
copyright: © 2008-2013 Kohana Team
license: https://kohana.top/license

Class declared in MODPATH/userguide/classes/Kodoc/Method.php on line 3.

Constants

None

Methods

__construct()
params_short()
class_methods()
classes()
factory()
format_tag()
is_transparent()
link_class_member()
menu()
parse()
show_class()
source()

Propertieslink to this

public ReflectionMethod $methodlink to this

The ReflectionMethod for this class

Default value:

NULL

public array $paramslink to this

Array of Kodoc_Method_Param

Default value:

NULL

public static string $regex_class_memberlink to this

PCRE fragment for matching 'Class', 'Class::method', 'Class::method()' or 'Class::$property'

string(33) "((\w++)(?:::(\$?\w++))?(?:\(\))?)"

public array $returnlink to this

The things this function can return

Default value:

array(0)

public string $sourcelink to this

The source code for this function

Default value:

NULL

Methodslink to this

public __construct( ) (defined in Kohana_Kodoc_Method) link to this

Source Code

?
public function __construct($class, $method)
{
    $this->method = new ReflectionMethod($class, $method);
 
    $this->class = $parent = $this->method->getDeclaringClass();
 
    if ($modifiers = $this->method->getModifiers()) {
        $this->modifiers = '<small>' . implode(' ', Reflection::getModifierNames($modifiers)) . '</small> ';
    }
 
    do {
        if ($parent->hasMethod($method) AND $comment = $parent->getMethod($method)->getDocComment()) {
            // Found a description for this method
            break;
        }
    } while ($parent = $parent->getParentClass());
 
    list($this->description, $tags) = Kodoc::parse($comment);
 
    if ($file = $this->class->getFileName()) {
        $this->source = Kodoc::source($file, $this->method->getStartLine(), $this->method->getEndLine());
    }
 
    if (isset($tags['param'])) {
        $params = [];
 
        foreach ($this->method->getParameters() as $i => $param) {
            $param = new Kodoc_Method_Param([$this->method->class, $this->method->name], $i);
 
            if (isset($tags['param'][$i])) {
                preg_match('/^(\S+)(?:\s*(?:\$' . $param->name . '\s*)?(.+))?$/s', $tags['param'][$i], $matches);
 
                $param->type = $matches[1];
 
                if (isset($matches[2])) {
                    $param->description = ucfirst($matches[2]);
                }
            }
            $params[] = $param;
        }
 
        $this->params = $params;
 
        unset($tags['param']);
    }
 
    if (isset($tags['return'])) {
        foreach ($tags['return'] as $return) {
            if (preg_match('/^(\S*)(?:\s*(.+?))?$/', $return, $matches)) {
                $this->return[] = [$matches[1], isset($matches[2]) ? $matches[2] : ''];
            }
        }
 
        unset($tags['return']);
    }
 
    $this->tags = $tags;
}

public params_short( ) (defined in Kohana_Kodoc_Method) link to this

Source Code

?
public function params_short()
{
    $out = '';
    $required = true;
    $first = true;
    foreach ($this->params as $param) {
        if ($required AND $param->default AND $first) {
            $out .= '[ ' . $param;
            $required = false;
            $first = false;
        } elseif ($required AND $param->default) {
            $out .= '[, ' . $param;
            $required = false;
        } elseif ($first) {
            $out .= $param;
            $first = false;
        } else {
            $out .= ', ' . $param;
        }
    }
 
    if (!$required) {
        $out .= '] ';
    }
 
    return $out;
}

public static class_methods( ) (defined in Kohana_Kodoc) link to this

Get all classes and methods of files in a list.

I personally don't like this as it was used on the index page. Way too much stuff on one page. It has potential for a package index page though. For example: class_methods( Kohana::list_files('classes/sprig') ) could make a nice index page for the sprig package in the api browser ~bluehawk

Source Code

?
public static function class_methods(array $list = null)
{
    $list = Kodoc::classes($list);
 
    $classes = [];
 
    foreach ($list as $class) {
        // Skip transparent extension classes
        if (Kodoc::is_transparent($class))
            continue;
 
        $_class = new ReflectionClass($class);
 
        $methods = [];
 
        foreach ($_class->getMethods() as $_method) {
            $declares = $_method->getDeclaringClass()->name;
 
            // Remove the transparent prefix from declaring classes
            if ($child = Kodoc::is_transparent($declares)) {
                $declares = $child;
            }
 
            if ($declares === $_class->name OR $declares === "Core") {
                $methods[] = $_method->name;
            }
        }
 
        sort($methods);
 
        $classes[$_class->name] = $methods;
    }
 
    return $classes;
}

public static classes( [ array $list = NULL ] ) (defined in Kohana_Kodoc) link to this

Returns an array of all the classes available, built by listing all files in the classes folder.

Parameters

array $list = NULL - Array of files, obtained using Kohana::list_files

Return Values

array - An array of all the class names

Source Code

?
public static function classes(array $list = null)
{
    if ($list === null) {
        $list = Kohana::list_files('classes');
    }
 
    $classes = [];
 
    // This will be used a lot!
    $ext_length = strlen(EXT);
 
    foreach ($list as $name => $path) {
        if (is_array($path)) {
            $classes += Kodoc::classes($path);
        } elseif (substr($name, -$ext_length) === EXT) {
            // Remove "classes/" and the extension
            $class = substr($name, 8, -$ext_length);
 
            // Convert slashes to underscores
            $class = str_replace(DIRECTORY_SEPARATOR, '_', $class);
 
            $classes[$class] = $class;
        }
    }
 
    return $classes;
}

public static factory( ) (defined in Kohana_Kodoc) link to this

Source Code

?
public static function factory($class)
{
    return new Kodoc_Class($class);
}

public static format_tag( string $tag , string $text ) (defined in Kohana_Kodoc) link to this

Generate HTML for the content of a tag.

Parameters

string $tag required - Name of the tag without @
string $text required - Content of the tag

Return Values

string - HTML

Source Code

?
public static function format_tag($tag, $text)
{
    if ($tag === 'license') {
        if (strpos($text, '://') !== false)
            return HTML::anchor($text);
    }
    elseif ($tag === 'link') {
        $split = preg_split('/\s+/', $text, 2);
 
        return HTML::anchor(
                $split[0], isset($split[1]) ? $split[1] : $split[0]
        );
    } elseif ($tag === 'copyright') {
        // Convert the copyright symbol
        return str_replace('(c)', '&copy;', $text);
    } elseif ($tag === 'throws') {
        $route = Route::get('docs/api');
 
        if (preg_match('/^(\w+)\W(.*)$/D', $text, $matches)) {
            return HTML::anchor(
                    $route->uri(['class' => $matches[1]]), $matches[1]
                ) . ' ' . $matches[2];
        }
 
        return HTML::anchor(
                $route->uri(['class' => $text]), $text
        );
    } elseif ($tag === 'see' OR $tag === 'uses') {
        if (preg_match('/^' . Kodoc::$regex_class_member . '/', $text, $matches))
            return Kodoc::link_class_member($matches);
    }
 
    return $text;
}

public static is_transparent( string $class [, array $classes = NULL ] ) (defined in Kohana_Kodoc) link to this

Checks whether a class is a transparent extension class or not.

This method takes an optional $classes parameter, a list of all defined class names. If provided, the method will return false unless the extension class exists. If not, the method will only check known transparent class prefixes.

Transparent prefixes are defined in the userguide.php config file:

?
'transparent_prefixes' => [
    'Kohana' => true,
];

Module developers can therefore add their own transparent extension namespaces and exclude them from the userguide.

Parameters

string $class required - The name of the class to check for transparency
array $classes = NULL - An optional list of all defined classes

Return Values

false - If this is not a transparent extension class
string - The name of the class that extends this (in the case provided)

Source Code

?
public static function is_transparent($class, $classes = null)
{
 
    static $transparent_prefixes = null;
 
    if (!$transparent_prefixes) {
        $transparent_prefixes = Kohana::$config->load('userguide.transparent_prefixes');
    }
 
    // Split the class name at the first underscore
    $segments = explode('_', $class, 2);
 
    if ((count($segments) == 2) AND ( isset($transparent_prefixes[$segments[0]]))) {
        if ($segments[1] === 'Core') {
            // Cater for Module extends Module_Core naming
            $child_class = $segments[0];
        } else {
            // Cater for Foo extends Module_Foo naming
            $child_class = $segments[1];
        }
 
        // It is only a transparent class if the unprefixed class also exists
        if ($classes AND ! isset($classes[$child_class]))
            return false;
 
        // Return the name of the child class
        return $child_class;
    }
    else {
        // Not a transparent class
        return false;
    }
}

public static link_class_member( array $matches ) (defined in Kohana_Kodoc) link to this

Make a class#member API link using an array of matches from Kodoc::$regex_class_member

Parameters

array $matches required - [1 => 'link text', 2 => 'class name', [3 => 'member name']]

Return Values

string

Source Code

?
public static function link_class_member($matches)
{
    $link = $matches[1];
    $class = $matches[2];
    $member = null;
 
    if (isset($matches[3])) {
        // If the first char is a $ it is a property, e.g. Kohana::$base_url
        if ($matches[3][0] === '$') {
            $member = '#property:' . substr($matches[3], 1);
        } elseif (preg_match('/^[A-Z_\x7f-\xff][A-Z0-9_\x7f-\xff]*$/', $matches[3])) {
            $member = '#constant:' . substr($matches[3], 0);
        } else {
            $member = '#' . $matches[3];
        }
    }
 
    return HTML::anchor(Route::get('docs/api')->uri(['class' => $class]) . $member, $link, null, null, true);
}

Creates an html list of all classes sorted by category (or package if no category)

Return Values

string - The html for the menu

Source Code

?
public static function menu()
{
    $classes = Kodoc::classes();
 
    ksort($classes);
 
    $menu = [];
 
    $route = Route::get('docs/api');
 
    foreach ($classes as $class) {
        if (Kodoc::is_transparent($class, $classes))
            continue;
 
        $class = Kodoc_Class::factory($class);
 
        // Test if we should show this class
        if (!Kodoc::show_class($class))
            continue;
 
        $link = HTML::anchor($route->uri(['class' => $class->class->name]), $class->class->name);
 
        if (isset($class->tags['package'])) {
            foreach ($class->tags['package'] as $package) {
                if (isset($class->tags['category'])) {
                    foreach ($class->tags['category'] as $category) {
                        $menu[$package][$category][] = $link;
                    }
                } else {
                    $menu[$package]['Base'][] = $link;
                }
            }
        } else {
            $menu['[Unknown]']['Base'][] = $link;
        }
    }
 
    // Sort the packages
    ksort($menu);
 
    return View::factory('userguide/api/menu')
            ->bind('menu', $menu);
}

public static parse( string $comment [, boolean $html = bool TRUE ] ) (defined in Kohana_Kodoc) link to this

Parse a comment to extract the description and the tags

Converting the output to HTML in this method is deprecated in 3.3

Parameters

string $comment required - The DocBlock to parse
boolean $html = bool TRUE - Whether or not to convert the return values to HTML (deprecated)

Return Values

array - [string $description, array $tags]

Source Code

?
public static function parse($comment, $html = true)
{
    // Normalize all new lines to \n
    $comment = str_replace(["\r\n", "\n"], "\n", $comment);
 
    // Split into lines while capturing without leading whitespace
    preg_match_all('/^\s*\* ?(.*)\n/m', $comment, $lines);
 
    // Tag content
    $tags = [];
 
    /**
     * Process a tag and add it to $tags
     *
     * @param   string  $tag    Name of the tag without @
     * @param   string  $text   Content of the tag
     * @return  void
     */
    $add_tag = function ($tag, $text) use ($html, & $tags) {
        // Don't show @access lines, they are shown elsewhere
        if ($tag !== 'access') {
            if ($html) {
                $text = Kodoc::format_tag($tag, $text);
            }
 
            // Add the tag
            $tags[$tag][] = $text;
        }
    };
 
    $comment = $tag = null;
    $end = count($lines[1]) - 1;
 
    foreach ($lines[1] as $i => $line) {
        // Search this line for a tag
        if (preg_match('/^@(\S+)\s*(.+)?$/', $line, $matches)) {
            if ($tag) {
                // Previous tag is finished
                $add_tag($tag, $text);
            }
 
            $tag = $matches[1];
            $text = isset($matches[2]) ? $matches[2] : '';
 
            if ($i === $end) {
                // No more lines
                $add_tag($tag, $text);
            }
        } elseif ($tag) {
            // This is the continuation of the previous tag
            $text .= "\n" . $line;
 
            if ($i === $end) {
                // No more lines
                $add_tag($tag, $text);
            }
        } else {
            $comment .= "\n" . $line;
        }
    }
 
    $comment = trim($comment, "\n");
 
    if ($comment AND $html) {
        // Parse the comment with Markdown
        $comment = Kodoc_Markdown::markdown($comment);
    }
 
    return [$comment, $tags];
}

public static show_class( Kodoc_Class $class ) (defined in Kohana_Kodoc) link to this

Test whether a class should be shown, based on the api_packages config option

Parameters

Kodoc_Class $class required - The class to test

Return Values

bool - Whether this class should be shown

Source Code

?
public static function show_class(Kodoc_Class $class)
{
    $api_packages = Kohana::$config->load('userguide.api_packages');
 
    // If api_packages is true, all packages should be shown
    if ($api_packages === true)
        return true;
 
    // Get the package tags for this class (as an array)
    $packages = Arr::get($class->tags, 'package', ['None']);
 
    $show_this = false;
 
    // Loop through each package tag
    foreach ($packages as $package) {
        // If this package is in the allowed packages, set show this to true
        if (in_array($package, explode(',', $api_packages)))
            $show_this = true;
    }
 
    return $show_this;
}

public static source( string $file , int $start , int $end ) (defined in Kohana_Kodoc) link to this

Get the source of a function

Parameters

string $file required - The filename
int $start required - Start line?
int $end required - End line?

Source Code

?
public static function source($file, $start, $end)
{
    if (!$file)
        return false;
 
    $file = file($file, FILE_IGNORE_NEW_LINES);
 
    $file = array_slice($file, $start - 1, $end - $start + 1);
 
    if (preg_match('/^(\s+)/', $file[0], $matches)) {
        $padding = strlen($matches[1]);
 
        foreach ($file as & $line) {
            $line = substr($line, $padding);
        }
    }
 
    return implode("\n", $file);
}

Modules

Kodoc_Method extends Kohana_Kodoc_Method extends Kodoc extends Kohana_Kodoc

Constants

Properties

Methods

Propertieslink to this

public ReflectionMethod $methodlink to this

public array $paramslink to this

public static string $regex_class_memberlink to this

public array $returnlink to this

public string $sourcelink to this

Methodslink to this

public __construct( ) (defined in Kohana_Kodoc_Method) link to this

Source Code

public params_short( ) (defined in Kohana_Kodoc_Method) link to this

Source Code

public static class_methods( ) (defined in Kohana_Kodoc) link to this

Source Code

public static classes( [ array $list = NULL ] ) (defined in Kohana_Kodoc) link to this

Parameters

Return Values

Source Code

public static factory( ) (defined in Kohana_Kodoc) link to this

Source Code

public static format_tag( string $tag , string $text ) (defined in Kohana_Kodoc) link to this

Parameters

Return Values

Source Code

public static is_transparent( string $class [, array $classes = NULL ] ) (defined in Kohana_Kodoc) link to this

Parameters

Tags

Return Values

Source Code

public static link_class_member( array $matches ) (defined in Kohana_Kodoc) link to this

Parameters

Return Values

Source Code

public static menu( ) (defined in Kohana_Kodoc) link to this

Return Values

Source Code

public static parse( string $comment [, boolean $html = bool TRUE ] ) (defined in Kohana_Kodoc) link to this

Parameters

Return Values

Source Code

public static show_class( Kodoc_Class $class ) (defined in Kohana_Kodoc) link to this

Parameters

Return Values

Source Code

public static source( string $file , int $start , int $end ) (defined in Kohana_Kodoc) link to this

Parameters

Source Code

Kodoc_Method
extends Kohana_Kodoc_Method
extends Kodoc
extends Kohana_Kodoc

public `ReflectionMethod` $methodlink to this

public `array` $paramslink to this

public static `string` $regex_class_memberlink to this

public `array` $returnlink to this

public `string` $sourcelink to this