Example #1
0
 public function __construct(DiInterface $di, $class)
 {
     if (!is_string($class) && !is_object($class)) {
         throw new Exception("第二个参数只能接受字符串或对象");
     }
     $this->_di = $di;
     $this->_class = new ReflectionClass($class);
     if (is_object($class)) {
         $this->_instance = $class;
     } elseif (is_string($class) && !$this->_class->isInstantiable()) {
         throw new Exception("不能对一个无法实例化的类进行注入");
     }
     $this->_interfaceNames = $this->_class->getInterfaceNames();
 }
Example #2
0
 public static function run()
 {
     // run setup and prepare env
     static::setup();
     // handle the requested uri
     $uri = static::parse();
     $segments = array();
     if (strlen($uri)) {
         $segments = explode('/', $uri);
     }
     // lets log our translated uri
     Log::info('Translated URI: ' . $uri);
     // set our action or our default if none is set
     $action = count($segments) ? array_shift($segments) : 'page';
     // default to our front end router
     $controller = 'Routes';
     // set the template path
     $theme = Config::get('metadata.theme');
     Template::path(PATH . 'themes/' . $theme . '/');
     // remove admin as an argument and set the default action if there isnt one
     if ($action == 'admin') {
         // set default controller for the admin
         $controller = (count($segments) ? array_shift($segments) : 'posts') . '_controller';
         // set default action
         $action = count($segments) ? array_shift($segments) : 'index';
         // public admin actions
         $public = array('users/login', 'users/amnesia', 'users/reset');
         // redirect to login
         if (Users::authed() === false and in_array(trim($controller, '_controller') . '/' . $action, $public) === false) {
             return Response::redirect(Config::get('application.admin_folder') . '/users/login');
         }
         // set template path for admin
         Template::path(PATH . 'system/admin/theme/');
     }
     // log the controller we are going to use and the action
     Log::info('Controller action: ' . $controller . '/' . $action);
     // check we can find a action
     $reflector = new ReflectionClass($controller);
     if ($reflector->isInstantiable() === false or $reflector->hasMethod($action) === false) {
         // default back to front end template for 404 page
         Template::path(PATH . 'themes/' . $theme . '/');
         // report error
         Log::warning($reflector->isInstantiable() === false ? 'Controller was not Instantiable' : 'Action does not exist');
         // method not found in controller
         return Response::error(404);
     }
     $reflector->getMethod($action)->invokeArgs(new $controller(), $segments);
 }
Example #3
0
 public function doaction($name)
 {
     if (isset(self::$action_info[$name])) {
         try {
             global $plugin;
             //var_dump(self::$action_info);
             if (file_exists(dirname(__FILE__) . "/{$plugin}/" . self::$action_info[$name]['file'])) {
                 include_once dirname(__FILE__) . "/{$plugin}/" . self::$action_info[$name]['file'];
             }
             if (isset(self::$action_info[$name]['class'])) {
                 $classname = self::$action_info[$name]['class'];
                 $class = new ReflectionClass($classname);
                 if ($class->isInstantiable()) {
                     $methodname = self::$action_info[$name]['method'];
                     $method = $class->newInstance();
                     $path = $method->{$methodname}();
                     //global $plugin;
                     header("Location: " . $plugin . "/" . self::$action_info[$name]['returns'][$path]);
                     //require(dirname(__file__)."../../".self::$action_info[$name]['returns'][$path]);
                 }
             } else {
                 $method = self::$action_info[$name]['method'];
                 $path = $method();
                 global $plugin;
                 header("Location: " . $plugin . "/" . self::$action_info[$name]['returns'][$path]);
             }
         } catch (Exception $e) {
             echo "在反射解释{$name} 出现错误\n";
         }
     } else {
         header("Location: help/noaction.html");
     }
 }
