public function load()
{
$files = $this->_getFiles();
$manifestRegistry = ZendL_Tool_Rpc_Manifest_Registry::getInstance();
$providerRegistry = ZendL_Tool_Rpc_Provider_Registry::getInstance();
$classesLoadedBefore = get_declared_classes();
$oldLevel = error_reporting(E_ALL | ~E_STRICT);
// remove strict so that other packages wont throw warnings
foreach ($files as $file) {
require_once $file;
}
error_reporting($oldLevel);
// restore old error level
$classesLoadedAfter = get_declared_classes();
$loadedClasses = array_diff($classesLoadedAfter, $classesLoadedBefore);
foreach ($loadedClasses as $loadedClass) {
$reflectionClass = new ReflectionClass($loadedClass);
if ($reflectionClass->implementsInterface('ZendL_Tool_Rpc_Manifest_Interface') && !$reflectionClass->isAbstract()) {
$manifestRegistry->addManifest($reflectionClass->newInstance());
}
if ($reflectionClass->implementsInterface('ZendL_Tool_Rpc_Provider_Interface') && !$reflectionClass->isAbstract()) {
$providerRegistry->addProvider($reflectionClass->newInstance());
}
}
}
/**
* @return object
*/
protected function createEntity()
{
if (!$this->entityClassReflection) {
$this->entityClassReflection = new \ReflectionClass($this->entityClassName);
}
return $this->entityClassReflection->newInstance();
}
public function display($url)
{
$data = (object) json_decode(file_get_contents('php://input'), true);
$reflection = new ReflectionClass($data->_type);
if ($reflection->isSubclassOf('DataSource')) {
$object = $reflection->newInstance();
$object->parameters()->{'root-element'} = 'data';
foreach ($data->_parameters as $key => $value) {
$object->parameters()->{$key} = $value;
}
$result = $object->render(new Register());
header('content-type: text/xml');
echo $result->saveXML();
exit;
}
if ($reflection->isSubclassOf('Event')) {
$object = $reflection->newInstance();
$object->parameters()->{'root-element'} = 'data';
foreach ($data->_parameters as $key => $value) {
$object->parameters()->{$key} = $value;
}
$result = $object->trigger(new Register(), (array) $data->_data);
header('content-type: text/xml');
echo $result->saveXML();
exit;
}
}
public static function getModuleInstanceByTypeAndName($sType, $sName)
{
if (!$sName) {
throw new Exception("Exception in Module::getModuleInstanceByTypeAndName(): module name is empty");
}
$sClassName = self::getClassNameByTypeAndName($sType, $sName);
if (!self::isModuleEnabled($sType, $sName)) {
throw new Exception("Exception in Module::getModuleInstanceByTypeAndName(): tried to instanciate disabled module {$sType}.{$sName}");
}
$aArgs = array_slice(func_get_args(), 2);
$oClass = new ReflectionClass($sClassName);
if ($sClassName::isSingleton()) {
if (!isset(self::$SINGLETONS[$sClassName])) {
try {
self::$SINGLETONS[$sClassName] = $oClass->newInstanceArgs($aArgs);
} catch (ReflectionException $ex) {
self::$SINGLETONS[$sClassName] = $oClass->newInstance();
}
}
return self::$SINGLETONS[$sClassName];
}
try {
return $oClass->newInstanceArgs($aArgs);
//Does not work in PHP < 5.1.3
} catch (ReflectionException $ex) {
return $oClass->newInstance();
//Does not work in PHP < 5.1.3
}
}
function test($class)
{
echo "====>{$class}\n";
try {
$ref = new ReflectionClass($class);
} catch (ReflectionException $e) {
var_dump($e->getMessage());
return;
// only here
}
echo "====>newInstance()\n";
try {
var_dump($ref->newInstance());
} catch (ReflectionException $e) {
var_dump($e->getMessage());
}
echo "====>newInstance(25)\n";
try {
var_dump($ref->newInstance(25));
} catch (ReflectionException $e) {
var_dump($e->getMessage());
}
echo "====>newInstance(25, 42)\n";
try {
var_dump($ref->newInstance(25, 42));
} catch (ReflectionException $e) {
var_dump($e->getMessage());
}
echo "\n";
}
/**
* Create validator
*
* @param $validator
* @return \Phalcon\Validation\ValidatorInterface
* @throws \Engine\Exception
*/
public function createValidator($validator)
{
if ($validator instanceof ValidatorInterface) {
return $validator;
} elseif (is_array($validator)) {
$origName = ucfirst($validator['validator']);
if ($class = $this->getValidatorClassName($origName)) {
if (empty($validator['options'])) {
$validator = new $class();
} else {
$r = new \ReflectionClass($class);
if ($r->hasMethod('__construct')) {
$validator = $r->newInstance($validator['options']);
} else {
$validator = $r->newInstance();
}
}
}
} elseif (is_string($validator)) {
$origName = ucfirst($validator);
if ($class = $this->getValidatorClassName($origName)) {
$validator = new $class();
}
} else {
throw new \Engine\Exception("Validator '{$validator}' not exists");
}
return $validator;
}
/**
* @param array|null $args
*
* @return object
*/
function invoke(array $args = null)
{
if ($args !== null) {
return $this->reflectionClass->newInstanceArgs($args);
}
return $this->reflectionClass->newInstance();
}
public function testGetSingle()
{
$singletags = ['br', 'clear', 'col', 'hr', 'xkcd'];
$method = $this->reflectionClass->getMethod('getSingle');
$this->parser = $this->reflectionClass->newInstance();
$this->assertEquals($singletags, $method->invoke($this->parser));
}
/**
*
* @param string $class
* @return BaseController
*/
protected function instantiateController($class)
{
$reflection = new \ReflectionClass($class);
if ($reflection->isSubclassOf('Tracker\\Controller\\BaseController')) {
return $reflection->newInstance($this->app);
}
return $reflection->newInstance();
}
/**
* Метод формирует экземпляр класса на основе строки.
* После будет применён фильтр, если он есть.
*
* @return object
*/
private function getInst(array $row)
{
if ($this->constructorParams) {
$args = $this->constructorParams;
$args[] = $row;
return $this->RC->newInstanceArgs($args);
} else {
return $this->RC->newInstance($row);
}
}
/**
* @see \RecursiveIterator:getChildren();
*/
public function getChildren()
{
if ($this->current() instanceof self) {
return $this->current();
}
if (empty($this->ref)) {
$this->ref = new \ReflectionClass($this);
}
return $this->ref->newInstance($this->current() . '/');
}
/**
* Creates a new instance for the class
*/
public static function createInstance($className, $args = [])
{
$reflection = new \ReflectionClass($className);
if ($reflection->implementsInterface('App\\Interfaces\\SingletonInterface')) {
if (isset(self::$singletones[$className])) {
return self::$singletones[$className];
} else {
$instance = $args ? $reflection->newInstanceArgs($args) : $reflection->newInstance();
self::$singletones[$className] = $instance;
}
} else {
$instance = $args ? $reflection->newInstanceArgs($args) : $reflection->newInstance();
}
return $instance;
}
/**
* @param mixed $id
* @param boolean $forceInstance Whether returns an empty instance when no result
*
* @return StaticEntity|null
*/
public function get($id, $forceInstance = false)
{
if (array_key_exists($id, $this->instances)) {
return $this->instances[$id];
} elseif (!($data = $this->getData($id))) {
return $forceInstance ? $this->reflection->newInstance() : null;
}
$this->instances[$id] = $this->reflection->newInstance();
foreach ($data as $property => $value) {
$reflectionProperty = $this->reflection->getProperty($property);
$reflectionProperty->setAccessible(true);
$reflectionProperty->setValue($this->instances[$id], $value);
}
return $this->instances[$id];
}
public function Deserialize($Root)
{
$result = null;
$counter = 0;
foreach ($Root as $member) {
$instance = new ReflectionClass($member->getName());
$ins = $instance->newInstance();
foreach ($member as $child) {
$rp = $instance->getMethod("set_" . $child->getName());
if (count($child->children()) == 0) {
$rp->invoke($ins, $child);
} else {
$rp->invoke($ins, $this->Deserialize($child->children()));
echo $child;
}
}
if (count($Root) == 1) {
return $ins;
} else {
$result[$counter] = $ins;
$counter++;
}
if ($counter == count($Root)) {
return $result;
}
}
}
/**
* Instantiates objects by class and id, respecting pattern implemented by given class
*
* @param string $class Class name
* @param $id
* @return unknown_type
*/
public static function instantiate($class, $id = null)
{
if (!strlen($class)) {
require_once 'Oops/Exception.php';
throw new Oops_Exception("Empty class name given");
}
if (!Oops_Loader::find($class)) {
require_once 'Oops/Exception.php';
throw new Oops_Exception("Class '{$class}' not found");
}
$reflectionClass = new ReflectionClass($class);
if ($reflectionClass->implementsInterface('Oops_Pattern_Identifiable_Factored_Interface')) {
/**
* Object can be instantiated using corresponding factory
*/
$factoryCallback = call_user_func($class, 'getFactoryCallback');
$result = call_user_func($factoryCallback, $id);
} elseif ($reflectionClass->implementsInterface('Oops_Pattern_Identifiable_Singleton_Interface')) {
/**
* This object can be instantiated using $class::getInstance($id)
*/
$result = call_user_func(array($class, 'getInstance'), $id);
} elseif ($reflectionClass->implementsInterface('Oops_Pattern_Singleton_Interface')) {
/**
* This object is the single available instance of this class, so it can be instantiated using $class::getInstance()
*/
$result = call_user_func(array($class, 'getInstance'));
} else {
/**
* This type of object should be constructed with given $id
*/
$result = $reflectionClass->newInstance($id);
}
return $result;
}
protected function setUp()
{
$this->wrapper = m::mock('Raideer\\TwitchApi\\Wrapper');
$this->wrapper->shouldReceive('registerResource')->with('Raideer\\TwitchApi\\Resources\\Resource');
$resourceReflection = new \ReflectionClass($this->resourceName);
$this->resource = $resourceReflection->newInstance($this->wrapper);
}
/**
* @return ControllerResponse
* @throws Page404Exception
* @throws RuntimeMvcException
*/
public function execute()
{
$class = $this->getControllerClass();
try {
$reflectionClass = new \ReflectionClass($class);
if ($reflectionClass->implementsInterface(ControllerInterface::class)) {
/** @var ControllerInterface $controller */
$controller = $reflectionClass->newInstance();
$controller->setReflectionClass($reflectionClass);
$this->getResponse()->setControllerInstance($controller);
$controller->setDi($this->container);
$reflectionMethod = new \ReflectionMethod($class, $this->getActionCamelize());
$controller->setReflectionAction($reflectionMethod);
$controller->setNamespace($this->getNamespace());
$controller->setName($this->getController());
$controller->setAction($this->getAction());
$controller->setParams($this->getParams());
$controller->beforeExecute();
$this->response->setControllerContent($reflectionMethod->invokeArgs($controller, $this->getParams()));
$controller->afterExecute();
$this->container->get('event')->dispatch(MvcEvent::ON_AFTER_RUN, new MvcEvent($controller));
} else {
throw new RuntimeMvcException('Controller found but it should implemented interface [:name]', ['name' => ControllerInterface::class]);
}
} catch (\ReflectionException $exception) {
$this->container->get('event')->dispatch(MvcEvent::ON_PAGE_404, new MvcEvent($this));
$this->container->get('event')->dispatch(MvcEvent::ON_ACTION_ERROR, new MvcEvent($exception));
throw new Page404Exception($exception->getMessage());
} catch (\Exception $exception) {
$this->container->get('event')->dispatch(MvcEvent::ON_ACTION_ERROR, new MvcEvent($exception));
throw new RuntimeMvcException($exception->getMessage());
}
return $this->response;
}
protected static function getEntityManager($options)
{
$config = new \Doctrine\ORM\Configuration();
// Handling for class names specified as platform types.
if ($options['conn']['platform']) {
$class_obj = new \ReflectionClass($options['conn']['platform']);
$options['conn']['platform'] = $class_obj->newInstance();
}
// Special handling for the utf8mb4 type.
if ($options['conn']['driver'] == 'pdo_mysql' && $options['conn']['charset'] == 'utf8mb4') {
$options['conn']['platform'] = new \DF\Doctrine\Platform\MysqlUnicode();
}
$metadata_driver = $config->newDefaultAnnotationDriver($options['modelPath']);
$config->setMetadataDriverImpl($metadata_driver);
$cache = new \DF\Doctrine\Cache();
// $cache->setNamespace('doctrine_');
$config->setMetadataCacheImpl($cache);
$config->setQueryCacheImpl($cache);
$config->setResultCacheImpl($cache);
$config->setProxyDir($options['proxyPath']);
$config->setProxyNamespace($options['proxyNamespace']);
if (isset($options['conn']['debug']) && $options['conn']['debug']) {
$config->setSQLLogger(new \DF\Doctrine\Logger\EchoSQL());
}
$config->addFilter('softdelete', '\\DF\\Doctrine\\Filter\\SoftDelete');
$config->addCustomNumericFunction('RAND', '\\DF\\Doctrine\\Functions\\Rand');
$evm = new \Doctrine\Common\EventManager();
$em = \Doctrine\ORM\EntityManager::create($options['conn'], $config, $evm);
$em->getFilters()->enable("softdelete");
// Try the connection before rendering the page.
$em->getConnection()->connect();
return $em;
}
/**
* @dataProvider getClass
*/
public function testGetterAndSetter($class, $constructorParameterList)
{
$reflexionClass = new \ReflectionClass($class);
if ($reflexionClass->getConstructor()) {
$instance = $reflexionClass->newInstanceArgs($constructorParameterList);
} else {
$instance = $reflexionClass->newInstance();
}
$propertyList = $reflexionClass->getProperties();
foreach ($propertyList as $property) {
$name = ucfirst($property->getName());
$property->setAccessible(true);
$getter = 'get' . $name;
$setter = 'set' . $name;
if ($reflexionClass->hasMethod($setter)) {
$type = $this->guessParamType($reflexionClass->getMethod($setter));
if (isset($this->valueList[$type])) {
$value = $this->valueList[$type];
$instance->{$setter}($value[0]);
// test setter
$this->assertEquals($property->getValue($instance), $value[0]);
if ($reflexionClass->hasMethod($getter)) {
$property->setValue($instance, $value[1]);
// test getter
$this->assertEquals($instance->{$getter}(), $value[1]);
}
}
}
}
}
public function dispatch(\Ctv\Route\Route $router, $response)
{
$controllerName = ucwords($router->getParams('controller'));
$namespace = ucwords($router->getParams('App')) . '\\Controller\\' . $controllerName;
if (\Ctv\Autoloader\App::validate($namespace)) {
$reflection = new \ReflectionClass($namespace);
if ($reflection->hasMethod($router->getParams('action'))) {
$method = $reflection->getMethod($router->getParams('action'));
$controller = $reflection->newInstance($router, $response);
if ($args = $router->getParams('args')) {
$method->invokeArgs($controller, $args);
} else {
$method->invoke($controller);
}
$this->__callOutPut($controller);
//$this->close();
} else {
echo outformat($namespace, 'trace');
echo outformat($router, 'trace');
echo $router;
die('Method not exists' . $namespace);
}
} else {
echo $namespace . 'error 404';
}
die;
}
public function create(ProviderModel $provider)
{
$eventDispatcher = $this->getEventDispatcher();
$event = new CreateProviderEvent($provider);
$eventDispatcher->dispatch(EVENT_XNAVIGATION_CREATE_PROVIDER, $event);
if ($event->getProvider()) {
return $event->getProvider();
}
$row = $provider->row();
$type = $provider->type;
$className = $this->getProviderClassName($type);
$class = new \ReflectionClass($className);
$subscriber = $class->newInstance();
$rgxp = '~^' . preg_quote($type, '~') . '_(.*)$~';
foreach ($row as $key => $value) {
if ($value && preg_match($rgxp, $key, $matches)) {
$property = $matches[1];
$property = explode('_', $property);
$property = array_map('ucfirst', $property);
$property = implode('', $property);
$setterName = 'set' . $property;
if ($class->hasMethod($setterName)) {
$setter = $class->getMethod($setterName);
$setter->invoke($subscriber, $value);
}
}
}
return $subscriber;
}
/**
* Set captcha adapter
*
* @param string|array|Zend_Captcha_Adapter $captcha
* @param array $options
*/
public function setCaptcha($captcha, $options = array())
{
if ($captcha instanceof Zend_Captcha_Adapter) {
$instance = $captcha;
} else {
if (is_array($captcha)) {
if (array_key_exists('captcha', $captcha)) {
$name = $captcha['captcha'];
unset($captcha['captcha']);
} else {
$name = array_shift($captcha);
}
$options = array_merge($options, $captcha);
} else {
$name = $captcha;
}
$name = $this->getPluginLoader(self::CAPTCHA)->load($name);
if (empty($options)) {
$instance = new $name();
} else {
$r = new ReflectionClass($name);
if ($r->hasMethod('__construct')) {
$instance = $r->newInstanceArgs(array($options));
} else {
$instance = $r->newInstance();
}
}
}
$this->_captcha = $instance;
$this->_captcha->setName($this->getName());
return $this;
}
/**
* 创建该类型的实例，并从指定对象或数组上复制属性
* @param object|array $src 原始对象或数组
* @return object
*/
static function create($src)
{
$class = new ReflectionClass(get_called_class());
$target = $class->newInstance();
ObjectUtil::copyProperties($src, $target);
return $target;
}
/**
* Constructor
*
* @param string|object $base_class Class name of the base class, or an instance
* @param array $constructor_args (Optional) Arguments to pass to the constructor of the base class
* @param array $constants (Optional) Constants to override
*/
public function __construct($base_class, array $constructor_args = array(), array $constants = array())
{
// @codeCoverageIgnoreStart
if (PHP_VERSION_ID < 50300) {
trigger_error(get_class() . ': This class requires PHP version 5.3 or higher.', E_USER_ERROR);
}
// @codeCoverageIgnoreEnd
if (is_object($base_class) && count($constructor_args)) {
throw new Mollie_Testing_Exception('Unused constructor arguments for passed instance of "' . get_class($base_class) . '".');
}
// If it's an instance, just accept it
if (is_object($base_class)) {
$this->_base_class = $base_class;
} elseif (!class_exists($base_class)) {
throw new Mollie_Testing_Exception("Base class '{$base_class}' does not exist.");
} else {
$ref = new ReflectionClass($base_class);
if ($ref->isAbstract()) {
$ref = new ReflectionClass($this->createDerivedClass($base_class));
}
if ($ref->getConstructor() && count($constructor_args) < $ref->getConstructor()->getNumberOfRequiredParameters()) {
throw new Mollie_Testing_Exception($ref->getConstructor()->getNumberOfRequiredParameters() . " constructor arguments required for '{$base_class}::__construct(...)'.");
}
$this->_base_class = sizeof($constructor_args) ? $ref->newInstanceArgs($constructor_args) : $ref->newInstance();
}
}
/**
* @see Lumine_Validator_AbstractValidator::execute()
*/
public function execute(Lumine_Base $obj)
{
$value = $this->getFieldValue($obj);
$reflection = new ReflectionClass($obj->metadata()->getClassname());
/* @var $objeto Lumine_Base */
$objeto = $reflection->newInstance();
$objeto->{$this->getField()} = $obj->{$this->getField()};
$objeto->find();
$pks = $objeto->metadata()->getPrimaryKeys();
$result = true;
while ($objeto->fetch()) {
foreach ($pks as $def) {
if ($objeto->{$def}['name'] != $obj->{$def}['name']) {
$result = false;
break;
}
}
if (!$result) {
break;
}
}
$objeto->destroy();
unset($objeto, $reflection);
return $result;
}
/**
* Whatever Data is returned by Hanlder, should be an array will be rendered as array on response
*
* @param AbstractUser $user
* @param array $controllerInfo
* @param String $handlerName
*/
function rx_interceptor_json($user, $controllerInfo, $handlerName)
{
$user->validate();
include_once RUDRA . "/core/handler/AbstractHandler.php";
$handlerInfo = ClassUtil::getHandler($handlerName);
if ($handlerInfo != NULL) {
global $temp;
include_once $handlerInfo["filePath"];
$className = $handlerInfo["className"];
$tempClass = new ReflectionClass($className);
if ($tempClass->isInstantiable()) {
$temp = $tempClass->newInstance();
}
if ($temp != NULL) {
try {
if ($tempClass->hasMethod("invokeHandler")) {
$resp = call_method_by_class($tempClass, $temp, 'invokeHandler', array('user' => $user, 'data' => new RequestData(get_request_param("data"))), $handlerInfo["requestParams"]);
if (isset($resp)) {
echo json_encode($resp);
}
}
} catch (Exception $e) {
echo json_encode(array("error" => $e));
}
}
}
}
/**
* Framework runner, create object from User Application Controller
*
* Instance call init() and isMapTrue(). If isMapTrue is True, it will return method name.
*/
public static function execute()
{
$class_controller = Service::$active_controller;
if ($class = new ReflectionClass($class_controller)) {
$object = $class->newInstance();
$object->init();
$request_method = $object->getRequestMethod();
$request_uri = $object->getRequestURI();
if ($action = $object->isMapTrue($request_method, $request_uri)) {
$data = $class->getMethod($action)->invoke($object);
$object->reply($data);
} else {
$object->setRestResponse('406', 'application/xml');
$data = "<application>\n";
$data .= "<error>Not Acceptible. Action Method Not Found</error>\n";
$data .= "</application>\n";
$object->reply($data);
}
} else {
$object->setRestResponse('400', 'application/xml');
$data = "<application>\n";
$data .= "<error>Bad Request</error>\n";
$data .= "</application>\n";
$object->reply($data);
}
}
public function parse_string($template, $data = array(), $return = FALSE, $config = array())
{
if (!is_array($config)) {
$config = array();
}
$config = array_merge($this->config, $config);
$ci = $this->ci;
$is_mx = false;
if (!$return) {
list($ci, $is_mx) = $this->detect_mx();
}
$parser_reflection = new ReflectionClass('Leafo\\ScssPhp\\Compiler');
$parser = $parser_reflection->newInstance();
$parser->setImportPaths($config['import_paths']);
$parser->setNumberPrecision($config['number_precision']);
$formatter = $config['formatter'];
if (!in_array($formatter, $this->allowed_formatters)) {
$formatter = 'expanded';
}
$formatter = 'Leafo\\ScssPhp\\Formatter\\' . ucfirst($formatter);
$parser->setFormatter($formatter);
$parser->setLineNumberStyle($config['line_number_style']);
$template = $parser->compile($template);
return $this->output($template, $return, $ci, $is_mx);
}
/**
* Resolves the target of the route and returns a callable.
*
* @param mixed $target
* @param array $construct_args
*
* @throws RuntimeException If the target is not callable
*
* @return callable
*/
private static function getCallable($target, array $construct_args)
{
if (is_string($target)) {
//is a class "classname::method"
if (strpos($target, '::') === false) {
$class = $target;
$method = '__invoke';
} else {
list($class, $method) = explode('::', $target, 2);
}
if (!class_exists($class)) {
throw new RuntimeException("The class {$class} does not exists");
}
$fn = new \ReflectionMethod($class, $method);
if (!$fn->isStatic()) {
$class = new \ReflectionClass($class);
$instance = $class->hasMethod('__construct') ? $class->newInstanceArgs($construct_args) : $class->newInstance();
$target = [$instance, $method];
}
}
//if it's callable as is
if (is_callable($target)) {
return $target;
}
throw new RuntimeException('The route target is not callable');
}
/**
* call back for mocking the object factory
* @return object fixture objects ...
* @author Robert Lemke <*****@*****.**>
*/
public function objectManagerCallback()
{
$arguments = array_merge(func_get_args(), array($this->mockObjectManager));
$objectName = array_shift($arguments);
$class = new \ReflectionClass($objectName);
return $class->getConstructor() !== null ? $class->newInstanceArgs($arguments) : $class->newInstance();
}
