Class Kodoc_Class

Kodoc_Class

extends Kohana_Kodoc_Class
extends Kodoc
extends Kohana_Kodoc

Class documentation generator.

package
Kohana/Userguide
category
Base
author
Kohana Team
copyright
(c) Kohana Team
license
https://koseven.ga/LICENSE.md


Information

This class is a transparent base class for Kohana_Kodoc_Class

Constants

  • None

Properties

Methods

Properties

public ReflectionClass $class

The ReflectionClass for this class

Default value: 
NULL

public array $constants

array of this classes constants

Default value: 
array(0)

public string $description

description of the class from the comment

Default value: 
NULL

public string $modifiers

modifiers like abstract, final

Default value: 
NULL

public array $parents

Parent classes/interfaces of this class/interface

Default value: 
array(0)

public static string $regex_class_member

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

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

public array $tags

array of tags, retrieved from the comment

Default value: 
array(0)

Methods

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

Loads a class and uses reflection to parse the class. Reads the class modifiers, constants and comment. Parses the comment to find the description and tags.

Parameters

  • string $class required - Class name

Return Values

  • void

Source Code

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

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

	$this->constants = $this->class->getConstants();

	// If ReflectionClass::getParentClass() won't work if the class in
	// question is an interface
	if ($this->class->isInterface())
	{
		$this->parents = $this->class->getInterfaces();
	}
	else
	{
		$parent = $this->class;

		while ($parent = $parent->getParentClass())
		{
			$this->parents[] = $parent;
		}
	}

	if ( ! $comment = $this->class->getDocComment())
	{
		foreach ($this->parents as $parent)
		{
			if ($comment = $parent->getDocComment())
			{
				// Found a description for this class
				break;
			}
		}
	}

	list($this->description, $this->tags) = Kodoc::parse($comment, FALSE);
}

public constants() (defined in Kohana_Kodoc_Class)

Gets the constants of this class as HTML.

Return Values

  • array

Source Code

public function constants()
{
	$result = [];

	foreach ($this->constants as $name => $value)
	{
		$result[$name] = Debug::vars($value);
	}

	return $result;
}

public description() (defined in Kohana_Kodoc_Class)

Get the description of this class as HTML. Includes a warning when the class or one of its parents could not be found.

Return Values

  • string - HTML

Source Code

public function description()
{
	$result = $this->description;

	// If this class extends Kodoc_Missing, add a warning about possible
	// incomplete documentation
	foreach ($this->parents as $parent)
	{
		if ($parent->name == 'Kodoc_Missing')
		{
			$result .= "[!!] **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!**";
		}
	}

	return Kodoc_Markdown::markdown($result);
}

public methods() (defined in Kohana_Kodoc_Class)

Gets a list of the class properties as Kodoc_Method objects.

Return Values

  • array

Source Code

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

	usort($methods, [$this,'_method_sort']);

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

	return $methods;
}

public properties() (defined in Kohana_Kodoc_Class)

Gets a list of the class properties as Kodoc_Property objects.

Return Values

  • array

Source Code

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

	$defaults = $this->class->getDefaultProperties();

	usort($props, [$this,'_prop_sort']);

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

	return $props;
}

public tags() (defined in Kohana_Kodoc_Class)

Get the tags of this class as HTML.

Return Values

  • array

Source Code

public function tags()
{
	$result = [];

	foreach ($this->tags as $name => $set)
	{
		foreach ($set as $text)
		{
			$result[$name][] = Kodoc::format_tag($name, $text);
		}
	}

	return $result;
}

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 = [];

	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)

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)

Source Code

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

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

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)

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' => array(
    '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

Tags

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

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

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

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)

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

protected _method_sort() (defined in Kohana_Kodoc_Class)

Sort methods based on their visibility and declaring class based on:

  • methods will be sorted public, protected, then private.
  • methods that are declared by an ancestor will be after classes declared by the current class
  • lastly, they will be sorted alphabetically

Source Code

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 Debug::vars('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)

Source Code

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

Modules

Do you want to contribute to Koseven?

Koseven Logo

We need YOUR help!

This project is open source. What does this mean? YOU can help:
  • Found a bug? Report it on Github
  • Need a feature? Add it Here
  • Want to help? Join the Forum
Go to Github