/**
* Cache declared interfaces and classes to a single file
* @todo - extract the file_put_contents / php_strip_whitespace calls or figure out a way to mock the filesystem
*
* @param string
* @return void
*/
public function cache($classCacheFilename)
{
if (file_exists($classCacheFilename)) {
$this->reflectClassCache($classCacheFilename);
$code = file_get_contents($classCacheFilename);
} else {
$code = "<?php\n";
}
$classes = array_merge(get_declared_interfaces(), get_declared_classes());
foreach ($classes as $class) {
$class = new ClassReflection($class);
if (!$this->shouldCacheClass->isSatisfiedBy($class)) {
continue;
}
// Skip any classes we already know about
if (in_array($class->getName(), $this->knownClasses)) {
continue;
}
$this->knownClasses[] = $class->getName();
$code .= $this->cacheCodeGenerator->getCacheCode($class);
}
file_put_contents($classCacheFilename, $code);
// minify the file
file_put_contents($classCacheFilename, php_strip_whitespace($classCacheFilename));
}
/**
* Loads a list of classes and caches them in one big file.
*
* @param array $classes An array of classes to load
* @param string $cacheDir A cache directory
* @param string $name The cache name prefix
* @param Boolean $autoReload Whether to flush the cache when the cache is stale or not
* @param Boolean $adaptive Whether to remove already declared classes or not
*
* @throws \InvalidArgumentException When class can't be loaded
*/
public static function load($classes, $cacheDir, $name, $autoReload, $adaptive = false)
{
// each $name can only be loaded once per PHP process
if (isset(self::$loaded[$name])) {
return;
}
self::$loaded[$name] = true;
$classes = array_unique($classes);
if ($adaptive) {
// don't include already declared classes
$classes = array_diff($classes, get_declared_classes(), get_declared_interfaces());
// the cache is different depending on which classes are already declared
$name = $name . '-' . substr(md5(implode('|', $classes)), 0, 5);
}
$cache = $cacheDir . '/' . $name . '.php';
// auto-reload
$reload = false;
if ($autoReload) {
$metadata = $cacheDir . '/' . $name . '.meta';
if (!file_exists($metadata) || !file_exists($cache)) {
$reload = true;
} else {
$time = filemtime($cache);
$meta = unserialize(file_get_contents($metadata));
if ($meta[1] != $classes) {
$reload = true;
} else {
foreach ($meta[0] as $resource) {
if (!file_exists($resource) || filemtime($resource) > $time) {
$reload = true;
break;
}
}
}
}
}
if (!$reload && file_exists($cache)) {
require_once $cache;
return;
}
$files = array();
$content = '';
foreach ($classes as $class) {
if (!class_exists($class) && !interface_exists($class)) {
throw new \InvalidArgumentException(sprintf('Unable to load class "%s"', $class));
}
$r = new \ReflectionClass($class);
$files[] = $r->getFileName();
$content .= preg_replace(array('/^\\s*<\\?php/', '/\\?>\\s*$/'), '', file_get_contents($r->getFileName()));
}
// cache the core classes
if (!is_dir(dirname($cache))) {
mkdir(dirname($cache), 0777, true);
}
self::writeCacheFile($cache, Kernel::stripComments('<?php ' . $content));
if ($autoReload) {
// save the resources
self::writeCacheFile($metadata, serialize(array($files, $classes)));
}
}
/**
* Constructor
*
* @param array Options hash:
* - OPT_TAGS_FILE: the path to a tags file produce with ctags for your project -- all tags will be used for autocomplete
*/
public function __construct($options = array())
{
// merge opts
$this->options = array_merge(array(self::OPT_TAGS_FILE => NULL, self::OPT_REQUIRE => NULL), $options);
// initialize temp files
$this->tmpFileShellCommand = $this->tmpFileNamed('command');
$this->tmpFileShellCommandRequires = $this->tmpFileNamed('requires');
$this->tmpFileShellCommandState = $this->tmpFileNamed('state');
// setup autocomplete
$phpList = get_defined_functions();
$this->autocompleteList = array_merge($this->autocompleteList, $phpList['internal']);
$this->autocompleteList = array_merge($this->autocompleteList, get_defined_constants());
$this->autocompleteList = array_merge($this->autocompleteList, get_declared_classes());
$this->autocompleteList = array_merge($this->autocompleteList, get_declared_interfaces());
// initialize tags
$tagsFile = $this->options[self::OPT_TAGS_FILE];
if (file_exists($tagsFile)) {
$tags = array();
$tagLines = file($tagsFile);
foreach ($tagLines as $tag) {
$matches = array();
if (preg_match('/^([A-z0-9][^\\W]*)\\W.*/', $tag, $matches)) {
$tags[] = $matches[1];
}
}
$this->autocompleteList = array_merge($this->autocompleteList, $tags);
}
// process optional require files
if ($this->options[self::OPT_REQUIRE]) {
if (!is_array($this->options[self::OPT_REQUIRE])) {
$this->options[self::OPT_REQUIRE] = array($this->options[self::OPT_REQUIRE]);
}
file_put_contents($this->tmpFileShellCommandRequires, serialize($this->options[self::OPT_REQUIRE]));
}
}
function execute()
{
echo "search class files...";
$files = find_files($this->_source_dir, array('extnames' => array('.php'), 'excludes' => array('_config')));
echo "ok\n\n";
$this->_files = $files;
spl_autoload_register(array($this, 'autoload'));
$classes = get_declared_classes();
$classes = array_merge($classes, get_declared_interfaces());
foreach ($files as $path) {
require_once $path;
}
$new_classes = get_declared_classes();
$new_classes = array_merge($new_classes, get_declared_interfaces());
$found = array_diff($new_classes, $classes);
$files = array();
foreach ($found as $class) {
$r = new ReflectionClass($class);
$files[$class] = $r->getFileName();
}
$arr = array();
$len = strlen($this->_source_dir);
foreach ($files as $class => $path) {
$filename = str_replace(array('/', '\\'), '/', substr($path, $len + 1));
$class = strtolower($class);
$arr[$class] = $filename;
}
$output = "<?php global \$G_CLASS_FILES;\$G_CLASS_FILES = ";
$output .= str_replace(array(' ', "\n"), '', var_export($arr, true));
$output .= ";\n";
file_put_contents($this->_output_file, $output, LOCK_EX);
echo "ok\n";
}
/** @param base base class to collect sub classes for
* @param check_interfaces whether we deal with interfaces
*/
function __construct($base, $check_interfaces = false)
{
foreach (get_declared_classes() as $cname) {
$parent = get_parent_class($cname);
if (strcasecmp($parent, $base) == 0) {
$this->offsetSet($cname, new SubClasses($cname));
}
if ($check_interfaces) {
if ($parent) {
$parent_imp = class_implements($parent);
}
foreach (class_implements($cname) as $iname) {
if (strcasecmp($iname, $base) == 0) {
if (!$parent || !in_array($iname, $parent_imp)) {
$this->offsetSet($cname, new SubClasses($cname));
}
}
}
}
}
if ($check_interfaces) {
foreach (get_declared_interfaces() as $cname) {
foreach (class_implements($cname) as $iname) {
if (strcasecmp($iname, $base) == 0) {
$this->offsetSet($cname, new SubClasses($cname, true));
}
}
}
}
$this->uksort('strnatcasecmp');
}
static function info($type = 1)
{
$type_list = array('basic', 'const', 'variable', 'function', 'class', 'interface', 'file');
if (is_int($type) && $type < 7) {
$type = $type_list[$type];
}
switch ($type) {
case 'const':
$const_arr = get_defined_constants(true);
return $const_arr['user'];
//2因作用域，请在外边直接调用函数
//2因作用域，请在外边直接调用函数
case 'variable':
return 'please use: get_defined_vars()';
case 'function':
$fun_arr = get_defined_functions();
return $fun_arr['user'];
case 'class':
return array_slice(get_declared_classes(), 125);
case 'interface':
return array_slice(get_declared_interfaces(), 10);
case 'file':
return get_included_files();
default:
return array('system' => php_uname(), 'service' => php_sapi_name(), 'php_version' => PHP_VERSION, 'frame_name' => config('frame|name'), 'frame_version' => config('frame|version'), 'magic_quotes' => get_magic_quotes_gpc(), 'time_zone' => date_default_timezone_get());
}
}
function add_internal($internal_classes)
{
global $functions, $internal_arginfo;
foreach ($internal_classes as $class_name) {
add_class($class_name, 0);
}
foreach (get_declared_interfaces() as $class_name) {
add_class($class_name);
}
foreach (get_declared_traits() as $class_name) {
add_class($class_name);
}
foreach (get_defined_functions()['internal'] as $function_name) {
$function = new \ReflectionFunction($function_name);
$required = $function->getNumberOfRequiredParameters();
$optional = $function->getNumberOfParameters() - $required;
$functions[strtolower($function_name)] = ['file' => 'internal', 'namespace' => $function->getNamespaceName(), 'avail' => true, 'conditional' => false, 'flags' => 0, 'lineno' => 0, 'endLineno' => 0, 'name' => $function_name, 'docComment' => '', 'required' => $required, 'optional' => $optional, 'ret' => null, 'params' => []];
add_param_info($function_name);
}
foreach (array_keys($internal_arginfo) as $function_name) {
if (strpos($function_name, ':') !== false) {
continue;
}
$ln = strtolower($function_name);
$functions[$ln] = ['file' => 'internal', 'avail' => false, 'conditional' => false, 'flags' => 0, 'lineno' => 0, 'endLineno' => 0, 'name' => $function_name, 'docComment' => '', 'ret' => null, 'params' => []];
add_param_info($function_name);
}
}
/**
* Prepares and returns used class lists.
*
* @return ReflectionClass[]
*/
protected function parseClassLists()
{
$this->declared = array_flip(array_merge(get_declared_classes(), get_declared_interfaces()));
foreach ($this->getNamespaces() as $namespace) {
foreach ($namespace->getClasses() as $name => $ref) {
$class = $this->reflectionFactory->createFromReflection($ref);
$this->allClasses[self::TOKENIZED_CLASSES][$name] = $class;
if (!$class->isDocumented()) {
continue;
}
$this->loadParentClassesAndInterfacesFromClassReflection($ref);
}
}
/** @var ReflectionClass $class */
foreach ($this->allClasses[self::TOKENIZED_CLASSES] as $class) {
if (!$class->isDocumented()) {
continue;
}
foreach ($class->getOwnMethods() as $method) {
$this->processFunction($method);
}
foreach ($class->getOwnProperties() as $property) {
$this->loadAnnotationFromReflection($class, $property->getAnnotations(), 'var');
}
}
foreach ($this->getFunctions() as $function) {
$this->processFunction($function);
}
array_walk_recursive($this->allClasses, function (&$reflection) {
if (!$reflection instanceof ReflectionClass) {
$reflection = $this->reflectionFactory->createFromReflection($reflection);
}
});
return $this->allClasses;
}
public function scan($namespace)
{
$namespace = trim($namespace, "\\") . "\\";
$paths = [];
foreach (spl_autoload_functions() as $loader) {
if (is_array($loader) && count($loader) === 2) {
if ($loader[0] instanceof ComposerLoader) {
foreach ($loader[0]->getPrefixes() as $prefix => $loaderPaths) {
if (strpos($prefix . "\\", $namespace) === 0) {
$paths = array_merge($paths, $loaderPaths);
} else {
if (strpos($namespace, $prefix . "\\") === 0) {
$paths = array_merge($paths, array_map(function ($path) use($namespace, $prefix) {
return $path . "/" . str_replace("\\", "/", $namespace);
}, $loaderPaths));
}
}
}
}
}
}
array_map([$this->phpLoader, "load"], $paths);
return array_filter(array_merge(get_declared_classes(), get_declared_interfaces()), function ($name) use($namespace) {
return stripos($name, $namespace) === 0;
});
}
protected function minifyYii($entryScript)
{
try {
ob_start();
$this->runRequest($entryScript);
$_SERVER['REQUEST_URI'] = '/index.php';
$this->runRequest($entryScript, array('r' => 'post'));
ob_end_clean();
} catch (CException $e) {
echo $e;
die;
}
$classes = array_merge(get_declared_classes(), get_declared_interfaces());
$results = array();
foreach ($classes as $class) {
$c = new ReflectionClass($class);
if (strpos($c->getFileName(), YII_PATH) === 0 && strpos($c->getFileName(), YII_PATH . DIRECTORY_SEPARATOR . 'console') !== 0) {
$results[$class] = $c->getFileName();
}
}
$results = $this->sortByInheritance($results);
$content = '';
foreach ($results as $fileName => $class) {
$content .= "\n" . file_get_contents($fileName);
}
return $content;
}
function __construct($dump_file = false, $gzip_dump_file = false)
{
$functions = get_defined_functions();
$this->data = array('memory_usage' => memory_get_usage(), 'interfaces' => get_declared_interfaces(), 'classes' => get_declared_classes(), 'constants' => get_defined_constants(), 'user_functions' => $functions['user'], 'int_functions' => $functions['internal']);
if ($dump_file) {
$this->dump($dump_file, $gzip_dump_file);
}
}
public function executeOnce(AgaviFilterChain $filterChain, AgaviExecutionContainer $container)
{
$filterChain->execute($container);
$interfaces = get_declared_interfaces();
$classes = get_declared_classes();
$text = "Interfaces ** \n - " . implode("\n - ", $interfaces) . "\n Classes ** \n - " . implode("\n - ", $classes);
$container->getContext()->getLoggerManager()->getLogger("debug")->log(new AgaviLoggerMessage("{$text}", AgaviLogger::DEBUG));
}
/**
* @runInSeparateProcess
*/
public function testOneClass()
{
$message = new \Zend\Stdlib\Message();
$classes = array_merge(get_declared_interfaces(), get_declared_classes());
$actual = $this->sut->cache($classes);
$expected = $this->getTestFileContents('testMessageClass');
$this->assertEquals($expected, $actual);
}
/**
* Loads a list of classes and caches them in one big file.
*
* @param array $classes An array of classes to load
* @param string $cacheDir A cache directory
* @param string $name The cache name prefix
* @param bool $autoReload Whether to flush the cache when the cache is stale or not
* @param bool $adaptive Whether to remove already declared classes or not
* @param string $extension File extension of the resulting file
*
* @throws \InvalidArgumentException When class can't be loaded
*/
public static function load($classes, $cacheDir, $name, $autoReload, $adaptive = false, $extension = '.php')
{
// each $name can only be loaded once per PHP process
if (isset(self::$loaded[$name])) {
return;
}
self::$loaded[$name] = true;
if ($adaptive) {
$declared = array_merge(get_declared_classes(), get_declared_interfaces(), get_declared_traits());
// don't include already declared classes
$classes = array_diff($classes, $declared);
// the cache is different depending on which classes are already declared
$name = $name . '-' . substr(hash('sha256', implode('|', $classes)), 0, 5);
}
$classes = array_unique($classes);
// cache the core classes
if (!is_dir($cacheDir) && !@mkdir($cacheDir, 0777, true) && !is_dir($cacheDir)) {
throw new \RuntimeException(sprintf('Class Collection Loader was not able to create directory "%s"', $cacheDir));
}
$cacheDir = rtrim(realpath($cacheDir) ?: $cacheDir, '/' . DIRECTORY_SEPARATOR);
$cache = $cacheDir . DIRECTORY_SEPARATOR . $name . $extension;
// auto-reload
$reload = false;
if ($autoReload) {
$metadata = $cache . '.meta';
if (!is_file($metadata) || !is_file($cache)) {
$reload = true;
} else {
$time = filemtime($cache);
$meta = unserialize(file_get_contents($metadata));
sort($meta[1]);
sort($classes);
if ($meta[1] != $classes) {
$reload = true;
} else {
foreach ($meta[0] as $resource) {
if (!is_file($resource) || filemtime($resource) > $time) {
$reload = true;
break;
}
}
}
}
}
if (!$reload && file_exists($cache)) {
require_once $cache;
return;
}
if (!$adaptive) {
$declared = array_merge(get_declared_classes(), get_declared_interfaces(), get_declared_traits());
}
$files = self::inline($classes, $cache, $declared);
if ($autoReload) {
// save the resources
self::writeCacheFile($metadata, serialize(array(array_values($files), $classes)));
}
}
/**
* Make cache file from current loaded classes
*
*/
public function cache()
{
set_time_limit(120);
$swpLockFile = $this->getConfig()->getSwapFile() . '.lock';
if (is_file($swpLockFile)) {
return;
}
file_put_contents($swpLockFile, '');
// Open working file
if (is_file($this->getConfig()->getSwapFile()) === false) {
file_put_contents($this->getConfig()->getSwapFile(), '');
}
$this->handle = fopen($this->getConfig()->getSwapFile(), 'r+');
// Lock the file
if (flock($this->handle, LOCK_EX) === false) {
return;
}
// Clear the file
ftruncate($this->handle, 0);
// Traits first, then interfaces at last the classes
$classes = array_merge(get_declared_traits(), get_declared_interfaces(), get_declared_classes());
// We only want to cache classes once
$classes = array_unique($classes);
$this->classList = array_flip($classes);
$this->classList = array_fill_keys($classes, false);
// Write PHP open tag
fwrite($this->handle, '<?php' . PHP_EOL);
// Walk through the classes
foreach ($this->classList as $class => &$used) {
$this->processClassIntoCacheFile(new Reflection\ClassReflection($class));
}
// Flush last contents to the file
fflush($this->handle);
// Release the swap lock
flock($this->handle, LOCK_UN);
// Close cache file handle
fclose($this->handle);
// Minify cache file
file_put_contents($this->getConfig()->getSwapFile(), php_strip_whitespace($this->getConfig()->getSwapFile()));
$fileLock = $this->getConfig()->getFile() . '.lock';
file_put_contents($fileLock, '');
if (is_file($this->getConfig()->getFile())) {
unlink($this->getConfig()->getFile());
}
// Replace old cache file
copy($this->getConfig()->getSwapFile(), $this->getConfig()->getFile());
if (is_file($this->getConfig()->getSwapFile())) {
// Hotfix for Windows environments
if (@unlink($this->getConfig()->getSwapFile()) === false) {
unlink($this->getConfig()->getSwapFile());
}
}
// Unlink Locks
unlink($swpLockFile);
unlink($fileLock);
}
public function testIteratorHasCorrectTotal()
{
$iterator = new cfhCompile_ClassIterator_Declared();
$total = count(get_declared_interfaces()) + count(get_declared_classes());
$i = 0;
foreach ($iterator as $c) {
$i++;
}
$this->assertEquals($total, $i);
}
/**
* @return string[] internal symbols
*/
public function internalSymbolsProvider()
{
$allSymbols = array_merge(get_declared_classes(), get_declared_interfaces(), get_declared_traits());
$indexedSymbols = array_combine($allSymbols, $allSymbols);
return array_map(function ($symbol) {
return [$symbol];
}, array_filter($indexedSymbols, function ($symbol) {
$reflection = new PhpReflectionClass($symbol);
return $reflection->isInternal();
}));
}
public function testGetInterfaces()
{
$interfaces = ezcReflection::getInterfaces();
self::assertContainsOnly('ezcReflectionClass', $interfaces);
foreach ($interfaces as $interfaceName => $interface) {
self::assertTrue($interface->isInterface());
self::assertEquals($interface->getName(), $interfaceName);
$interfaceNames[] = $interface->getName();
}
self::assertEquals(get_declared_interfaces(), $interfaceNames);
}
public function addGlobalizedClass($class)
{
if (!is_string($class)) {
throw new \Exception('class value must be a string');
}
if ($this->isGlobalizedClassRegistered($class)) {
throw new \Exception('class class value "' . $class . '" is already defined');
}
if (!in_array($class, get_declared_classes()) && !in_array($class, get_declared_interfaces())) {
$this->_globalizedClasses[] = $class;
}
}
private function requireFile($file)
{
$previousDefinedClasses = get_declared_classes();
$previousDefinedInterfaces = get_declared_interfaces();
require_once $this->file;
$currentDefinedClasses = get_declared_classes();
$currentDefinedInterfaces = get_declared_interfaces();
$userDefinedClasses = array_diff($currentDefinedClasses, $previousDefinedClasses);
$userDefinedInterfaces = array_diff($currentDefinedInterfaces, $previousDefinedInterfaces);
//now treat classes and interfaces as the same
$this->userDefinedClasses = array_merge($userDefinedClasses, $userDefinedInterfaces);
}
public function load($source)
{
$classes = get_declared_classes();
$interfaces = get_declared_interfaces();
$functions = get_defined_functions()['user'];
$constants = get_defined_constants();
require_once $source;
$this->classes = array_diff(get_declared_classes(), $classes);
$this->interfaces = array_diff(get_declared_interfaces(), $interfaces);
$this->functions = array_diff(get_defined_functions()['user'], $functions);
$this->constants = array_diff(get_defined_constants(), $constants);
}
/**
* Warms up the cache.
*
* @param string $cacheDir The cache directory
*/
public function warmUp($cacheDir)
{
$classmap = $cacheDir . '/classes.map';
if (!is_file($classmap)) {
return;
}
if (file_exists($cacheDir . '/classes.php')) {
return;
}
$declared = null !== $this->declaredClasses ? $this->declaredClasses : array_merge(get_declared_classes(), get_declared_interfaces(), get_declared_traits());
ClassCollectionLoader::inline(include $classmap, $cacheDir . '/classes.php', $declared);
}
/**
* Cache declared interfaces and classes to a single file
*
* @param \Zend\Mvc\MvcEvent $e
* @return void
*/
public function cache($e)
{
$request = $e->getRequest();
if ($request instanceof ConsoleRequest || $request->getQuery()->get('EDPSUPERLUMINAL_CACHE', null) === null) {
return;
}
if (file_exists(ZF_CLASS_CACHE)) {
$this->reflectClassCache();
$code = file_get_contents(ZF_CLASS_CACHE);
} else {
$code = "<?php\n";
}
$classes = array_merge(get_declared_interfaces(), get_declared_classes());
foreach ($classes as $class) {
// Skip non-Zend classes
if (0 !== strpos($class, 'Zend')) {
continue;
}
// Skip the autoloader factory and this class
if (in_array($class, array('Zend\\Loader\\AutoloaderFactory', __CLASS__))) {
continue;
}
if ($class === 'Zend\\Loader\\SplAutoloader') {
continue;
}
// Skip any classes we already know about
if (in_array($class, $this->knownClasses)) {
continue;
}
$this->knownClasses[] = $class;
$class = new ClassReflection($class);
// Skip any Annotation classes
$docBlock = $class->getDocBlock();
if ($docBlock) {
if ($docBlock->getTags('Annotation')) {
continue;
}
}
// Skip ZF2-based autoloaders
if (in_array('Zend\\Loader\\SplAutoloader', $class->getInterfaceNames())) {
continue;
}
// Skip internal classes or classes from extensions
// (this shouldn't happen, as we're only caching Zend classes)
if ($class->isInternal() || $class->getExtensionName()) {
continue;
}
$code .= static::getCacheCode($class);
}
file_put_contents(ZF_CLASS_CACHE, $code);
// minify the file
file_put_contents(ZF_CLASS_CACHE, php_strip_whitespace(ZF_CLASS_CACHE));
}
protected function processElementsItems()
{
$items = [];
foreach (array_merge(get_declared_classes(), get_declared_interfaces(), get_declared_traits()) as $name) {
$reflection = new \ReflectionClass($name);
if ($reflection->isInternal() || mb_substr($name, 0, 11) === 'FixinTools\\') {
continue;
}
$items[$reflection->name] = new Item($this, $reflection);
}
ksort($items);
$this->items = $items;
}
private static function findTypes(array $searchTypeList, array $excludeTypeList)
{
$correctTypes = array();
$foundTypeList = array_merge(get_declared_classes(), get_declared_interfaces());
foreach ($foundTypeList as $type) {
if (in_array($type, $excludeTypeList)) {
continue;
}
if (self::hasTypeList($type, $searchTypeList)) {
$correctTypes[] = $type;
}
}
return $correctTypes;
}
function testLazyLoadInterfaceGuessNameFromFile()
{
$name1 = $this->_rndName();
$path1 = $this->_writeInterfaceFile($name1, '.php');
$name2 = $this->_rndName();
$path2 = $this->_writeInterfaceFile($name2, '.php');
lmb_require_class($path1);
lmb_require_class($path2);
$this->assertFalse(in_array($name1, get_declared_interfaces()));
$this->assertFalse(in_array($name2, get_declared_interfaces()));
$this->assertTrue(interface_exists($name1, true));
//triggers autoload
$this->assertTrue(in_array($name1, get_declared_interfaces()));
$this->assertFalse(in_array($name2, get_declared_interfaces()));
}
/**
* Returns string representation of all given arguments.
*
* @return string
*/
function dump()
{
$args = func_get_args();
$bt = debug_backtrace();
if (count($args) < 1) {
$args['version'] = PHP_VERSION;
$args['environment'] = $_SERVER;
$args['interfaces'] = get_declared_interfaces();
$args['classes'] = get_declared_classes();
//$args['constants'] = get_defined_constants(true);
//$args['functions'] = get_defined_functions();
//$args['variables'] = get_defined_vars();
//$args['backtrace'] = $bt;
}
$inner = '';
foreach ($args as $index => $arg) {
$str = '';
if (true === $arg) {
$str = 'true';
} else {
if (false === $arg) {
$str = 'false';
} else {
$str = print_r($arg, true);
}
}
if (true) {
//$escape) {
$index = htmlspecialchars($index, ENT_QUOTES, 'UTF-8');
$str = htmlspecialchars($str, ENT_QUOTES, 'UTF-8');
}
$methods = '';
if (is_object($arg)) {
$methods = '<pre>' . print_r(get_class_methods($arg), true) . '</pre>';
}
$id = '';
if ($this->format != 'plain') {
$id = rawurlencode($index) . str_replace(array('.', ' '), array('_', '_'), microtime());
}
$inner .= $this->tr($this->tdnb($id, $index . ' => ' . gettype($arg) . $methods, $id) . $this->td($id, $id, $str));
}
if (@$bt[3]['file'] == __FILE__) {
$bt = $bt[3];
} else {
$bt = $bt[2];
}
return $this->table($this->tr($this->th($bt['function'], $bt['file'], $bt['line'])) . $inner . $this->trend());
}
/**
* Load class in the source directory
*/
protected function loadClasses()
{
if (!is_dir($this->srcDirectory)) {
throw new \Exception('Source directory not found : ' . $this->srcDirectory);
}
$objects = new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($this->srcDirectory), \RecursiveIteratorIterator::SELF_FIRST);
$Regex = new \RegexIterator($objects, '/^.+\\.php$/i', \RecursiveRegexIterator::GET_MATCH);
foreach ($Regex as $name => $object) {
if (!empty($name)) {
require_once $name;
}
}
$classes = get_declared_classes();
$traits = get_declared_traits();
$interfaces = get_declared_interfaces();
$this->loadedClasses = array_merge($classes, $traits, $interfaces);
}
protected function _findPackages($files)
{
$found_classes = array();
foreach ($files as $file) {
require_once $file;
}
$classes = array_merge(get_declared_classes(), get_declared_interfaces());
$this->_last_errors = array();
foreach ($classes as $class) {
$doc = new ReflectionClass($class);
if (!in_array($doc->getFileName(), $files)) {
continue;
}
try {
$found_classes[] = API_Doc_Class::instance($class);
} catch (API_Doc_Exception $ex) {
$this->_last_errors[] = $ex;
}
}
foreach ($found_classes as $class) {
try {
$package = $class->package;
if (!$package) {
throw new API_Doc_EmptyPackageException($class, sprintf('Class "%s" use empty package name.', $class->name));
}
$package->classes[] = $class;
if (!isset($this->packages[$package->name])) {
$this->packages[$package->name] = $package;
}
} catch (API_Doc_Exception $ex) {
$this->_last_errors[] = $ex;
}
}
$this->classes = $found_classes;
foreach ($this->packages as $name => $package) {
$filename = "{$this->docs_dir}/package.{$name}.texy";
if (is_file($filename)) {
$contents = file_get_contents($filename);
$lines = explode("\n", $contents);
$summary = reset($lines);
$package->summary = trim($summary);
$package->description = $contents;
unset($lines);
}
}
}
/**
* method for making a single file of most used doctrine runtime components
* including the compiled file instead of multiple files (in worst
* cases dozens of files) can improve performance by an order of magnitude
*
* @throws Doctrine_Compiler_Exception if something went wrong during the compile operation
* @return void
*/
public static function compile($target = null)
{
$path = Doctrine::getPath();
$it = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($path), RecursiveIteratorIterator::LEAVES_ONLY);
foreach ($it as $file) {
$e = explode('.', $file->getFileName());
// we don't want to require versioning files
if (end($e) === 'php' && strpos($file->getFileName(), '.inc') === false) {
require_once $file->getPathName();
}
}
$classes = array_merge(get_declared_classes(), get_declared_interfaces());
$ret = array();
foreach ($classes as $class) {
$e = explode('_', $class);
if ($e[0] !== 'Doctrine') {
continue;
}
$refl = new ReflectionClass($class);
$file = $refl->getFileName();
print 'Adding ' . $file . PHP_EOL;
$lines = file($file);
$start = $refl->getStartLine() - 1;
$end = $refl->getEndLine();
$ret = array_merge($ret, array_slice($lines, $start, $end - $start));
}
if ($target == null) {
$target = $path . DIRECTORY_SEPARATOR . 'Doctrine.compiled.php';
}
// first write the 'compiled' data to a text file, so
// that we can use php_strip_whitespace (which only works on files)
$fp = @fopen($target, 'w');
if ($fp === false) {
throw new Doctrine_Compiler_Exception("Couldn't write compiled data. Failed to open {$target}");
}
fwrite($fp, "<?php " . implode('', $ret));
fclose($fp);
$stripped = php_strip_whitespace($target);
$fp = @fopen($target, 'w');
if ($fp === false) {
throw new Doctrine_Compiler_Exception("Couldn't write compiled data. Failed to open {$file}");
}
fwrite($fp, $stripped);
fclose($fp);
}