Example #4
0
 /**
  * Get Global Application CMS accessibility scope.
  *
  * @access public
  * @static
  * @uses   Core\Config()
  *
  * @return array
  */
 public static function getAccessibilityScope()
 {
     $scope = glob(Core\Config()->paths('mode') . 'controllers' . DIRECTORY_SEPARATOR . '*.php');
     $builtin_scope = array('CMS\\Controllers\\CMS');
     $builtin_actions = array();
     $accessibility_scope = array();
     foreach ($builtin_scope as $resource) {
         $builtin_actions = array_merge($builtin_actions, get_class_methods($resource));
     }
     $builtin_actions = array_filter($builtin_actions, function ($action) {
         return !in_array($action, array('create', 'show', 'edit', 'delete', 'export'), true);
     });
     foreach ($scope as $resource) {
         $resource = basename(str_replace('.php', '', $resource));
         if ($resource !== 'cms') {
             $controller_name = '\\CMS\\Controllers\\' . $resource;
             $controller_class = new \ReflectionClass($controller_name);
             if (!$controller_class->isInstantiable()) {
                 continue;
             }
             /* Create instance only if the controller class is instantiable */
             $controller_object = new $controller_name();
             if ($controller_object instanceof CMS\Controllers\CMS) {
                 $accessibility_scope[$resource] = array_diff(get_class_methods($controller_name), $builtin_actions);
                 array_push($accessibility_scope[$resource], 'index');
                 foreach ($accessibility_scope[$resource] as $key => $action_with_acl) {
                     if (in_array($action_with_acl, $controller_object->skipAclFor, true)) {
                         unset($accessibility_scope[$resource][$key]);
                     }
                 }
             }
         }
     }
     return $accessibility_scope;
 }
Example #5
0
 public function run()
 {
     foreach (Finder::findFiles('*Test.php')->from(__DIR__) as $fileInfo) {
         /** @var \SplFileInfo $fileInfo*/
         $baseName = $fileInfo->getBasename('.php');
         if ($baseName === 'PhpRQTest') {
             continue;
         }
         $className = 'PhpRQ\\' . $baseName;
         $reflection = new \ReflectionClass($className);
         if (!$reflection->isInstantiable()) {
             continue;
         }
         foreach ($reflection->getMethods() as $method) {
             if (!$method->isPublic() || strpos($methodName = $method->getName(), 'test') === false) {
                 continue;
             }
             $phpdoc = $method->getDocComment();
             if ($phpdoc !== false && ($providerPos = strpos($phpdoc, '@dataProvider')) !== false) {
                 $providerMethodPos = $providerPos + 14;
                 $providerMethodLen = strpos($phpdoc, "\n", $providerMethodPos) - $providerMethodPos;
                 $providerMethod = substr($phpdoc, $providerMethodPos, $providerMethodLen);
                 $testCase = new $className($this->provider->getRedisClient());
                 foreach ($testCase->{$providerMethod}() as $args) {
                     $testCase = new $className($this->provider->getRedisClient());
                     call_user_func_array([$testCase, $methodName], (array) $args);
                 }
             } else {
                 $testCase = new $className($this->provider->getRedisClient());
                 $testCase->{$methodName}();
             }
         }
     }
 }
Example #6
0
function find_classes($input, $recursive = true)
{
    $classes = array();
    if (is_file($input)) {
        if (preg_match('/\\.php$/', $input)) {
            $classes = determine_classes($input);
        }
    } elseif (is_dir($input)) {
        $iter = null;
        if ($recursive) {
            $iter = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($input), RecursiveIteratorIterator::LEAVES_ONLY);
        } else {
            $iter = new DirectoryIterator($input);
        }
        foreach ($iter as $i) {
            if ($i->isFile()) {
                if (preg_match('/\\.php$/', $i)) {
                    $found = determine_classes($i->getPathname());
                    $classes = array_merge($classes, $found);
                }
            }
        }
    }
    $classes = array_unique($classes);
    $found = array();
    foreach ($classes as $c) {
        $rc = new \ReflectionClass($c);
        if ($rc->isInstantiable()) {
            $found[] = $c;
        }
    }
    return $found;
}
Example #7
0
 /**
  * 自动绑定(Autowiring)自动解析(Automatic Resolution)
  *
  * @param string $className
  * @return object
  * @throws Exception
  */
 public function build($className)
 {
     var_dump($className);
     // 如果是匿名函数(Anonymous functions),也叫闭包函数(closures)
     if ($className instanceof \Closure) {
         // 执行闭包函数,并将结果
         return $className($this);
     }
     /** @var ReflectionClass $reflector */
     $reflector = new \ReflectionClass($className);
     // 检查类是否可实例化, 排除抽象类abstract和对象接口interface
     if (!$reflector->isInstantiable()) {
         throw new Exception("Can't instantiate this.");
     }
     /** @var ReflectionMethod $constructor 获取类的构造函数 */
     $constructor = $reflector->getConstructor();
     // 若无构造函数,直接实例化并返回
     if (is_null($constructor)) {
         return new $className();
     }
     // 取构造函数参数,通过 ReflectionParameter 数组返回参数列表
     $parameters = $constructor->getParameters();
     // 递归解析构造函数的参数
     $dependencies = $this->getDependencies($parameters);
     // 创建一个类的新实例,给出的参数将传递到类的构造函数。
     return $reflector->newInstanceArgs($dependencies);
 }
