/** * Exports the PHP code * * @return string */ public function exportCode() { $code_lines = array(); $code_lines[] = '<?php'; // Export the namespace if ($this->_reflection_class->getNamespaceName()) { $code_lines[] = ''; $code_lines[] = 'namespace ' . $this->_reflection_class->getNamespaceName() . ';'; $code_lines[] = ''; } // Export the class' signature $code_lines[] = sprintf('%s%s%s %s%s%s', $this->_reflection_class->isAbstract() ? 'abstract ' : '', $this->_reflection_class->isFinal() ? 'final ' : '', $this->_reflection_class->isInterface() ? 'interface' : ($this->_reflection_class->isTrait() ? 'trait' : 'class'), $this->getClassName(), $this->_getParentClassName() ? " extends {$this->_getParentClassName()}" : '', $this->_getInterfaceNames() ? " implements " . join(', ', $this->_getInterfaceNames()) : ''); $code_lines[] = '{'; $code_lines[] = ''; // Export constants foreach ($this->_reflection_class->getConstants() as $name => $value) { $reflection_constant = new ReflectionConstant($name, $value); $code_lines[] = "\t" . $reflection_constant->exportCode(); $code_lines[] = ''; } // Export properties foreach ($this->_reflection_class->getProperties() as $property) { $reflection_property = new ReflectionProperty($property); $code_lines[] = "\t" . $reflection_property->exportCode(); $code_lines[] = ''; } // Export methods foreach ($this->_reflection_class->getMethods() as $method) { $reflection_method = new ReflectionMethod($method); $code_lines[] = "\t" . $reflection_method->exportCode(); $code_lines[] = ''; } $code_lines[] = '}'; return join("\n", $code_lines); }
/** * Get current object type * @return string - class/trait/interface */ public function getType() { if ($this->reflectionClass->isInterface()) { return 'interface'; } if (method_exists($this->reflectionClass, 'isTrait') && $this->reflectionClass->isTrait()) { return 'trait'; } return 'class'; }
/** * @param \Donquixote\HastyReflectionCommon\Canvas\ClassIndex\ClassIndexInterface $classIndex * @param string $class * * @dataProvider provideClassIndexArgs() */ function testClassIndex(ClassIndexInterface $classIndex, $class) { $classReflection = $classIndex->classGetReflection($class); $reflectionClass = new \ReflectionClass($class); // Test identity. $this->assertTrue($classReflection === $classIndex->classGetReflection($class)); // Test class type/info. $expectedIsClass = !$reflectionClass->isInterface() && !$reflectionClass->isTrait(); $this->assertEquals($reflectionClass->getName(), $classReflection->getName()); $this->assertEquals($reflectionClass->getShortName(), $classReflection->getShortName()); $this->assertEquals($reflectionClass->getDocComment(), $classReflection->getDocComment()); $this->assertEquals($reflectionClass->isInterface(), $classReflection->isInterface()); $this->assertEquals($reflectionClass->isTrait(), $classReflection->isTrait()); $this->assertEquals($expectedIsClass, $classReflection->isClass()); $this->assertEquals($reflectionClass->isAbstract() && $expectedIsClass, $classReflection->isAbstractClass()); // Test context. $this->assertEquals($reflectionClass->getNamespaceName(), $classReflection->getNamespaceUseContext()->getNamespaceName()); // Test interfaces foreach ($classReflection->getOwnInterfaces() as $interfaceName => $interfaceReflection) { $this->assertTrue($reflectionClass->implementsInterface($interfaceName)); } foreach ($reflectionClass->getInterfaceNames() as $interfaceName) { $this->assertTrue($classReflection->extendsOrImplementsInterface($interfaceName, FALSE)); } $expectedAllInterfaceNames = $expectedAllAndSelfInterfaceNames = $reflectionClass->getInterfaceNames(); if ($reflectionClass->isInterface()) { array_unshift($expectedAllAndSelfInterfaceNames, $class); } $this->assertEqualSorted($expectedAllAndSelfInterfaceNames, array_keys($classReflection->getAllInterfaces(TRUE))); $this->assertEqualSorted($expectedAllInterfaceNames, array_keys($classReflection->getAllInterfaces(FALSE))); $expectedMethodNames = array(); $expectedOwnMethodNames = array(); foreach ($reflectionClass->getMethods() as $method) { $expectedMethodNames[] = $method->getName(); if ($method->getDeclaringClass()->getName() === $reflectionClass->getName()) { $expectedOwnMethodNames[] = $method->getName(); } } $this->assertEquals($expectedOwnMethodNames, array_keys($classReflection->getOwnMethods())); $this->assertEqualSorted($expectedMethodNames, array_keys($classReflection->getMethods())); $methodReflections = $classReflection->getMethods(); foreach ($reflectionClass->getMethods() as $reflectionMethod) { $methodReflection = $methodReflections[$reflectionMethod->getShortName()]; $this->assertEqualMethods($reflectionMethod, $methodReflection); } // isAbstract() is a beast, so we test it least. $this->assertEquals($reflectionClass->isAbstract(), $classReflection->isAbstract()); }
private static function _createClassCode($decoratee_class, $decorator_class, $events_handler) { $reflection = new ReflectionClass($decoratee_class); if ($reflection->isInterface()) { $relation = "implements"; } else { $relation = "extends"; } $code = "class {$decorator_class} {$relation} {$decoratee_class} {" . PHP_EOL; $code .= $events_handler->onDeclareProperties() . PHP_EOL; $code .= " function __construct() {" . PHP_EOL; //dealing with proxied class' public properties foreach ($reflection->getProperties() as $property) { if ($property->isPublic()) { $code .= 'unset($this->' . $property->getName() . ");" . PHP_EOL; } } $code .= " \$args = func_get_args();" . PHP_EOL; $code .= $events_handler->onConstructor() . PHP_EOL; $code .= " }" . PHP_EOL; $code .= self::_createHandlerCode($decoratee_class, $decorator_class, $events_handler) . PHP_EOL; $code .= "}" . PHP_EOL; //var_dump($code); return $code; }
/** * Filter classes. * * @param \ReflectionClass $class Class to filter. * * @throws FilterException */ public function filter(\ReflectionClass $class) { $name = $class->getShortName(); if ($class->isAbstract() || $class->isInterface() || !(strlen($name) > 4 && substr($name, -4) === 'Test')) { throw new FilterException(sprintf('TestCase was filtered by "%s" filter.', $this->getName())); } }
protected function getFile($file, $classToCheck = null) { if (!file_exists($file)) { throw new ShopException("File {$file} not found"); } if (!is_readable($file)) { throw new ShopException("File {$file} exists, but it's not readable"); } require_once $file; if ($classToCheck === 'Product') { $classToCheck = array('ConfigurableProduct', 'SimpleProduct'); } if ($classToCheck) { if (!is_array($classToCheck)) { $classToCheck = array($classToCheck); } foreach ($classToCheck as $class) { $reflection = new ReflectionClass($class); if (!$reflection->isInstantiable()) { if (!$reflection->isAbstract() && !$reflection->isInterface()) { throw new ShopException("{$class} class is not instantiable"); } } } } }
/** * @param \ReflectionClass $class * @return string * @throws IoException */ public function loadTemplateForClass(\ReflectionClass $class) { if ($class->isInterface()) { return $this->loadFile($this->templateDir . 'Interface.php.template'); } return $this->loadFile($this->templateDir . 'Class.php.template'); }
/** * @param $rpcRequest \RpcGateway\Request * @throws \Exception */ protected function throwErrorIfRpcRequestIsInvalid($rpcRequest) { $serviceMethodName = $rpcRequest->getMethodName(); // create a PHP compatible version of the requested service class $serviceClassName = $this->getServiceClassNamespace() . str_replace(Request::METHOD_DELIMITER, '_', $rpcRequest->getClassName()); try { class_exists($serviceClassName); } catch (\Exception $exception) { throw new \Exception("Invalid rpc.method [" . $rpcRequest->getMethod() . "] (not found) at " . __METHOD__); } $serviceClassReflection = new \ReflectionClass($serviceClassName); if ($serviceClassReflection->isAbstract() || $serviceClassReflection->isInterface() || $serviceClassReflection->isInternal()) { throw new \Exception("Invalid rpc.class [" . $rpcRequest->getMethod() . "] at " . __METHOD__); } if ($serviceClassReflection->hasMethod($serviceMethodName) !== true) { throw new \Exception("Invalid rpc.method [" . $rpcRequest->getMethod() . "] (not found) at " . __METHOD__); } $serviceMethodReflection = $serviceClassReflection->getMethod($serviceMethodName); if ($serviceMethodReflection->isAbstract() || $serviceMethodReflection->isConstructor() || $serviceMethodReflection->isStatic() || !$serviceMethodReflection->isPublic()) { throw new \Exception("Invalid rpc.method [" . $rpcRequest->getMethod() . "] (not invokable) at " . __METHOD__); } $argsExpectedMin = $serviceMethodReflection->getNumberOfRequiredParameters(); $argsExpectedMax = $serviceMethodReflection->getNumberOfParameters(); $argsOptional = $argsExpectedMax - $argsExpectedMin; $argsGiven = count($rpcRequest->getParams()); if ($argsGiven < $argsExpectedMin || $argsGiven > $argsExpectedMax) { $msg = 'Invalid rpc.method [' . $rpcRequest->getMethod() . ']' . " Wrong number of parameters:" . " " . $argsGiven . " given" . " (required: " . $argsExpectedMin . " optional: " . $argsOptional . ")" . " expectedMin: " . $argsExpectedMin . " expectedMax: " . $argsExpectedMax; throw new Exception($msg); } }
/** * Identify concrete extensible interface name based on the class name. * * @param string $extensibleClassName * @return string */ public function getExtensibleInterfaceName($extensibleClassName) { $exceptionMessage = "Class '{$extensibleClassName}' must implement an interface, " . "which extends from '" . self::EXTENSIBLE_INTERFACE_NAME . "'"; $notExtensibleClassFlag = ''; if (isset($this->classInterfaceMap[$extensibleClassName])) { if ($notExtensibleClassFlag === $this->classInterfaceMap[$extensibleClassName]) { throw new \LogicException($exceptionMessage); } else { return $this->classInterfaceMap[$extensibleClassName]; } } $modelReflection = new \ReflectionClass($extensibleClassName); if ($modelReflection->isInterface() && $modelReflection->isSubClassOf(self::EXTENSIBLE_INTERFACE_NAME) && $modelReflection->hasMethod('getExtensionAttributes')) { $this->classInterfaceMap[$extensibleClassName] = $extensibleClassName; return $this->classInterfaceMap[$extensibleClassName]; } foreach ($modelReflection->getInterfaces() as $interfaceReflection) { if ($interfaceReflection->isSubclassOf(self::EXTENSIBLE_INTERFACE_NAME) && $interfaceReflection->hasMethod('getExtensionAttributes')) { $this->classInterfaceMap[$extensibleClassName] = $interfaceReflection->getName(); return $this->classInterfaceMap[$extensibleClassName]; } } $this->classInterfaceMap[$extensibleClassName] = $notExtensibleClassFlag; throw new \LogicException($exceptionMessage); }
public function compile() { foreach (PluginRepository::findAll() as $plugin) { $containerBuilder = new UnfreezableContainerBuilder(); $containerBuilder->registerExtension(new GeneralExtension()); $extensionClass = new \ReflectionClass('Stagehand\\TestRunner\\DependencyInjection\\Extension\\' . $plugin->getPluginID() . 'Extension'); if (!$extensionClass->isInterface() && !$extensionClass->isAbstract() && $extensionClass->isSubclassOf('Symfony\\Component\\DependencyInjection\\Extension\\ExtensionInterface')) { $containerBuilder->registerExtension($extensionClass->newInstance()); } foreach ($containerBuilder->getExtensions() as $extension) { /* @var $extension \Symfony\Component\DependencyInjection\Extension\ExtensionInterface */ $containerBuilder->loadFromExtension($extension->getAlias(), array()); } $containerBuilder->addCompilerPass(new ReplaceDefinitionByPluginDefinitionPass($plugin)); $containerBuilder->getCompilerPassConfig()->setOptimizationPasses(array_filter($containerBuilder->getCompilerPassConfig()->getOptimizationPasses(), function (CompilerPassInterface $compilerPass) { return !$compilerPass instanceof ResolveParameterPlaceHoldersPass; })); ErrorReporting::invokeWith(error_reporting() & ~E_USER_DEPRECATED, function () use($containerBuilder) { $containerBuilder->compile(); }); $phpDumper = new PhpDumper($containerBuilder); $containerClass = $plugin->getPluginID() . 'Container'; $containerClassSource = $phpDumper->dump(array('class' => $containerClass)); $containerClassSource = preg_replace('/^<\\?php/', '<?php' . PHP_EOL . 'namespace ' . self::COMPILED_CONTAINER_NAMESPACE . ';' . PHP_EOL, $containerClassSource); file_put_contents(__DIR__ . '/../' . $containerClass . '.php', $containerClassSource); } }
/** * Finds installable records from the models folder. * * @return array */ public function findInstallableRecords() { $records = array(); $recordsFolder = craft()->path->getAppPath() . 'records/'; $recordFiles = IOHelper::getFolderContents($recordsFolder, false, ".*Record\\.php\$"); foreach ($recordFiles as $file) { if (IOHelper::fileExists($file)) { $fileName = IOHelper::getFileName($file, false); $class = __NAMESPACE__ . '\\' . $fileName; // Ignore abstract classes and interfaces $ref = new \ReflectionClass($class); if ($ref->isAbstract() || $ref->isInterface()) { Craft::log("Skipping record {$file} because it’s abstract or an interface.", LogLevel::Warning); continue; } $obj = new $class('install'); if (method_exists($obj, 'createTable')) { $records[] = $obj; } else { Craft::log("Skipping record {$file} because it doesn’t have a createTable() method.", LogLevel::Warning); } } else { Craft::log("Skipping record {$file} because it doesn’t exist.", LogLevel::Warning); } } return $records; }
/** * @param \ReflectionClass|string * @return self */ public static function from($from) { $from = new \ReflectionClass($from instanceof \ReflectionClass ? $from->getName() : $from); if (PHP_VERSION_ID >= 70000 && $from->isAnonymous()) { $class = new static('anonymous'); } else { $class = new static($from->getShortName(), new PhpNamespace($from->getNamespaceName())); } $class->type = $from->isInterface() ? 'interface' : (PHP_VERSION_ID >= 50400 && $from->isTrait() ? 'trait' : 'class'); $class->final = $from->isFinal() && $class->type === 'class'; $class->abstract = $from->isAbstract() && $class->type === 'class'; $class->implements = $from->getInterfaceNames(); $class->documents = $from->getDocComment() ? array(preg_replace('#^\\s*\\* ?#m', '', trim($from->getDocComment(), "/* \r\n\t"))) : array(); if ($from->getParentClass()) { $class->extends = $from->getParentClass()->getName(); $class->implements = array_diff($class->implements, $from->getParentClass()->getInterfaceNames()); } foreach ($from->getProperties() as $prop) { if ($prop->getDeclaringClass()->getName() === $from->getName()) { $class->properties[$prop->getName()] = Property::from($prop); } } foreach ($from->getMethods() as $method) { if ($method->getDeclaringClass()->getName() === $from->getName()) { $class->methods[$method->getName()] = Method::from($method)->setNamespace($class->namespace); } } return $class; }
public function testCheckInterfaceExtending() { $refl = new \ReflectionClass('Test\\ExtendedInterface'); $this->assertTrue($refl->isInterface()); $this->assertContains('IteratorAggregate', $refl->getInterfaceNames()); $this->assertContains('Countable', $refl->getInterfaceNames()); }
function classData(ReflectionClass $class) { $details = ""; $name = $class->getName(); if ($class->isUserDefined()) { $details .= "{$name} is user defined\n"; } if ($class->isInternal()) { $details .= "{$name} is built-in\n"; } if ($class->isInterface()) { $details .= "{$name} is interface\n"; } if ($class->isAbstract()) { $details .= "{$name} is an abstract class\n"; } if ($class->isFinal()) { $details .= "{$name} is a final class\n"; } if ($class->isInstantiable()) { $details .= "{$name} can be instantiated\n"; } else { $details .= "{$name} can not be instantiated\n"; } return $details; }
/** * Check if all classes given by the cli are instantiable. */ public function run() { $classNames = array_keys($this->_args); //No classes given if (!$classNames) { exit(1); } //Perform single checks for the classes foreach ($classNames as $className) { $reflectionClass = new ReflectionClass($className); //Is an interface? if ($reflectionClass->isInterface()) { echo "Interface"; exit(1); } //Is an abstract class? if ($reflectionClass->isAbstract()) { echo "Abstract"; exit(1); } //Is a trait? if ($reflectionClass->isTrait()) { echo "Trait"; exit(1); } //Can create the class with new? if (!$reflectionClass->isInstantiable()) { echo "Not instantiable"; exit(1); } } echo 'Done'; }
public function __construct(\ReflectionClass $interface) { if (!$interface->isInterface() || $interface->isTrait()) { throw new \InvalidArgumentException('Only interfaces supported'); } parent::__construct($interface); }
public final function getMockClassHeader(ReflectionClass $class, $test_double_class_name, array $interfaces, array $traits) { $extends = ''; if ($class->isInterface()) { $interfaces[] = $class->getName(); } else { $extends = 'extends ' . $class->getName(); } $interfaces_str = $interfaces ? 'implements ' . implode(', ', $interfaces) : ''; $traits[] = 'FBMock_TestDoubleObject'; $traits_str = 'use ' . implode(', ', $traits) . ';'; $doc_block = ''; if (FBMock_Utils::isHHVM()) { // Allows mocking final classes and methods. // CAUTION: this implementation is subject to change, avoid using outside // of FBMock $doc_block = '<< __MockClass >>'; } return sprintf(<<<'EOT' %s class %s %s %s { %s EOT , $doc_block, $test_double_class_name, $extends, $interfaces_str, $traits_str); }
/** * Generates a new class with the given class name * * @param string $newClassName - The name of the new class * @param string $mockedClassName - The name of the class being mocked * @param Phake_Mock_InfoRegistry $infoRegistry * @return NULL */ public function generate($newClassName, $mockedClassName, Phake_Mock_InfoRegistry $infoRegistry) { $extends = ''; $implements = ''; $interfaces = array(); $constructor = ''; $mockedClass = new ReflectionClass($mockedClassName); if (!$mockedClass->isInterface()) { $extends = "extends {$mockedClassName}"; } elseif ($mockedClassName != 'Phake_IMock') { $implements = ", {$mockedClassName}"; if ($mockedClass->implementsInterface('Traversable') && !$mockedClass->implementsInterface('Iterator') && !$mockedClass->implementsInterface('IteratorAggregate')) { if ($mockedClass->getName() == 'Traversable') { $implements = ', Iterator'; } else { $implements = ', Iterator' . $implements; } $interfaces = array('Iterator'); } } $classDef = "\nclass {$newClassName} {$extends}\n\timplements Phake_IMock {$implements}\n{\n public \$__PHAKE_info;\n\n public static \$__PHAKE_staticInfo;\n\n\tconst __PHAKE_name = '{$mockedClassName}';\n\n\tpublic \$__PHAKE_constructorArgs;\n\n\t{$constructor}\n\n\t/**\n\t * @return void\n\t */\n\tpublic function __destruct() {}\n\n \t{$this->generateSafeConstructorOverride($mockedClass)}\n\n\t{$this->generateMockedMethods($mockedClass, $interfaces)}\n}\n"; $this->loader->loadClassByString($newClassName, $classDef); $newClassName::$__PHAKE_staticInfo = $this->createMockInfo($mockedClassName, new Phake_CallRecorder_Recorder(), new Phake_Stubber_StubMapper(), new Phake_Stubber_Answers_NoAnswer()); $infoRegistry->addInfo($newClassName::$__PHAKE_staticInfo); }
protected function _checkProtection($protectionType) { // Check type if (!is_string($protectionType) || $protectionType != self::PROTECTION_CSRF && $protectionType != self::PROTECTION_CAPTCHA && $protectionType != self::PROTECTION_BRUTEFORCE && $protectionType != self::PROTECTION_XSS) { throw new \Exception('Invalid protection type : "' . $protectionType . '"'); } // Check class if (class_exists('framework\\security\\form\\' . ucfirst($protectionType))) { $className = 'framework\\security\\form\\' . ucfirst($protectionType); } else { $className = $protectionType; } $class = new \ReflectionClass($className); if (!in_array('framework\\security\\IForm', $class->getInterfaceNames())) { throw new \Exception('Form protection drivers must be implement framework\\security\\IForm'); } if ($class->isAbstract()) { throw new \Exception('Form protection drivers must be not abstract class'); } if ($class->isInterface()) { throw new \Exception('Form protection drivers must be not interface'); } $classInstance = $class->newInstanceWithoutConstructor(); $constuctor = new \ReflectionMethod($classInstance, '__construct'); if ($constuctor->isPrivate() || $constuctor->isProtected()) { throw new \Exception('Protection constructor must be public'); } return $className; }
/** * @static * @throws phpMorphy_Exception * @param string $decorateeClass * @param string|null $decoratorClass * @param null|phpMorphy_Generator_Decorator_HandlerInterface $handler * @return string */ static function generate($decorateeClass, $decoratorClass = null, phpMorphy_Generator_Decorator_HandlerInterface $handler = null) { if (!class_exists($decorateeClass) && !interface_exists($decorateeClass)) { throw new phpMorphy_Exception("Class '{$decorateeClass}' not found"); } if (null === $decoratorClass) { $decoratorClass = self::getDecoratorClassName($decorateeClass); } $helper = new phpMorphy_Generator_ReflectionHelper(); if (null === $handler) { $handler = new phpMorphy_Generator_Decorator_HandlerDefault(); } $classref = new ReflectionClass($decorateeClass); // generateHeaderPhpDoc header $buffer = $handler->generateHeaderDocComment($decorateeClass, $decoratorClass) . PHP_EOL . PHP_EOL; $parents = null; $interfaces = null; if ($classref->isInterface()) { $interfaces = array($decorateeClass); } else { $parents = array($decorateeClass); } // generateHeaderPhpDoc class declaration $buffer .= $handler->generateClassDeclaration($classref->getDocComment(), $decoratorClass, $parents, $interfaces); // generateHeaderPhpDoc common methods $buffer .= ' {' . PHP_EOL . $handler->generateCommonMethods($decoratorClass, $decorateeClass) . PHP_EOL . PHP_EOL; // generateHeaderPhpDoc wrapped methods foreach ($helper->getOverridableMethods($classref) as $method) { $buffer .= $handler->generateMethod($method->getDocComment(), $helper->generateMethodModifiers($method, ReflectionMethod::IS_ABSTRACT), $method->returnsReference(), $method->getName(), $helper->generateMethodArguments($method), $helper->generateArgsPass($method)) . PHP_EOL . PHP_EOL; } $buffer .= '}' . PHP_EOL; return $buffer; }
/** * Get controller to use, either plugin controller or application controller * * @param \Cake\Network\Request $request Request object * @param \Cake\Network\Response $response Response for the controller. * @return mixed name of controller if not loaded, or object if loaded */ protected function _getController($request, $response) { $pluginPath = $controller = null; $namespace = 'Controller'; if (!empty($request->params['plugin'])) { $pluginPath = $request->params['plugin'] . '.'; } if (!empty($request->params['controller'])) { $controller = $request->params['controller']; } if (!empty($request->params['prefix'])) { $prefixes = array_map('Cake\\Utility\\Inflector::camelize', explode('/', $request->params['prefix'])); $namespace .= '/' . implode('/', $prefixes); } $className = false; if ($pluginPath . $controller) { $className = App::classname($pluginPath . $controller, $namespace, 'Controller'); } if (!$className) { return false; } $reflection = new \ReflectionClass($className); if ($reflection->isAbstract() || $reflection->isInterface()) { return false; } return $reflection->newInstance($request, $response, $controller); }
function __autoload($className) { if (function_exists('smartyAutoload') and smartyAutoload($className)) { return true; } $className = str_replace(chr(0), '', $className); $classDir = dirname(__FILE__) . '/../classes/'; $overrideDir = dirname(__FILE__) . '/../override/classes/'; $file_in_override = file_exists($overrideDir . $className . '.php'); $file_in_classes = file_exists($classDir . $className . '.php'); // This is a Core class and its name is the same as its declared name if (substr($className, -4) == 'Core') { require_once $classDir . substr($className, 0, -4) . '.php'; } else { if ($file_in_override && $file_in_classes) { require_once $classDir . str_replace(chr(0), '', $className) . '.php'; require_once $overrideDir . $className . '.php'; } elseif (!$file_in_override && $file_in_classes) { require_once $classDir . str_replace(chr(0), '', $className) . '.php'; $classInfos = new ReflectionClass($className . ((interface_exists($className, false) or class_exists($className, false)) ? '' : 'Core')); if (!$classInfos->isInterface() && substr($classInfos->name, -4) == 'Core') { eval(($classInfos->isAbstract() ? 'abstract ' : '') . 'class ' . $className . ' extends ' . $className . 'Core {}'); } } elseif ($file_in_override && !$file_in_classes) { require_once $overrideDir . $className . '.php'; } } }
/** * @return string */ public function getTitle() { if ($this->_classReflector->isInterface()) { $prefix = 'Interface'; } elseif ($this->_classReflector->isFinal()) { $prefix = 'Final class'; } elseif ($this->_classReflector->isAbstract()) { $prefix = 'Abstract class'; } else { $prefix = 'Class'; } $rstClassName = str_replace("\\", "\\\\", $this->_className); $rstTitle = "{$prefix} **{$rstClassName}**" . PHP_EOL; $rstTitle .= str_repeat('=', strlen($rstTitle) - strlen(PHP_EOL)) . PHP_EOL . PHP_EOL; return $rstTitle; }
protected function addInterface($fqcn) { $added = new \ReflectionClass($fqcn); if (!$added->isInterface()) { throw new \LogicException("{$fqcn} is not an interface"); } $this->interfaceList[] = $added; }
/** * @test */ public function testCommon() { $reflection = new \ReflectionClass('Upwork\\API\\Interfaces\\Client'); $this->assertTrue($reflection->isInterface()); $this->assertTrue($reflection->hasMethod('auth')); $this->assertTrue($reflection->hasMethod('request')); $this->assertTrue($reflection->hasMethod('setupRequestToken')); }
static function getInterfaces($name) { $reflection = new ReflectionClass($name); if ($reflection->isInterface()) { return array($name); } return self::_onlyParents($reflection->getInterfaces()); }
/** * Whether instance is concrete implementation * * @param string $type * @return bool */ public function isConcrete($type) { try { $instance = new \ReflectionClass($type); } catch (\ReflectionException $e) { return false; } return !$instance->isAbstract() && !$instance->isInterface(); }
public function __construct(\ReflectionClass $reflectionClass, \ReflectionProperty $reflectionProperty) { $reflectionProperty->setAccessible(true); if (strpos($reflectionProperty->getDocComment(), "@skipSerialization") !== false) { $this->isSkipped = true; } if (strpos($reflectionProperty->getDocComment(), "@var") === false) { throw new PropertyTypeWasNotDefined($reflectionClass->getName(), $reflectionProperty->getName()); } if (preg_match('/@var\\s+([^\\s]+)/', $reflectionProperty->getDocComment(), $matches)) { list(, $type) = $matches; $types = explode("|", $type); if (!empty($types)) { foreach ($types as $type) { if ($pos = strpos($type, '[]')) { $this->isArray = true; $type = substr($type, 0, $pos); } if (class_exists($type)) { // Object $this->types[] = $type; $typeReflectionClass = new \ReflectionClass($type); if (!$typeReflectionClass->isInterface() && !$typeReflectionClass->isAbstract()) { $this->isObject = $type; } } else { $typeCheck = $reflectionClass->getNamespaceName() . '\\' . $type; if (class_exists($typeCheck)) { // Object $this->types[] = $typeCheck; $typeReflectionClass = new \ReflectionClass($typeCheck); if (!$typeReflectionClass->isInterface() && !$typeReflectionClass->isAbstract()) { $this->isObject = $typeCheck; } } else { $aliases = $this->getAliases($reflectionClass->getFileName()); if (array_key_exists($type, $aliases) && class_exists($aliases[$type])) { $type = $aliases[$type]; // Object $this->types[] = $type; $typeReflectionClass = new \ReflectionClass($type); if (!$typeReflectionClass->isInterface() && !$typeReflectionClass->isAbstract()) { $this->isObject = $type; } } else { $this->types[] = $type = null; } } } } array_unique($this->types); } } $this->reflectionClass = $reflectionClass; $this->reflectionProperty = $reflectionProperty; }
private static function loadAllPlugins() { foreach (Finder::create()->name('/^.+Plugin\\.php$/')->files()->in(__DIR__) as $file) { /* @var $file \SplFileInfo */ $pluginClass = new \ReflectionClass(__NAMESPACE__ . '\\' . $file->getBasename('.php')); if (!$pluginClass->isInterface() && !$pluginClass->isAbstract() && $pluginClass->isSubclassOf('Stagehand\\TestRunner\\Core\\Plugin\\IPlugin')) { self::$plugins[] = $pluginClass->newInstance(); } } }
public function auto_fill() { $test_case = new \ReflectionClass('ztest\\TestCase'); foreach (get_declared_classes() as $class_name) { $r = new \ReflectionClass($class_name); if ($r->isSubclassOf($test_case) && !$r->isInterface() && !$r->isAbstract()) { $this->add_test(new $class_name()); } } }