Modules

Kodoc_Property
extends Kohana_Kodoc_Property
extends Kodoc
extends Kohana_Kodoc

Class property documentation generator.

package
Kohana/Userguide
category
Base
author
Kohana Team
copyright
© 2009-2012 Kohana Team
license
http://kohanaphp.com/license

Class declared in MODPATH/userguide/classes/kodoc/property.php on line 3.

Properties

public string $modifiers

modifiers: public, private, static, etc

public object $property

ReflectionProperty

public static string $regex_class_member

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

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

public string $type

variable type, retrieved from the comment

public string $value

value of the property

Methods

public __construct( ) (defined in Kohana_Kodoc_Property)

Source Code

public function __construct($class, $property)
{
	$property = new ReflectionProperty($class, $property);

	list($description, $tags) = Kodoc::parse($property->getDocComment());

	$this->description = $description;

	if ($modifiers = $property->getModifiers())
	{
		$this->modifiers = '<small>'.implode(' ', Reflection::getModifierNames($modifiers)).'</small> ';
	}

	if (isset($tags['var']))
	{
		if (preg_match('/^(\S*)(?:\s*(.+?))?$/', $tags['var'][0], $matches))
		{
			$this->type = $matches[1];

			if (isset($matches[2]))
			{
				$this->description = Kodoc_Markdown::markdown($matches[2]);
			}
		}
	}

	$this->property = $property;
	
	// Show the value of static properties, but only if they are public or we are php 5.3 or higher and can force them to be accessible
	if ($property->isStatic() AND ($property->isPublic() OR version_compare(PHP_VERSION, '5.3', '>=')))
	{
		// Force the property to be accessible
		if (version_compare(PHP_VERSION, '5.3', '>='))
		{
			$property->setAccessible(TRUE);
		}
		
		// Don't debug the entire object, just say what kind of object it is
		if (is_object($property->getValue($class)))
		{
			$this->value = '<pre>object '.get_class($property->getValue($class)).'()</pre>';
		}
		else
		{
			$this->value = Debug::vars($property->getValue($class));
		}
	}
	
}

public static class_methods( ) (defined in Kohana_Kodoc)

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 = array();

	foreach ($list as $class)
	{
		$_class = new ReflectionClass($class);

		if (stripos($_class->name, 'Kohana_') === 0)
		{
			// Skip transparent extension classes
			continue;
		}

		$methods = array();

		foreach ($_class->getMethods() as $_method)
		{
			$declares = $_method->getDeclaringClass()->name;

			if (stripos($declares, 'Kohana_') === 0)
			{
				// Remove "Kohana_"
				$declares = substr($declares, 7);
			}

			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)

Returns an array of all the classes available, built by listing all files in the classes folder and then trying to create that class.

This means any empty class files (as in complety empty) will cause an exception

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 = array();

	// 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, '_', strtolower($class));

			$classes[$class] = $class;
		}
	}

	return $classes;
}

public static factory( ) (defined in Kohana_Kodoc)

Source Code

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

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

Parameters

  • array $matches required - Array( 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);
		}
		else
		{
			$member = '#'.$matches[3];
		}
	}

	return HTML::anchor(Route::get('docs/api')->uri(array('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();

	foreach ($classes as $class)
	{
		if (isset($classes['kohana_'.$class]))
		{
			// Remove extended classes
			unset($classes['kohana_'.$class]);
		}
	}

	ksort($classes);

	$menu = array();

	$route = Route::get('docs/api');

	foreach ($classes as $class)
	{
		$class = Kodoc_Class::factory($class);

		// Test if we should show this class
		if ( ! Kodoc::show_class($class))
			continue;

		$link = HTML::anchor($route->uri(array('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 ) (defined in Kohana_Kodoc)

Parse a comment to extract the description and the tags

Parameters

  • string $comment required - The comment retreived using ReflectionClass->getDocComment()

Return Values

  • array - Array(string $description, array $tags)

Source Code

public static function parse($comment)
{
	// Normalize all new lines to \n
	$comment = str_replace(array("\r\n", "\n"), "\n", $comment);

	// Remove the phpdoc open/close tags and split
	$comment = array_slice(explode("\n", $comment), 1, -1);

	// Tag content
	$tags = array();

	foreach ($comment as $i => $line)
	{
		// Remove all leading whitespace
		$line = preg_replace('/^\s*\* ?/m', '', $line);

		// Search this line for a tag
		if (preg_match('/^@(\S+)(?:\s*(.+))?$/', $line, $matches))
		{
			// This is a tag line
			unset($comment[$i]);

			$name = $matches[1];
			$text = isset($matches[2]) ? $matches[2] : '';

			switch ($name)
			{
				case 'license':
					if (strpos($text, '://') !== FALSE)
					{
						// Convert the lincense into a link
						$text = HTML::anchor($text);
					}
				break;
				case 'link':
					$text = preg_split('/\s+/', $text, 2);
					$text = HTML::anchor($text[0], isset($text[1]) ? $text[1] : $text[0]);
				break;
				case 'copyright':
					if (strpos($text, '(c)') !== FALSE)
					{
						// Convert the copyright sign
						$text = str_replace('(c)', '&copy;', $text);
					}
				break;
				case 'throws':
					if (preg_match('/^(\w+)\W(.*)$/', $text, $matches))
					{
						$text = HTML::anchor(Route::get('docs/api')->uri(array('class' => $matches[1])), $matches[1]).' '.$matches[2];
					}
					else
					{
						$text = HTML::anchor(Route::get('docs/api')->uri(array('class' => $text)), $text);
					}
				break;
				case 'uses':
					if (preg_match('/^'.Kodoc::$regex_class_member.'$/i', $text, $matches))
					{
						$text = Kodoc::link_class_member($matches);
					}
				break;
				// Don't show @access lines, they are shown elsewhere
				case 'access':
					continue 2;
			}

			// Add the tag
			$tags[$name][] = $text;
		}
		else
		{
			// Overwrite the comment line
			$comment[$i] = (string) $line;
		}
	}

	// Concat the comment lines back to a block of text
	if ($comment = trim(implode("\n", $comment)))
	{
		// Parse the comment with Markdown
		$comment = Kodoc_Markdown::markdown($comment);
	}

	return array($comment, $tags);
}

public static show_class( Kodoc_Class $class ) (defined in Kohana_Kodoc)

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', array('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)

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);
}