Example #8
0
 /**
  * @param $name
  * @return mixed
  * @throws \Exception
  */
 public function getInstance($name)
 {
     if (!is_string($name)) {
         throw new \Exception('Name must be a string');
     }
     $name = rtrim($name, '\\');
     if (isset($this->instance[$name])) {
         return $this->instance[$name]();
     } else {
         $reflectionClass = new \ReflectionClass($name);
         if (!$reflectionClass->isInstantiable()) {
             throw new \Exception('Class ' . $name . ' is not instantiable');
         }
         $constructor = $reflectionClass->getConstructor();
         if (!is_null($constructor)) {
             $parameters = $constructor->getParameters();
             $params = $this->getReflectionParametersValues($parameters);
         } else {
             $params = array();
         }
         $this->setInstance($name, function () use($reflectionClass, $params) {
             return $reflectionClass->newInstanceArgs($params);
         });
         return $this->getInstance($name);
     }
 }
 /**
  * Returns the definition as string representation.
  *
  * @return string
  */
 public function dump(ObjectDefinition $definition)
 {
     $className = $definition->getClassName();
     $classExist = class_exists($className) || interface_exists($className);
     // Class
     if (!$classExist) {
         $warning = '#UNKNOWN# ';
     } else {
         $class = new \ReflectionClass($className);
         $warning = $class->isInstantiable() ? '' : '#NOT INSTANTIABLE# ';
     }
     $str = sprintf('    class = %s%s', $warning, $className);
     // Scope
     $str .= PHP_EOL . '    scope = ' . $definition->getScope();
     // Lazy
     $str .= PHP_EOL . '    lazy = ' . var_export($definition->isLazy(), true);
     if ($classExist) {
         // Constructor
         $str .= $this->dumpConstructor($className, $definition);
         // Properties
         $str .= $this->dumpProperties($definition);
         // Methods
         $str .= $this->dumpMethods($className, $definition);
     }
     return sprintf('Object (' . PHP_EOL . '%s' . PHP_EOL . ')', $str);
 }
Example #10
0
function find_handler($path)
{
    global $g_maps;
    $route_path = substr($path, 5);
    if ($g_maps && isset($g_maps[$route_path])) {
        $object = $g_maps[$route_path]['class'];
        $action = $g_maps[$route_path]['method'];
    } else {
        if (preg_match('/^\\/rest\\/(\\w+)\\/(\\w+)\\/?[^\\/]*$/i', $path, $ret)) {
            $object = $ret[1];
            $action = $ret[2];
        }
    }
    if (isset($object) && isset($action)) {
        try {
            $class_file = CLASSES_PATH . "/{$object}.php";
            if (file_exists($class_file)) {
                require_once $class_file;
                $class = new ReflectionClass($object);
                if ($class->isInstantiable()) {
                    return array('class' => $class->newInstance(), 'method' => new ReflectionMethod($object, $action));
                }
            }
        } catch (Exception $e) {
        }
    }
    return null;
}
Example #11
0
 /**
  * get callable methods within the classObj
  *
  * @param string|object $classObj
  * @param int $filter
  * @param bool $filterOwn
  * @return array array of \ReflectionMethod
  */
 public function getCallableMethods($classObj, $filter, $filterOwn = true)
 {
     if (is_string($classObj) && !class_exists($classObj, false)) {
         throw new ClassNotDefinedException('Class name: ' . $classObj . ' not defined yet!');
     }
     $className = $classObj;
     if (is_object($classObj)) {
         $className = get_class($classObj);
     }
     $reflectClass = new \ReflectionClass($classObj);
     $methods = array();
     if (!$reflectClass->isUserDefined() || !$reflectClass->isInstantiable()) {
         return $methods;
     }
     $methods = $reflectClass->getMethods($filter);
     if ($filterOwn) {
         $needNeaten = false;
         foreach ($methods as $k => $method) {
             if ($method->class != $className) {
                 unset($methods[$k]);
                 !$needNeaten && ($needNeaten = true);
             }
         }
         $needNeaten && ($methods = array_values($methods));
     }
     return $methods;
 }
 /**
  * @param object $entity
  *
  * @return MetaInformation
  *
  * @throws \RuntimeException if no declaration for document found in $entity
  */
 public function loadInformation($entity)
 {
     $className = $this->getClass($entity);
     if (!is_object($entity)) {
         $reflectionClass = new \ReflectionClass($className);
         if (!$reflectionClass->isInstantiable()) {
             throw new \RuntimeException(sprintf('cannot instantiate entity %s', $className));
         }
         $entity = $reflectionClass->newInstanceWithoutConstructor();
     }
     if (!$this->annotationReader->hasDocumentDeclaration($entity)) {
         throw new \RuntimeException(sprintf('no declaration for document found in entity %s', $className));
     }
     $metaInformation = new MetaInformation();
     $metaInformation->setEntity($entity);
     $metaInformation->setClassName($className);
     $metaInformation->setDocumentName($this->getDocumentName($className));
     $metaInformation->setFieldMapping($this->annotationReader->getFieldMapping($entity));
     $metaInformation->setFields($this->annotationReader->getFields($entity));
     $metaInformation->setRepository($this->annotationReader->getRepository($entity));
     $metaInformation->setIdentifier($this->annotationReader->getIdentifier($entity));
     $metaInformation->setBoost($this->annotationReader->getEntityBoost($entity));
     $metaInformation->setSynchronizationCallback($this->annotationReader->getSynchronizationCallback($entity));
     $metaInformation->setIndex($this->annotationReader->getDocumentIndex($entity));
     $metaInformation->setIsDoctrineEntity($this->annotationReader->isDoctrineEntity($entity));
     return $metaInformation;
 }
