public __construct( string $class ) (defined in Kohana_Kodoc_Class)

Parameters

• string $class required - Class name

Return Values

• void

public function __construct($class)
{
	$this->class = new ReflectionClass($class);

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

	if ($constants = $this->class->getConstants())
	{
		foreach ($constants as $name => $value)
		{
			$this->constants[$name] = Kohana::debug($value);
		}
	}

	$parent = $this->class;

	do
	{
		if ($comment = $parent->getDocComment())
		{
			// Found a description for this class
			break;
		}
	}
	while ($parent = $parent->getParentClass());

	list($this->description, $this->tags) = Kodoc::parse($comment);
	
	// If this class extends Kodoc_Missing, add a warning about possible
	// incomplete documentation
	$parent = $this->class;
	
	while ($parent = $parent->getParentClass())
	{
		if ($parent->name == 'Kodoc_Missing')
		{
			$warning = "[!!] **This class, or a class parent, could not be
			           found or loaded. This could be caused by a missing
					   module or other dependancy. The documentation for
					   class may not be complete!**";
			$this->description = Markdown($warning).$this->description;
		}
	}
}

public static class_methods( ) (defined in Kohana_Kodoc)

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)

Parameters

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

Return Values

• array - An array of all the class names

public static function classes(array $list = NULL)
{
	if ($list === NULL)
	{
		$list = Kohana::list_files('classes');
	}

	$classes = array();

	foreach ($list as $name => $path)
	{
		if (is_array($path))
		{
			$classes += Kodoc::classes($path);
		}
		else
		{
			// Remove "classes/" and the extension
			$class = substr($name, 8, -(strlen(EXT)));

			// Convert slashes to underscores
			$class = str_replace(DIRECTORY_SEPARATOR, '_', strtolower($class));

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

	return $classes;
}

public static factory( ) (defined in Kohana_Kodoc)

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

public static link_class_member( array $matches ) (defined in Kohana_Kodoc)

Parameters

• array $matches required - Array( 1 => link text, 2 => class name, [3 => member name] )

Return Values

• string

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

public static menu( ) (defined in Kohana_Kodoc)

Return Values

• string - The html for the menu

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 methods( ) (defined in Kohana_Kodoc_Class)

Return Values

• array

public function methods()
{
	$methods = $this->class->getMethods();

	usort($methods, array($this,'_method_sort'));

	foreach ($methods as $key => $method)
	{
		$methods[$key] = new Kodoc_Method($this->class->name, $method->name);
	}

	return $methods;
}

public static parse( string $comment ) (defined in Kohana_Kodoc)

Parameters

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

Return Values

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

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)', '©', $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 = Markdown($comment);
	}

	return array($comment, $tags);
}

public properties( ) (defined in Kohana_Kodoc_Class)

Return Values

• array

public function properties()
{
	$props = $this->class->getProperties();

	usort($props, array($this,'_prop_sort'));

	foreach ($props as $key => $property)
	{
		// Create Kodoc Properties for each property
		$props[$key] = new Kodoc_Property($this->class->name, $property->name);
	}

	return $props;
}

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

Parameters

• Kodoc_Class $class required - The class to test

Return Values

• bool - Whether this class should be shown

public static function show_class(Kodoc_Class $class)
{
	$api_packages = Kohana::config('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)

Parameters

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

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

protected _method_sort( ) (defined in Kohana_Kodoc_Class)

protected function _method_sort($a, $b)
{
	// If one method is public, and the other is not, it goes on top
	if ($a->isPublic() AND ( ! $b->isPublic()))
		return -1;
	if ($b->isPublic() AND ( ! $a->isPublic()))
		return 1;
	
	// If one method is protected and the other is private, it goes on top
	if ($a->isProtected() AND $b->isPrivate())
		return -1;
	if ($b->isProtected() AND $a->isPrivate())
		return 1;
	
	// The methods have the same visibility, so check the declaring class depth:
	
	
	/*
	echo kohana::debug('a is '.$a->class.'::'.$a->name,'b is '.$b->class.'::'.$b->name,
					   'are the classes the same?', $a->class == $b->class,'if they are, the result is:',strcmp($a->name, $b->name),
					   'is a this class?', $a->name == $this->class->name,-1,
					   'is b this class?', $b->name == $this->class->name,1,
					   'otherwise, the result is:',strcmp($a->class, $b->class)
					   );
	*/

	// If both methods are defined in the same class, just compare the method names
	if ($a->class == $b->class)
		return strcmp($a->name, $b->name);

	// If one of them was declared by this class, it needs to be on top
	if ($a->name == $this->class->name)
		return -1;
	if ($b->name == $this->class->name)
		return 1;

	// Otherwise, get the parents of each methods declaring class, then compare which function has more "ancestors"
	$adepth = 0;
	$bdepth = 0;

	$parent = $a->getDeclaringClass();
	do
	{
		$adepth++;
	}
	while ($parent = $parent->getParentClass());

	$parent = $b->getDeclaringClass();
	do
	{
		$bdepth++;
	}
	while ($parent = $parent->getParentClass());

	return $bdepth - $adepth;
}

protected _prop_sort( ) (defined in Kohana_Kodoc_Class)

protected function _prop_sort($a, $b)
{
	// If one property is public, and the other is not, it goes on top
	if ($a->isPublic() AND ( ! $b->isPublic()))
		return -1;
	if ($b->isPublic() AND ( ! $a->isPublic()))
		return 1;
	
	// If one property is protected and the other is private, it goes on top
	if ($a->isProtected() AND $b->isPrivate())
		return -1;
	if ($b->isProtected() AND $a->isPrivate())
		return 1;
	
	// Otherwise just do alphabetical
	return strcmp($a->name, $b->name);
}