/**
* Load classes
*
* @param String Class name of class for loading
* @param string Directory of class
* @param boolean If class need instantiation
* @return object
*/
function load_class($class, $directory = 'core', $instantiate = FALSE )
{
static $_classes = array();
$class_path = ROOT . '/' . $directory . '/' . $class;
// return classe instance if exists (singleton pattern)
if (isset($_classes[$class]))
{
return $_classes[$class];
}
if (file_exists($class_path . '.php'))
{
require $class_path . '.php';
$reflection = new ReflectionClass("\\$directory\\$class");
if($reflection->inNamespace())
{
$class = $reflection->getNamespaceName() . '\\' . $class;
}
if($instantiate === TRUE)
{
$_classes[$class] = new $class();
return $_classes[$class];
}
}
}
/**
* Returns inheritance inspection.
*
* The inspection result:
*
* must:
*
* * shortName
* * name
* * userDefined
*
* optional:
*
* * namespace
*
* @param \ReflectionClass $declaringClass ReflectionClass object.
* @return array Inheritance inspection.
*/
protected function getInheritanceInspection(\ReflectionClass $declaringClass)
{
$inheritanceInspection = array('shortname' => $declaringClass->getShortName(), 'name' => $declaringClass->getName(), 'filename' => $declaringClass->getFileName(), 'userDefined' => $declaringClass->isUserDefined());
if ($declaringClass->inNamespace()) {
$inheritanceInspection['namespace'] = $declaringClass->getNamespaceName();
}
return $inheritanceInspection;
}
public function get($entity)
{
$function = new \ReflectionClass($entity);
$className = $function->getShortName();
$transformerClassName = sprintf("AppBundle\\Response\\Transformer\\%sTransformer", $className);
if (class_exists($transformerClassName) === false) {
throw new \Exception(sprintf("Transformer class for entity %s does not exist.", $function->inNamespace()));
}
$transformerClass = new $transformerClassName();
return $transformerClass;
}
/**
* @SuppressWarnings(PHPMD.CyclomaticComplexity)
*/
public function getExistingClasses(array $paths) : array
{
$namespaceList = [];
$classList = [];
$list = [];
foreach ($paths as $path) {
if (false === $path->isSourceCode()) {
continue;
}
$iter = new ClassIterator($this->getPhpFiles($path->getPathBase()));
foreach (array_keys($iter->getClassMap()) as $classname) {
if (in_array(substr($classname, -4), ['Test', 'Spec'])) {
continue;
}
$reflection = new \ReflectionClass($classname);
if ($reflection->isAbstract() || $reflection->isTrait() || $reflection->isInterface()) {
continue;
}
if ($reflection->inNamespace()) {
$namespaces = explode('\\', $reflection->getNamespaceName());
$namespace = '';
foreach ($namespaces as $key => $namespacePart) {
if ($namespace !== '') {
$namespace .= '/';
}
$namespace .= $namespacePart;
if (!array_key_exists($key, $namespaceList)) {
$namespaceList[$key] = [];
}
$namespaceList[$key][$namespace] = $namespace;
}
}
$escapedName = str_replace('\\', '/', $classname);
$classList[$escapedName] = $escapedName;
}
}
foreach ($namespaceList as $namespaceDepthList) {
$list = array_merge($list, $namespaceDepthList);
}
$list = array_merge($list, $classList);
return $list;
}
/**
* Expands class name into FQN.
* @param string
* @return string fully qualified class name
* @throws Nette\InvalidArgumentException
*/
public static function expandClassName($name, \ReflectionClass $reflector)
{
if (empty($name)) {
throw new Nette\InvalidArgumentException('Class name must not be empty.');
} elseif ($name === 'self') {
return $reflector->getName();
} elseif ($name[0] === '\\') { // already fully qualified
return ltrim($name, '\\');
}
$filename = $reflector->getFileName();
$parsed = static::getCache()->load($filename, function (& $dp) use ($filename) {
if (AnnotationsParser::$autoRefresh) {
$dp[Nette\Caching\Cache::FILES] = $filename;
}
return AnnotationsParser::parsePhp(file_get_contents($filename));
});
$uses = array_change_key_case((array) $tmp = & $parsed[$reflector->getName()]['use']);
$parts = explode('\\', $name, 2);
$parts[0] = strtolower($parts[0]);
if (isset($uses[$parts[0]])) {
$parts[0] = $uses[$parts[0]];
return implode('\\', $parts);
} elseif ($reflector->inNamespace()) {
return $reflector->getNamespaceName() . '\\' . $name;
} else {
return $name;
}
}
/**
* 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
* @param string $extension File extension of the resulting file
*
* @throws \InvalidArgumentException When class can't be loaded
*/
static public 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) {
// 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.$extension;
// auto-reload
$reload = false;
if ($autoReload) {
$metadata = $cacheDir.'/'.$name.$extension.'.meta';
if (!is_file($metadata) || !is_file($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 (!is_file($resource) || filemtime($resource) > $time) {
$reload = true;
break;
}
}
}
}
}
if (!$reload && is_file($cache)) {
require_once $cache;
return;
}
$files = array();
$content = '';
foreach ($classes as $class) {
if (!class_exists($class) && !interface_exists($class) && (!function_exists('trait_exists') || !trait_exists($class))) {
throw new \InvalidArgumentException(sprintf('Unable to load class "%s"', $class));
}
$r = new \ReflectionClass($class);
$files[] = $r->getFileName();
$c = preg_replace(array('/^\s*<\?php/', '/\?>\s*$/'), '', file_get_contents($r->getFileName()));
// add namespace declaration for global code
if (!$r->inNamespace()) {
$c = "\nnamespace\n{\n".self::stripComments($c)."\n}\n";
} else {
$c = self::fixNamespaceDeclarations('<?php '.$c);
$c = preg_replace('/^\s*<\?php/', '', $c);
}
$content .= $c;
}
// cache the core classes
if (!is_dir(dirname($cache))) {
mkdir(dirname($cache), 0777, true);
}
self::writeCacheFile($cache, '<?php '.$content);
if ($autoReload) {
// save the resources
self::writeCacheFile($metadata, serialize(array($files, $classes)));
}
}
/**
* Returns array of magic methods defined by annotation @method.
* @return array
*/
public static function getMagicMethods($class)
{
$rc = new \ReflectionClass($class);
preg_match_all('~^
[ \\t*]* @method [ \\t]+
(?: [^\\s(]+ [ \\t]+ )?
(set|get|is|add) ([A-Z]\\w*) [ \\t]*
(?: \\( [ \\t]* ([^)$\\s]+) )?
()~mx', $rc->getDocComment(), $matches, PREG_SET_ORDER);
$methods = array();
foreach ($matches as $m) {
list(, $op, $prop, $type) = $m;
$name = $op . $prop;
$prop = strtolower($prop[0]) . substr($prop, 1) . ($op === 'add' ? 's' : '');
if ($rc->hasProperty($prop) && ($rp = $rc->getProperty($prop)) && !$rp->isStatic()) {
$rp->setAccessible(TRUE);
if ($op === 'get' || $op === 'is') {
$type = NULL;
$op = 'get';
} elseif (!$type && preg_match('#@var[ \\t]+(\\S+)' . ($op === 'add' ? '\\[\\]#' : '#'), $rp->getDocComment(), $m)) {
$type = $m[1];
}
if ($rc->inNamespace() && preg_match('#^[A-Z]\\w+(\\[|\\||\\z)#', $type)) {
$type = $rc->getNamespaceName() . '\\' . $type;
}
$methods[$name] = array($op, $rp, $type);
}
}
return $methods;
}
/**
* Returns array of magic methods defined by annotation @method.
* @return array
*/
public static function getMagicMethods(string $class) : array
{
$rc = new \ReflectionClass($class);
preg_match_all('~^
[ \\t*]* @method [ \\t]+
(?: [^\\s(]+ [ \\t]+ )?
(set|get|is|add) ([A-Z]\\w*)
(?: ([ \\t]* \\() [ \\t]* ([^)$\\s]*) )?
()~mx', (string) $rc->getDocComment(), $matches, PREG_SET_ORDER);
$methods = [];
foreach ($matches as list(, $op, $prop, $bracket, $type)) {
if ($bracket !== '(') {
trigger_error("Bracket must be immediately after @method {$op}{$prop}() in class {$class}.", E_USER_WARNING);
}
$name = $op . $prop;
$prop = strtolower($prop[0]) . substr($prop, 1) . ($op === 'add' ? 's' : '');
if ($rc->hasProperty($prop) && ($rp = $rc->getProperty($prop)) && !$rp->isStatic()) {
$rp->setAccessible(TRUE);
if ($op === 'get' || $op === 'is') {
$type = NULL;
$op = 'get';
} elseif (!$type && preg_match('#@var[ \\t]+(\\S+)' . ($op === 'add' ? '\\[\\]#' : '#'), (string) $rp->getDocComment(), $m)) {
$type = $m[1];
}
if ($rc->inNamespace() && preg_match('#^[A-Z]\\w+(\\[|\\||\\z)#', (string) $type)) {
$type = $rc->getNamespaceName() . '\\' . $type;
}
$methods[$name] = [$op, $rp, $type];
}
}
return $methods;
}
/**
* Expands class name into FQN.
* @param string
* @return string fully qualified class name
* @throws Nette\InvalidArgumentException
*/
public static function expandClassName($name, \ReflectionClass $reflector)
{
if (empty($name)) {
throw new Nette\InvalidArgumentException('Class name must not be empty.');
}
if ($name[0] === '\\') {
// already fully qualified
return ltrim($name, '\\');
}
$parsed = static::parsePhp(file_get_contents($reflector->getFileName()));
$uses = array_change_key_case((array) ($tmp =& $parsed[$reflector->getName()]['use']));
$parts = explode('\\', $name, 2);
$parts[0] = strtolower($parts[0]);
if (isset($uses[$parts[0]])) {
$parts[0] = $uses[$parts[0]];
return implode('\\', $parts);
} elseif ($reflector->inNamespace()) {
return $reflector->getNamespaceName() . '\\' . $name;
} else {
return $name;
}
}
/**
* @group DDC-3231
*/
public function testGeneratedEntityRepositoryClassCustomDefaultRepository()
{
$em = $this->_getTestEntityManager();
$ns = $this->_namespace;
require_once __DIR__ . '/../../Models/DDC3231/DDC3231User2.php';
$className = $ns . '\\DDC3231User2Tmp';
$this->writeEntityClass('Doctrine\\Tests\\Models\\DDC3231\\DDC3231User2', $className);
$rpath = $this->writeRepositoryClass($className, 'Doctrine\\Tests\\Models\\DDC3231\\DDC3231EntityRepository');
$this->assertNotNull($rpath);
$this->assertFileExists($rpath);
require $rpath;
$repo = new \ReflectionClass($em->getRepository($className));
$this->assertTrue($repo->inNamespace());
$this->assertSame($className . 'Repository', $repo->getName());
$this->assertSame('Doctrine\\Tests\\Models\\DDC3231\\DDC3231EntityRepository', $repo->getParentClass()->getName());
require_once __DIR__ . '/../../Models/DDC3231/DDC3231User2NoNamespace.php';
$className2 = 'DDC3231User2NoNamespaceTmp';
$this->writeEntityClass('DDC3231User2NoNamespace', $className2);
$rpath2 = $this->writeRepositoryClass($className2, 'Doctrine\\Tests\\Models\\DDC3231\\DDC3231EntityRepository');
$this->assertNotNull($rpath2);
$this->assertFileExists($rpath2);
require $rpath2;
$repo2 = new \ReflectionClass($em->getRepository($className2));
$this->assertFalse($repo2->inNamespace());
$this->assertSame($className2 . 'Repository', $repo2->getName());
$this->assertSame('Doctrine\\Tests\\Models\\DDC3231\\DDC3231EntityRepository', $repo2->getParentClass()->getName());
}
public static function load($classes, $cacheDir, $name, $autoReload, $adaptive = false)
{
if (isset(self::$loaded[$name])) {
return;
}
self::$loaded[$name] = true;
$classes = array_unique($classes);
if ($adaptive) {
$classes = array_diff($classes, get_declared_classes(), get_declared_interfaces());
$name = $name . '-' . substr(md5(implode('|', $classes)), 0, 5);
}
$cache = $cacheDir . '/' . $name . '.php';
$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();
$c = preg_replace(array('/^\\s*<\\?php/', '/\\?>\\s*$/'), '', file_get_contents($r->getFileName()));
if (!$r->inNamespace()) {
$c = "\nnamespace\n{\n{$c}\n}\n";
} else {
$c = self::fixNamespaceDeclarations('<?php ' . $c);
$c = preg_replace('/^\\s*<\\?php/', '', $c);
}
$content .= $c;
}
if (!is_dir(dirname($cache))) {
mkdir(dirname($cache), 0777, true);
}
self::writeCacheFile($cache, Kernel::stripComments('<?php ' . $content));
if ($autoReload) {
self::writeCacheFile($metadata, serialize(array($files, $classes)));
}
}
/**
* Return the local class for an object or a class that can be loaded.
*
* @param object|string $object
*
* @return string
*/
static function get_local_class($object)
{
$class_name = is_object($object) ? get_class($object) : $object;
try {
$reflector = new \ReflectionClass($class_name);
if ($reflector->inNamespace()) {
$base_class = $reflector->getShortName();
} else {
$base_class = $class_name;
}
} catch (\Exception $e) {
$base_class = $class_name;
}
return $base_class;
}
/**
* {@inheritdoc}
*/
public function inNamespace()
{
return $this->reflectionClass->inNamespace();
}
/**
* Inspect namespace.
*
* @return void
*/
protected function inspectNamespace()
{
if ($this->class->inNamespace()) {
$this->inspection['namespace'] = $this->class->getNamespaceName();
}
}
/**
* Expands class name into full name.
* @param string
* @return string full name
* @throws Nette\InvalidArgumentException
*/
public static function expandClassName(string $name, \ReflectionClass $rc) : string
{
$lower = strtolower($name);
if (empty($name)) {
throw new Nette\InvalidArgumentException('Class name must not be empty.');
} elseif (in_array($lower, ['string', 'int', 'float', 'bool', 'array', 'callable'], TRUE)) {
return $lower;
} elseif ($lower === 'self') {
return $rc->getName();
} elseif ($name[0] === '\\') {
// fully qualified name
return ltrim($name, '\\');
}
$uses =& self::$cache[$rc->getName()];
if ($uses === NULL) {
self::$cache = self::parseUseStatemenets(file_get_contents($rc->getFileName()), $rc->getName()) + self::$cache;
$uses =& self::$cache[$rc->getName()];
}
$parts = explode('\\', $name, 2);
if (isset($uses[$parts[0]])) {
$parts[0] = $uses[$parts[0]];
return implode('\\', $parts);
} elseif ($rc->inNamespace()) {
return $rc->getNamespaceName() . '\\' . $name;
} else {
return $name;
}
}
/**
* Constructor
*
* @param array $config Configuration options
* @return void
*/
public function __construct($config = array())
{
$this->_db = App::get('db');
$this->args = '';
// Set the controller name
if (empty($this->_name)) {
if (isset($config['name'])) {
$this->_name = $config['name'];
} else {
// Get the reflection info
$r = new ReflectionClass($this);
// Is it namespaced?
if ($r->inNamespace()) {
// It is! This makes things easy.
$this->_name = strtolower($r->getShortName());
} else {
if (preg_match('/(.*)Macro/i', get_class($this), $r)) {
$this->_name = strtolower($r[1]);
} else {
throw new RuntimeException(__CLASS__ . '::__construct(); Can\'t get or parse class name.');
}
}
}
}
}
/**
* Return the path alias for the module the element belongs to based on its namespace
* (assumes elements exist in a namespace below the module namespace)
*
* @param BaseEventTypeElement $element
* @return string
*/
public function getElementModulePathAlias(\BaseEventTypeElement $element)
{
$r = new ReflectionClass($element);
if ($r->inNamespace()) {
$ns_parts = explode('\\', $r->getNamespaceName());
return implode('.', array_slice($ns_parts, 0, count($ns_parts) - 1));
}
return $this->modulePathAlias;
}
/**
* Expands class name into full name.
* @param string
* @return string full name
* @throws Nette\InvalidArgumentException
*/
public static function expandClassName($name, \ReflectionClass $rc)
{
if (empty($name)) {
throw new Nette\InvalidArgumentException('Class name must not be empty.');
} elseif ($name === 'self') {
return $rc->getName();
} elseif ($name[0] === '\\') {
// fully qualified name
return ltrim($name, '\\');
}
$uses =& self::$cache[$rc->getName()];
if ($uses === NULL) {
self::$cache = self::parseUseStatemenets(file_get_contents($rc->getFileName()), $rc->getName()) + self::$cache;
$uses =& self::$cache[$rc->getName()];
}
$parts = explode('\\', $name, 2);
if (isset($uses[$parts[0]])) {
$parts[0] = $uses[$parts[0]];
return implode('\\', $parts);
} elseif ($rc->inNamespace()) {
return $rc->getNamespaceName() . '\\' . $name;
} else {
return $name;
}
}
/**
* Parses internal PHP method modifiers (abstract, final, public, ...).
*
* @param \TokenReflection\ReflectionClass $class Parent class
*
* @return \TokenReflection\ReflectionMethod
*/
private function parseInternalModifiers(ReflectionClass $class)
{
$name = strtolower($this->name);
// In PHP 5.3.3+ the ctor can be named only __construct in namespaced classes
if ('__construct' === $name || (!$class->inNamespace() || PHP_VERSION_ID < 50303) && strtolower($class->getShortName()) === $name) {
$this->modifiers |= self::IS_CONSTRUCTOR;
} elseif ('__destruct' === $name) {
$this->modifiers |= self::IS_DESTRUCTOR;
} elseif ('__clone' === $name) {
$this->modifiers |= self::IS_CLONE;
}
if ($class->isInterface()) {
$this->modifiers |= InternalReflectionMethod::IS_ABSTRACT;
} else {
// Can be called statically, see http://svn.php.net/viewvc/php/php-src/branches/PHP_5_3/Zend/zend_API.c?revision=309853&view=markup#l1795
static $notAllowed = array('__clone' => true, '__tostring' => true, '__get' => true, '__set' => true, '__isset' => true, '__unset' => true);
if (!$this->isStatic() && !$this->isConstructor() && !$this->isDestructor() && !isset($notAllowed[$name])) {
$this->modifiers |= self::IS_ALLOWED_STATIC;
}
}
return $this;
}
<?php
namespace A\B;
class Foo
{
}
$function = new \ReflectionClass('stdClass');
var_dump($function->inNamespace());
var_dump($function->getName());
var_dump($function->getNamespaceName());
var_dump($function->getShortName());
$function = new \ReflectionClass('A\\B\\Foo');
var_dump($function->inNamespace());
var_dump($function->getName());
var_dump($function->getNamespaceName());
var_dump($function->getShortName());