Example #13
0
 /**
  * Load the resource map
  *
  * @return $this
  */
 public function loadResourceMap()
 {
     $dirIterator = new \RecursiveDirectoryIterator($this->path->getDir('vendor/devvoh/parable/src'), \RecursiveDirectoryIterator::SKIP_DOTS);
     $iteratorIterator = new \RecursiveIteratorIterator($dirIterator);
     foreach ($iteratorIterator as $path => $file) {
         /** @var \SplFileInfo $file */
         /*
          * Specifically exclude all non-php files and Bootstrap, since it will attempt to register everything again
          * and isn't a class anyway.
          */
         if ($file->getFilename() === 'Bootstrap.php' || $file->getFilename() === 'parable.php' || $file->getExtension() !== 'php' || strpos($file->getRealPath(), '/Cli/') !== false) {
             continue;
         }
         $className = str_replace('.' . $file->getExtension(), '', $file->getFilename());
         $fullClassName = str_replace($this->path->getDir('vendor/devvoh/parable/src'), '', $file->getRealPath());
         $fullClassName = str_replace('.' . $file->getExtension(), '', $fullClassName);
         $fullClassName = str_replace('/', '\\', 'Parable' . $fullClassName);
         $reflectionClass = new \ReflectionClass($fullClassName);
         if (!$reflectionClass->isInstantiable()) {
             continue;
         }
         $this->resourceMap[$className] = $fullClassName;
     }
     return $this;
 }
 /**
  * Returns an array of variants.
  *
  * With no arguments, returns all variants
  *
  * With a classname as the first argument, returns the variants that apply to that class
  * (optionally including subclasses)
  *
  * @static
  * @param string $class - The class name to get variants for
  * @param bool $includeSubclasses - True if variants should be included if they apply to at least one subclass of $class
  * @return array - An array of (string)$variantClassName => (Object)$variantInstance pairs
  */
 public static function variants($class = null, $includeSubclasses = true)
 {
     if (!$class) {
         if (self::$variants === null) {
             $classes = ClassInfo::subclassesFor('SearchVariant');
             $concrete = array();
             foreach ($classes as $variantclass) {
                 $ref = new ReflectionClass($variantclass);
                 if ($ref->isInstantiable()) {
                     $variant = singleton($variantclass);
                     if ($variant->appliesToEnvironment()) {
                         $concrete[$variantclass] = $variant;
                     }
                 }
             }
             self::$variants = $concrete;
         }
         return self::$variants;
     } else {
         $key = $class . '!' . $includeSubclasses;
         if (!isset(self::$class_variants[$key])) {
             self::$class_variants[$key] = array();
             foreach (self::variants() as $variantclass => $instance) {
                 if ($instance->appliesTo($class, $includeSubclasses)) {
                     self::$class_variants[$key][$variantclass] = $instance;
                 }
             }
         }
         return self::$class_variants[$key];
     }
 }
