/**
* Maps two object together, a map should exist.
*
* @param $source
* @param $destination
*
* @return object
* @throws InvalidClassConstructorException
*/
public function map($source, $destination)
{
if (is_string($destination)) {
$destinationRef = new \ReflectionClass($destination);
if ($destinationRef->getConstructor() && $destinationRef->getConstructor()->getNumberOfRequiredParameters() > 0) {
throw new InvalidClassConstructorException($destination);
}
$destination = $destinationRef->newInstance();
}
$map = $this->getMap($this->guessType($source), $this->guessType($destination));
$fieldAccessors = $map->getFieldAccessors();
$fieldFilters = $map->getFieldFilters();
foreach ($fieldAccessors as $path => $fieldAccessor) {
$value = $fieldAccessor->getValue($source);
if (isset($fieldFilters[$path])) {
if (($filter = $fieldFilters[$path]) instanceof AbstractMappingFilter) {
$filter->setMapper($this);
}
$value = $filter->filter($value);
}
if ($map->getSkipNull() && is_null($value)) {
continue;
}
$propertyAccessor = PropertyAccess::createPropertyAccessor();
if ($map->getOverwriteIfSet()) {
$propertyAccessor->setValue($destination, $path, $value);
} else {
if ($propertyAccessor->getValue($destination, $path) == null) {
$propertyAccessor->setValue($destination, $path, $value);
}
}
}
return $destination;
}
/**
* Test handling of attributes of the DateTime type.
*/
public function testDateTime()
{
// Add a mostly dummy configuration. We are not going to read or write any files here.
// The important part is the accessors part.
$config = new Config(array('inputFile' => null, 'outputDir' => null, 'constructorParamsDefaultToNull' => true));
$complexType = new ComplexType($config, 'ComplexTypeTestClass');
$complexType->addMember('dateTime', 'dateTimeAttribute', false);
$this->generateClass($complexType);
$this->assertClassExists('ComplexTypeTestClass');
$this->assertClassHasAttribute('dateTimeAttribute', 'ComplexTypeTestClass');
$this->assertClassHasMethod('ComplexTypeTestClass', 'getDateTimeAttribute');
$this->assertClassHasMethod('ComplexTypeTestClass', 'setDateTimeAttribute');
$object = new \ComplexTypeTestClass(new \DateTime());
$class = new \ReflectionClass($object);
$this->assertMethodParameterHasType($class->getConstructor(), 'dateTimeAttribute', 'DateTime');
$this->assertMethodParameterDocBlockHasType($class->getConstructor(), 'dateTimeAttribute', '\\DateTime');
$this->assertMethodHasReturnType($class->getMethod('getDateTimeAttribute'), '\\DateTime');
$this->assertMethodParameterHasType($class->getMethod('setDateTimeAttribute'), 'dateTimeAttribute', 'DateTime');
$this->assertMethodParameterDocBlockHasType($class->getMethod('setDateTimeAttribute'), 'dateTimeAttribute', '\\DateTime');
// Using reflection to set up bad datetime value as like SoapClass does it
$property = 'dateTimeAttribute';
$badDateTime = 'noDate';
$this->setObjectProperty($object, $property, $badDateTime);
$this->assertFalse($object->getDateTimeAttribute());
// Test passing variable datetime formats available in SOAP, http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/#dateTime
$now = new \DateTime();
foreach (array('Y-m-d\\TH:i:s', 'Y-m-d\\TH:i:sP', 'Y-m-d\\TH:i:s.u', 'Y-m-d\\TH:i:s.uP', 'Y-m-d\\TH:i:s\\Z', 'Y-m-d\\TH:i:s.u\\Z') as $format) {
$this->setObjectProperty($object, $property, $now->format($format));
$this->assertInstanceOf('\\DateTime', $object->getDateTimeAttribute());
}
}
/**
* {@inheritdoc}
*/
public function execute(InputInterface $input, OutputInterface $output)
{
$class = $input->getArgument('factory');
$class = str_replace('/', '\\', $class);
if (false === class_exists($class)) {
throw new \Exception(sprintf('Class %s not found', $class));
}
$rfl = new \ReflectionClass($class);
if (null !== $rfl->getConstructor() && 0 < $rfl->getConstructor()->getNumberOfRequiredParameters()) {
throw new \Exception('Can\'t instanciate adapter factory %s, constructor shouldn\'t need required parameters');
}
$factory = new $class();
if (false === $factory instanceof AdapterFactory) {
throw new \Exception('Your adapter factory should implements Gaufrette\\TestSuite\\Adapter\\AdapterFactory');
}
$exit = 0;
foreach ($this->tests->all() as $test) {
$output->writeln('');
$adapter = $factory->create();
$result = $this->runTest($test, $adapter, $output);
$factory->destroy();
$exit = true === $result ? $exit : 1;
}
$output->writeln('');
return $exit;
}
/**
* @param null|string|CrudControllerInterface $controller
* @return CrudControllerInterface
* @throws ControllerNotFoundException
*/
public function resolve($controller)
{
if (null === $controller) {
$controller = $this->defaultController;
}
$name = $controller;
if (is_string($controller)) {
if (isset($this->resolved[$controller])) {
return $this->resolved[$controller];
}
if ($this->container->has($controller)) {
$controller = $this->container->get($controller);
} elseif (class_exists($controller, true)) {
$refl = new \ReflectionClass($controller);
if ($refl->implementsInterface('Bravesheep\\CrudifyBundle\\Controller\\CrudControllerInterface')) {
if ($refl->getConstructor() === null || $refl->getConstructor()->getNumberOfRequiredParameters() === 0) {
$controller = $refl->newInstance();
$controller->setContainer($this->container);
}
}
}
}
if (!$controller instanceof CrudControllerInterface) {
throw new ControllerNotFoundException("Could not resolve controller specification to controller");
}
if (is_string($name)) {
$this->resolved[$name] = $controller;
}
return $controller;
}
/**
* Derives properties from constructor, public instance variables, getters and setters.
*
* @param object|null $object If provided, dynamic (run-time) variables are read as well
* @return \watoki\collections\Map|Property[] indexed by property name
*/
public function readInterface($object = null)
{
$properties = new Map();
if ($this->class->getConstructor()) {
foreach ($this->class->getConstructor()->getParameters() as $parameter) {
$this->accumulate($properties, new property\ConstructorProperty($this->factory, $this->class->getConstructor(), $parameter));
}
}
$declaredProperties = array();
foreach ($this->class->getProperties(\ReflectionProperty::IS_PUBLIC) as $property) {
if (!$property->isStatic()) {
$declaredProperties[] = $property->name;
$this->accumulate($properties, new property\InstanceVariableProperty($this->factory, $property));
}
}
if (is_object($object)) {
foreach ($object as $name => $value) {
if (!in_array($name, $declaredProperties)) {
$this->accumulate($properties, new property\DynamicProperty($this->factory, new \ReflectionClass($object), $name));
}
}
}
foreach ($this->class->getMethods(\ReflectionMethod::IS_PUBLIC) as $method) {
if (property\AccessorProperty::isAccessor($method) && !$method->isStatic()) {
$this->accumulate($properties, new property\AccessorProperty($this->factory, $method));
}
}
return $properties;
}
/**
* 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();
}
}
private function generateCode($classes, $controllerName)
{
$methods = [];
$comments = [];
foreach ($classes as $item) {
if (false === class_exists($item)) {
$comments[] = sprintf('Class %s does not exist', $item);
continue;
}
$reflection = new \ReflectionClass($item);
if ($reflection->getConstructor() && 0 !== $reflection->getConstructor()->getNumberOfRequiredParameters()) {
$comments[] = sprintf('Class %s has a required constructor argument', $item);
continue;
}
if (false === $reflection->hasMethod('getDefaultView')) {
$comments[] = sprintf('Class %s has no default view', $item);
continue;
}
list($name) = array_reverse(explode("\\", $item));
$template = $reflection->newInstance()->getDefaultView();
$methods[] = ['name' => lcfirst($name), 'class' => $item, 'template' => $template];
}
$code = '<?php' . "\n\n" . '// THIS FILE IS GENERATED DURING THE CACHE WARMUP, DO NOT MODIFY' . "\n" . 'class %s extends \\Symfony\\Bundle\\FrameworkBundle\\Controller\\Controller' . "\n" . '{%s}';
$code = sprintf($code, $controllerName, "\n\n\t" . ($comments ? implode("\n\t", $comments) . "\n\n\t" : '') . implode("\n\t", array_map(function ($item) {
$key = false === strpos($item['class'], "PagePart") ? 'page' : 'resource';
return sprintf('public function %sAction()' . "\n\t" . '{' . "\n\t\t" . 'return $this->render("%s", [' . "\n\t\t\t" . '"%s" => new \\%s,' . "\n\t\t" . ']);' . "\n\t" . "}" . "\n", $item['name'], $item['template'], $key, $item['class']);
}, $methods)) . "\n");
$code = str_replace("\t", " ", $code);
return $code;
}
private function instantinate($class_name)
{
if (array_key_exists($class_name, $this->class_dictionary)) {
$class_name = $this->class_dictionary[$class_name];
}
$class = new ReflectionClass($class_name);
$parameters = array();
$constructor = $class->getConstructor();
if ($constructor != null) {
$parameters = $class->getConstructor()->getParameters();
}
$dependencies = array();
foreach ($parameters as $value) {
$className = "";
if ($value->getClass() != null) {
$className = $value->getClass()->getName();
}
$parameterName = $value->getName();
if (array_key_exists($className, $this->instance_dictionary)) {
$dependencies[] = $this->instance_dictionary[$className];
} elseif (array_key_exists($parameterName, $this->var_dictionary)) {
if (!is_string($this->var_dictionary[$parameterName])) {
$dependencies[] = $this->var_dictionary[$parameterName];
} else {
$dependencies[] = $this->get($this->var_dictionary[$parameterName]);
}
} elseif (array_key_exists($className, $this->class_dictionary)) {
$dependencies[] = $this->get($className);
} else {
throw new IocClassNotFounException($class_name, $className, $parameterName);
}
}
return call_user_func_array(array(new ReflectionClass($class_name), 'newInstance'), $dependencies);
}
public function testGeneratedCode()
{
// Test that enums are created correctly.
//
// the MS-SSNWS contains enumerations with names that collide with PHP
// keywords. This test ensures that they are created correctly.
//
// Load the code. This ensures that the syntax of the generated code is
// valid.
// We do not call the service here. It is not necessary for the check
// at hand and we do not have a valid endpoint for the service either.
// Create an instance of a class containing problematic constants. This also autoloads it.
$typeEnum = new \sqlDbTypeEnum();
// If we got this far and loaded the class without parse errors we should be good.
$this->assertTrue(true);
// Test that classes with datetimes are created correctly.
//
// This should be in a separate test method. This would however cause
// code generated to run twice and classes would be generated twice as
// setUp() is called twice. Since the first part of the test loads all
// the classes the second round would add a suffix to class names to
// avoid conflicts.
//
// This we test for multiple aspects in the same method. Going forward
// we should consider separating generated code between methods - e.g.
// by adding the test method as a namespace.
$this->assertGeneratedClassExists('DayAsNumber');
$object = new \DayAsNumber(new \DateTime());
$class = new \ReflectionClass($object);
$this->assertMethodParameterHasType($class->getConstructor(), 'day', 'DateTime');
$this->assertMethodParameterDocBlockHasType($class->getConstructor(), 'day', '\\DateTime');
}
/**
* Makes an instance of a class
*
* @param string $className Class name
* @return object Class instance
*/
public function make($className)
{
// Create a reflection to access the class properties
$reflection = new \ReflectionClass($className);
// If the class has no constructor, just return a new instance
$constructor = $reflection->getConstructor();
if (is_null($constructor)) {
return new $className();
}
// Or get the constructor parameters and instance dependencies
$dependencies = [];
$parameters = $reflection->getConstructor()->getParameters();
foreach ($parameters as $param) {
$class = $param->getClass();
if ($class && $class->getName() === 'Laito\\App') {
// If the dependency is the app itself, inject the current instance
$dependencies[] = $this;
} else {
// Otherwise, inject the instantiated dependency or a null value
$dependencies[] = $class ? $this->make($class->name) : 'NULL';
}
}
// Return the class instance
$instance = $reflection->newInstanceArgs($dependencies);
// If the class has a boot method, run it
if (method_exists($instance, 'boot')) {
$instance->boot();
}
// Return instance
return $instance;
}
/**
* @return \ReflectionParameter[]
*/
function getReflectionParameters()
{
$reflConstructor = $this->reflClass->getConstructor();
if (NULL === $reflConstructor) {
return array();
}
return $reflConstructor->getParameters();
}
/**
* Fetches constructor args (array of ReflectionParameter) from the reflected class
* and set them as an associative array
*/
public function initConstructorArgs()
{
$constructor = $this->reflected->getConstructor();
if (!is_null($constructor)) {
// Index parameters by their names
foreach ($constructor->getParameters() as $param) {
$this->constructorArgs[$param->getName()] = $param;
}
}
}
/**
* Get Class definition for constructor parameter.
*
* @param \ReflectionClass $parameterClass
*
* @return mixed|null|object
*/
private function getClassDefinition(\ReflectionClass $parameterClass)
{
$parameterClassName = $parameterClass->getName();
$entryReference = new \ReflectionClass($parameterClass->getName());
$argumentParams = false;
if ($entryReference->getConstructor()) {
$argumentParams = $entryReference->getConstructor()->getParameters();
}
return $argumentParams ? $this->get($parameterClassName) : new $parameterClassName();
}
/**
* Fetches constructor args (array of ReflectionParameter) from the reflected class
* and set them as an associative array
*
* Convert the parameter names to camelCase for classes that have contructor
* params defined in snake_case for consistency with the options
*/
public function initConstructorArgs()
{
$constructor = $this->reflected->getConstructor();
if (!is_null($constructor)) {
// Index parameters by their names
foreach ($constructor->getParameters() as $param) {
$name = Util::snakeToCamelCase($param->getName());
$this->constructorArgs[$name] = $param;
}
}
}
/**
* Fetches constructor args (array of ReflectionParameter) from the reflected class
* and set them as an associative array
*
* Convert the parameter names to camelCase for classes that have contructor
* params defined in snake_case for consistency with the options
*/
public function initConstructorArgs()
{
$constructor = $this->reflected->getConstructor();
$nameConverter = new CamelCaseToSnakeCaseNameConverter();
if (!is_null($constructor)) {
// Index parameters by their names
foreach ($constructor->getParameters() as $param) {
$this->constructorArgs[$nameConverter->denormalize($param->getName())] = $param;
}
}
}
/**
* Generic constructor for all Singleton classes
* @param string $class
* @param float $ts
* @param array $args
* @return \CloudFramework\Patterns\Schemas\SingletonInterface
*/
private static function instanceClass($class, $ts, array $args = array())
{
$reflectionClass = new \ReflectionClass($class);
/** @var \CloudFramework\Patterns\Schemas\SingletonInterface $instanceClass */
if (null !== $reflectionClass->getConstructor() && $reflectionClass->getConstructor()->getNumberOfParameters() > 0) {
$instanceClass = $reflectionClass->newInstanceArgs($args);
} else {
$instanceClass = $reflectionClass->newInstance();
}
self::initializeInstance($ts, $reflectionClass, $instanceClass);
unset($reflectionClass);
return $instanceClass;
}
/**
* Resolves the dependencies recursively.
*/
protected function reflect($key)
{
$reflector = new \ReflectionClass($key);
if (!$reflector->getConstructor()) {
return new $key();
}
$parameters = $reflector->getConstructor()->getParameters();
$dependencies = [];
foreach ($parameters as $parameter) {
$className = $parameter->getClass()->getName();
$dependencies[] = $this->reflect($className);
}
return $reflector->newInstanceArgs($dependencies);
}
/**
* @param FormEvent $e
*/
public function setEntityAsObject(FormEvent $e)
{
$form = $e->getTarget();
if (!$form instanceof FormInterface) {
return;
}
$config = $e->getConfiguration();
if (!$config || !$config->getEntity()) {
return;
}
$rc = new \ReflectionClass($config->getEntity());
$hasConstructorparams = $rc->getConstructor() && $rc->getConstructor()->getNumberOfParameters() ? true : false;
$instance = $hasConstructorparams ? $rc->newInstanceWithoutConstructor() : $rc->newInstance();
$form->setObject($instance);
}
private function getContructArguments($classname)
{
$arguments = [];
$reflector = new \ReflectionClass($classname);
if ($reflector->getConstructor()) {
foreach ($reflector->getConstructor()->getParameters() as $param) {
$classname = $param->getClass()->name;
if ($classname == 'Buuum\\Config') {
$classname = 'config';
}
$arguments[] = $classname;
}
}
return $arguments;
}
/**
* Creates an object instance of the requested class, optionally passing additional constructor arguments
*
* @param $requestedClass
* @param ...$arguments
* @return mixed|object
*/
public final function getInstance($requestedClass, ...$arguments)
{
if (isset($this->singletons[$requestedClass])) {
return $this->singletons[$requestedClass];
}
$useSingleton = false;
// Check for singletons first as they should trump previous registrations of non
// singleton mappings.
if (isset($this->concreteClassMappings['_' . $requestedClass])) {
$class = $this->concreteClassMappings['_' . $requestedClass];
$useSingleton = true;
} elseif (isset($this->concreteClassMappings[$requestedClass])) {
$class = $this->concreteClassMappings[$requestedClass];
} else {
$class = $requestedClass;
}
$reflection = new \ReflectionClass($class);
if ($reflection->isAbstract()) {
throw new ClassMappingException($class);
}
$constructor = $reflection->getConstructor();
if ($constructor == null) {
// No defined constructor so exit simply with a new instance.
$instance = $reflection->newInstanceArgs($arguments);
} else {
$instance = $this->generateInstanceFromConstructor($reflection, $constructor, $arguments);
}
if ($useSingleton) {
$this->singletons[$requestedClass] = $instance;
}
return $instance;
}
public function testResultSetConstruction()
{
$resultSet = ResultSet::create(array('part1', 'part2', 'part3'), 'parts');
self::assertInstanceOf('DrestCommon\\ResultSet', $resultSet);
$refl = new \ReflectionClass('DrestCommon\\ResultSet');
self::assertTrue($refl->getConstructor()->isPrivate());
}
public static function resolve($type, $constructorArguments = [])
{
$resolvedClass = self::getResolvedClassName($type);
if ($resolvedClass === null) {
throw new exceptions\ResolutionException("Could not resolve dependency {$type}");
}
$reflection = new \ReflectionClass($resolvedClass);
if ($reflection->isAbstract()) {
throw new exceptions\ResolutionException("Abstract class {$reflection->getName()} cannot be instantiated. " . "Please provide a binding to an implementation.");
}
$constructor = $reflection->getConstructor();
$instanceParameters = [];
if ($constructor != null) {
$parameters = $constructor->getParameters();
foreach ($parameters as $parameter) {
$class = $parameter->getClass();
if (isset($constructorArguments[$parameter->getName()])) {
$instanceParameters[] = $constructorArguments[$parameter->getName()];
} else {
$instanceParameters[] = $class ? self::resolve($class->getName()) : null;
}
}
}
return $reflection->newInstanceArgs($instanceParameters);
}
/**
* Creates a new instance of the cacheable object or returns an already
* cached one
*
* The parameters of this method are derived from the constructor of the
* cacheable class. Additionally, the following parameters are dynamically
* added:
*
* @param bool $fetch If <var>true</var> the object’s <var>fetch()</var>
* method will be called
* @param bool $bypassCache If <var>true</var> the cache will not be hit
* @return mixed A new object or a matching cached one
*/
public static function create()
{
$args = func_get_args();
$className = empty(self::$className) ? get_class() : self::$className;
$class = new \ReflectionClass($className);
$constructor = $class->getConstructor();
$arity = $constructor->getNumberOfParameters();
if (sizeof($args) < $arity) {
array_fill(0, $arity, null);
}
$bypassCache = sizeof($args) > $arity + 1 ? array_pop($args) : false;
$fetch = sizeof($args) > $arity ? array_pop($args) : true;
$object = $class->newInstanceWithoutConstructor();
$constructor->setAccessible(true);
$constructor->invokeArgs($object, $args);
$cachedObject = $object->cachedInstance();
if ($cachedObject != null && !$bypassCache) {
$object = $cachedObject;
}
if ($fetch && ($bypassCache || !$object->isFetched())) {
$object->fetch();
$object->cache();
}
return $object;
}
/**
* @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]);
}
}
}
}
}
/**
* 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();
}
/**
* 自动绑定（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);
}
/**
* @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);
}
}
private function makeInstanceFromClassName($className, array $alreadySeen)
{
$className = $this->resolveClassName($className);
try {
$refl = new ReflectionClass($className);
} catch (ReflectionException $re) {
throw new Core_Foundation_IoC_Exception(sprintf('This doesn\'t seem to be a class name: `%s`.', $className));
}
$args = array();
if ($refl->isAbstract()) {
throw new Core_Foundation_IoC_Exception(sprintf('Cannot build abstract class: `%s`.', $className));
}
$classConstructor = $refl->getConstructor();
if ($classConstructor) {
foreach ($classConstructor->getParameters() as $param) {
$paramClass = $param->getClass();
if ($paramClass) {
$args[] = $this->doMake($param->getClass()->getName(), $alreadySeen);
} elseif ($param->isDefaultValueAvailable()) {
$args[] = $param->getDefaultValue();
} else {
throw new Core_Foundation_IoC_Exception(sprintf('Cannot build a `%s`.', $className));
}
}
}
if (count($args) > 0) {
return $refl->newInstanceArgs($args);
} else {
// newInstanceArgs with empty array fails in PHP 5.3 when the class
// doesn't have an explicitly defined constructor
return $refl->newInstance();
}
}
public function callConstructor()
{
$parent = new \ReflectionClass(parent::class);
if ($parent->getConstructor()) {
parent::__construct();
}
}
/**
* @param array $schema
* @param PhpClass $class
*/
protected function generateConstructor(array $schema, PhpClass $class)
{
$constructorParams = [];
$constructorBody = [];
if (!empty($schema['inherit'])) {
$parent = new \ReflectionClass($schema['inherit']);
$parentConstructor = $parent->getConstructor();
if ($parentConstructor) {
$params = $parentConstructor->getParameters();
$callParamsDef = [];
foreach ($params as $param) {
$constructorParams[] = PhpParameter::fromReflection($param);
$callParamsDef[] = '$' . $param->getName();
}
$constructorBody[] = sprintf('parent::__construct(%s);', implode(', ', $callParamsDef));
}
}
foreach ($schema['addremove'] as $fieldName => $config) {
$constructorBody[] = '$this->' . $fieldName . ' = new \\Doctrine\\Common\\Collections\\ArrayCollection();';
}
$constructor = $this->generateClassMethod('__construct', implode("\n", $constructorBody));
foreach ($constructorParams as $constructorParam) {
$constructor->addParameter($constructorParam);
}
$class->setMethod($constructor);
}