Example #15
0
 public function test__construct()
 {
     $metadata = new ClassMetadata(__NAMESPACE__ . '\\ModelTest');
     $metadata->addModel('entity', __NAMESPACE__ . '\\EntityTest');
     $metadata->setIdentifier('entity', 'id');
     $metadataFactory = $this->getMock('Pok\\PoolDBM\\Mapping\\ClassMetadataFactory', array('getMetadataFor', 'setModelManager'));
     $metadataFactory->expects($this->any())->method('getMetadataFor')->will($this->returnValue($metadata));
     $refl = new \ReflectionClass('Pok\\PoolDBM\\Manager\\BaseManager');
     $this->assertTrue($refl->isInstantiable());
     $pool = new Pool();
     $pool->addManager('entity', new EntityManager());
     $manager = new TestManager(__NAMESPACE__ . '\\ModelTest', new ModelManager($pool, $metadataFactory));
     $this->assertInstanceOf('Pok\\PoolDBM\\ModelRepository', $manager->getRepository($manager));
     $this->assertInstanceOf(__NAMESPACE__ . '\\ModelTest', $manager->create());
     $manager->save(new ModelTest());
     $manager->save(new ModelTest(), true);
     try {
         $manager->save(new \stdClass());
     } catch (\RuntimeException $e) {
         $this->assertEquals('Manager "Pok\\PoolDBM\\Tests\\Manager\\TestManager" is unable to save model "stdClass"', $e->getMessage());
     }
     $manager->clear();
     $this->assertInstanceOf(__NAMESPACE__ . '\\ModelTest', $manager->find(null));
     $this->assertEquals(1, count($manager->findBy(array())));
     $this->assertInstanceOf(__NAMESPACE__ . '\\ModelTest', $manager->findOneBy(array()));
     $this->assertEquals(1, count($manager->findAll()));
 }
Example #16
0
 public function load()
 {
     $queries = $this->path . '/queries.php';
     $script = $this->path . '/script.php';
     if (file_exists($queries)) {
         $sql = null;
         include $queries;
         if (is_array($sql)) {
             $this->queries = $sql;
         }
     }
     if (file_exists($script)) {
         include_once $script;
         $suffix = str_replace('-', '_', baseName($this->path));
         $class = 'Nano_Migrate_Script_' . $suffix;
         if (class_exists($class, false)) {
             $reflection = new ReflectionClass($class);
             if ($reflection->isInstantiable() && $reflection->isSubclassOf('Nano_Migrate_Script')) {
                 $this->script = $reflection->newInstance();
             } else {
                 $this->script = Nano_Migrate_ScriptEmpty::instance();
             }
         } else {
             $this->script = Nano_Migrate_ScriptEmpty::instance();
         }
     } else {
         $this->script = Nano_Migrate_ScriptEmpty::instance();
     }
 }
 public function fetchObject($className = "stdClass", $args = null)
 {
     $data = $this->fetchAll();
     $callback = $args;
     if (!is_callable($callback) || $args === null) {
         // Кастомная обработка аргументов
         $callback = function ($data, $className, $args = null) {
             $items = [];
             $class = new \ReflectionClass($className);
             foreach ((array) $data as $item) {
                 $values = [];
                 if ($args === null) {
                     $values = array_keys($data[0]);
                 } else {
                     foreach ((array) $args as $arg) {
                         $values[] = $item[$arg];
                     }
                 }
                 // Создаем класс и передаем в конструктор значения выборки
                 if ($class->isInstantiable()) {
                     $items[] = $class->newInstanceArgs($values);
                 }
             }
             return $items;
         };
     }
     return $callback($this->ci, $data, $className, $args);
 }
Example #18
0
 public static function get($alias, $options = array(), $force_new = false)
 {
     if (isset(self::$singleton[$alias]) && !$force_new) {
         return self::$singleton[$alias];
     }
     if (!isset(self::$map[$alias])) {
         return null;
     }
     $resolver = self::$map[$alias]['resolver'];
     if (is_string($resolver)) {
         $reflection = new \ReflectionClass($resolver);
         // Verifica si se puede instanciar la clase
         if (!$reflection->isInstantiable()) {
             throw new \Exception($alias . " The class is not instantiable");
         }
         // Verifica si tiene un constructor
         $constructor = $reflection->getConstructor();
         if (is_null($constructor)) {
             return new $resolver();
         }
         $parameters = $constructor->getParameters();
         if (count($parameters)) {
             throw new \Exception($alias . " The class requires parameters");
         }
     } elseif ($resolver instanceof \Closure) {
         if (!is_array($options)) {
             echo "{$alias} {$options}";
         }
         $object = $resolver($options);
     }
     if (self::$map[$alias]['new'] == false) {
         self::$singleton[$alias] = $object;
     }
     return $object;
 }
Example #19
0
 /**
  * Creates or gets an instance for class with class
  *
  * *Additional args* can be passed to this method. In this case they will be used to instantiate
  * the new class. If new class is instance of {@link AbsPluginSingleton} or {@link AbsCoreSingleton}
  * then additional args will be discarded. If class to be instantiated has $plugin property then the plugin
  * instance is added to the head of additional args. In that case the class constructor should have `Plugin $plugin`
  * argument first.
  *
  * **IMPORTANT** If class is instance of {@link AbsPluginSingleton} or {@link AbsCoreSingleton} then
  * {@link AbsPluginSingleton::getInstance()} or {@link AbsCoreSingleton::getInstance()}
  * is used. In that case any additional args will be discarded. If this is not the case then a new
  * instance of class is returned.
  *
  * @param string $className baseNamespace must be omitted. eg. `$className = 'MyBaseNamespaceChildren\MyClass'
  *
  * @return object An instance of [baseNamespace]\$className
  * @throws Exception If class not found or isn't instantiable or is plugin class has same name as one in core and
  *                   doesn't extend this core class.
  * @author Panagiotis Vagenas <*****@*****.**>
  * @since  0.0.2
  */
 public function createOrGet($className)
 {
     if ($this->existsInPlugin($className)) {
         if ($this->coreClassExists($className) && !$this->isCoreExtension($className)) {
             throw new Exception('Classes that have core name should ALWAYS extend core classes. Class name: ' . $className);
         }
         $class = $this->getPluginClassName($className);
     } elseif ($this->coreClassExists($className)) {
         $class = $this->getCoreClassName($className);
     } else {
         throw new Exception('Class ' . $className . ' doesn\'t seem to exists!');
     }
     $args = func_get_args();
     array_shift($args);
     $reflection = new \ReflectionClass($class);
     if (!$reflection || !($reflection->isSubclassOf($this->getCoreClassNameFromBase('Abs\\AbsPluginSingleton')) || $reflection->isSubclassOf($this->getCoreClassNameFromBase('Abs\\AbsCoreSingleton'))) && !$reflection->isInstantiable()) {
         throw new Exception('Trying to instantiate non-instantiable class ' . $class);
     }
     if ($reflection->isSubclassOf($this->getCoreClassNameFromBase('Abs\\AbsPluginSingleton'))) {
         /* @var AbsPluginSingleton $class */
         $instance = $class::getInstance($this->plugin);
     } elseif ($reflection->isSubclassOf($this->getCoreClassNameFromBase('Abs\\AbsCoreSingleton'))) {
         /* @var AbsCoreSingleton $class */
         $instance = $class::getInstance();
     } else {
         if ($reflection->hasProperty('plugin') && (empty($args) || isset($args[0]) && !$args[0] instanceof Plugin)) {
             array_unshift($args, $this->plugin);
         }
         $instance = $reflection->newInstanceArgs($args);
     }
     return $instance;
 }
Example #20
0
 /**
  * @param string $base_class A parent class or interface.
  * @param bool $callback Optionally, don't call the register callback to construct the results array.
  * @param bool $use_constructor Optionally, get a class-instance via constructor - potentially UNSAFE!
  * @return array Array of result classes, optionally keyed.
  */
 public function match($base_class, $callback = true, $use_constructor = false)
 {
     $results = array();
     //foreach ($this as $class) {
     foreach ($this->classes as $class) {
         if (is_subclass_of($class, $base_class)) {
             if ($callback) {
                 try {
                     $obj = null;
                     if ($use_constructor) {
                         $obj = new $class();
                     } else {
                         $reflect = new \ReflectionClass($class);
                         // Ignore abstract classes.
                         if ($reflect->isInstantiable()) {
                             $obj = $reflect->newInstanceWithoutConstructor();
                         }
                     }
                     if ($obj) {
                         $obj->{self::REGISTER_FN}($results);
                     }
                 } catch (\ReflectionException $e) {
                     $this->debug('Warning! (RF) ' . $e->getMessage());
                 } catch (\Exception $e) {
                     $this->debug('Warning! ' . $e->getMessage());
                 }
                 //Was: $results[ $class::{ $callback }() ] = $class;
             } else {
                 $results[] = $class;
             }
         }
     }
     return $results;
 }
Example #21
0
/**
 *  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));
            }
        }
    }
}
Example #22
0
 /**
  *
  */
 public function buildService($serviceCode, $definitions)
 {
     // Make sure the service has a definition
     if (array_key_exists($serviceCode, $definitions) === false) {
         \z\e(EXCEPTION_SERVICE_NOT_FOUND, ['serviceCode' => $serviceCode, 'definitions' => $definitions]);
     }
     // Get the definition
     $definition = $definitions[$serviceCode];
     // If the definition is an object
     // Return it as such
     if (is_object($definition) === true) {
         return $definition;
     }
     // Otherwise, it's a classname
     $className = $definition;
     // Make sure the class exists
     if (class_exists($className) === false) {
         \z\e(EXCEPTION_SERVICE_NOT_FOUND, ['serviceCode' => $serviceCode, 'className' => $className]);
     }
     // Make sure the class is instantiable
     $reflection = new \ReflectionClass($className);
     if ($reflection->isInstantiable() === false) {
         \z\e(EXCEPTION_SERVICE_NOT_INSTANTIABLE, ['serviceCode' => $serviceCode, 'className' => $className]);
     }
     // Create the service
     $service = new $className();
     return $service;
 }
 /**
  * {@inheritdoc}
  */
 public function dump(Definition $definition)
 {
     if (!$definition instanceof ObjectDefinition) {
         throw new \InvalidArgumentException(sprintf('This definition dumper is only compatible with ObjectDefinition objects, %s given', get_class($definition)));
     }
     $className = $definition->getClassName();
     $classExist = class_exists($className) || interface_exists($className);
     // Class
     if (!$classExist) {
         $warning = '#UNKNOWN# ';
     } else {
         $class = new \ReflectionClass($className);
         $warning = $class->isInstantiable() ? '' : '#NOT INSTANTIABLE# ';
     }
     $str = sprintf('    class = %s%s', $warning, $className);
     // Scope
     $str .= PHP_EOL . "    scope = " . $definition->getScope();
     // Lazy
     $str .= PHP_EOL . "    lazy = " . var_export($definition->isLazy(), true);
     if ($classExist) {
         // Constructor
         $str .= $this->dumpConstructor($className, $definition);
         // Properties
         $str .= $this->dumpProperties($definition);
         // Methods
         $str .= $this->dumpMethods($className, $definition);
     }
     return sprintf("Object (" . PHP_EOL . "%s" . PHP_EOL . ")", $str);
 }
Example #24
0
 public function invoke(User $user, $handlerName)
 {
     $class_info = Rudrax::classInfo($handlerName);
     $className = $class_info["class_name"];
     $user->validate();
     include_once RUDRA . "/core/handler/AbstractHandler.php";
     include_once HANDLER_PATH . "/" . $className . ".php";
     $tempClass = new ReflectionClass($className);
     global $temp;
     if ($tempClass->isInstantiable()) {
         $temp = $tempClass->newInstance();
     }
     if ($temp != NULL) {
         if (is_subclass_of($temp, 'AbstractPageHandler')) {
             include_once RUDRA . "/core/handler/AbstractPageHandler.php";
         } else {
             if (is_subclass_of($temp, 'AbstractTemplateHandler')) {
                 include_once RUDRA . "/core/handler/AbstractTemplateHandler.php";
             } else {
                 if (is_subclass_of($temp, 'AbstractDataHandler')) {
                     include_once RUDRA . "/core/handler/AbstractDataHandler.php";
                 }
             }
         }
         $temp->_invokeHandler($user, $handlerName, $tempClass);
     }
 }
Example #25
0
 private function buildTypeMap($paths)
 {
     global $prefs;
     $cacheKey = 'fieldtypes.' . $prefs['language'];
     if ($this->getPreCacheTypeMap()) {
         return;
     }
     $cachelib = TikiLib::lib('cache');
     if ($data = $cachelib->getSerialized($cacheKey)) {
         $this->typeMap = $data['typeMap'];
         $this->infoMap = $data['infoMap'];
         $this->setPreCacheTypeMap($data);
         return;
     }
     foreach ($paths as $path => $prefix) {
         foreach (glob("{$path}/*.php") as $file) {
             if ($file === "{$path}/index.php") {
                 continue;
             }
             $class = $prefix . substr($file, strlen($path) + 1, -4);
             $reflected = new ReflectionClass($class);
             if ($reflected->isInstantiable() && $reflected->implementsInterface('Tracker_Field_Interface')) {
                 $providedFields = call_user_func(array($class, 'getTypes'));
                 foreach ($providedFields as $key => $info) {
                     $this->typeMap[$key] = $class;
                     $this->infoMap[$key] = $info;
                 }
             }
         }
     }
     uasort($this->infoMap, array($this, 'compareName'));
     $data = array('typeMap' => $this->typeMap, 'infoMap' => $this->infoMap);
     $cachelib->cacheItem($cacheKey, serialize($data));
     $this->setPreCacheTypeMap($data);
 }
 /**
  * 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';
 }
Example #27
0
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;
}
Example #28
0
 public function build($concrete, $parameters = array())
 {
     //$concrete=字符串 则反射类
     $reflector = new ReflectionClass($concrete);
     //类不存在会触发php类加载器
     if (!$reflector->isInstantiable()) {
         #类不能被可实例化
         $message = "Target [{$concrete}] is not instantiable.";
         throw new BindingResolutionException($message);
     }
     //反射出构造方法 ,返回ReflectionMethod 对象
     $constructor = $reflector->getConstructor();
     if (is_null($constructor)) {
         #不存在构造方法即没有直接定义__construct构造方法
         //array_pop($this->buildStack);
         echo "没有直接定义__construct构造方法";
         //直接实例化类
         return new $concrete();
     }
     //反射构造方法参数,没有参数则返回空数组,有参数则返回array(0=>第1个参数的ReflectionParameter对象,1=》第2个参数的ReflectionParameter对象) 
     $dependencies = $constructor->getParameters();
     $parameters = $this->keyParametersByArgument($dependencies, $parameters);
     $instances = $this->getDependencies($dependencies, $parameters);
     //var_dump($instances );
     //从堆中移除
     //array_pop($this->buildStack);
     //实例化类并返回对象,并把$instances参数给构造方法
     return $reflector->newInstanceArgs($instances);
 }
 /**
  * @param $key
  * @return mixed
  * @throws ReflectionException
  */
 public function get($key)
 {
     if (empty($this->factories[$key]) && !empty($this->registry[$key])) {
         return $this->factories[$key] = $this->registry[$key]();
     }
     if (empty($this->instances[$key])) {
         if (!empty($this->registry[$key])) {
             $this->instances[$key] = $this->registry[$key]();
         } else {
             $reflected_class = new \ReflectionClass($key);
             if ($reflected_class->isInstantiable()) {
                 $constructor = $reflected_class->getConstructor();
                 if ($constructor) {
                     $parameters = $constructor->getParameters();
                     $constructor_parameters = [];
                     foreach ($parameters as $parameter) {
                         if ($parameter->getClass()) {
                             $constructor_parameters[] = $this->get($parameter->getClass()->getName());
                         } else {
                             $constructor_parameters[] = $parameter->getDefaultValue();
                         }
                     }
                     $this->instances[$key] = $reflected_class->newInstanceArgs($constructor_parameters);
                 } else {
                     $this->instances[$key] = $reflected_class->newInstance();
                 }
             } else {
                 throw new ReflectionException('Class ' . $reflected_class->getName() . ' cannot be instantiable');
             }
         }
     }
     return $this->instances[$key];
 }
Example #30
0
 public function testEveryFieldTransformsDisabledAsClone()
 {
     $fieldClasses = ClassInfo::subclassesFor('FormField');
     foreach ($fieldClasses as $fieldClass) {
         $reflectionClass = new ReflectionClass($fieldClass);
         if (!$reflectionClass->isInstantiable()) {
             continue;
         }
         $constructor = $reflectionClass->getMethod('__construct');
         if ($constructor->getNumberOfRequiredParameters() > 1) {
             continue;
         }
         if ($fieldClass == 'CompositeField' || is_subclass_of($fieldClass, 'CompositeField')) {
             continue;
         }
         if ($fieldClass = 'NullableField') {
             $instance = new $fieldClass(new TextField("{$fieldClass}_instance"));
         } else {
             $instance = new $fieldClass("{$fieldClass}_instance");
         }
         $isDisabledBefore = $instance->isDisabled();
         $disabledInstance = $instance->performDisabledTransformation();
         $this->assertEquals($isDisabledBefore, $instance->isDisabled(), "FormField class {$fieldClass} retains its disabled state after calling performDisabledTransformation()");
         $this->assertTrue($disabledInstance->isDisabled(), "FormField class {$fieldClass} returns a valid disabled representation as of isDisabled()");
         $this->assertNotSame($disabledInstance, $instance, "FormField class {$fieldClass} returns a valid cloned disabled representation");
     }
 }