/**
* Creates the remote api based on the module/plugin configuration using the extbase
* reflection features.
*
* @param string $routeUrl
* @param string $namespace
* @return array
*/
public function createApi($routeUrl, $namespace)
{
$api = [];
$api['url'] = $routeUrl;
$api['type'] = 'remoting';
$api['namespace'] = $namespace;
$api['actions'] = [];
if (empty($this->frameworkConfiguration['controllerConfiguration'])) {
# @todo improve me! Hack for fetching API of newsletter the hard way!
# It looks $this->frameworkConfiguration['controllerConfiguration'] is empty as of TYPO3 6.1. Bug or feature?
$this->frameworkConfiguration['controllerConfiguration'] = $GLOBALS['TYPO3_CONF_VARS']['EXTCONF']['extbase']['extensions']['Newsletter']['modules']['web_NewsletterTxNewsletterM1']['controllers'];
}
foreach ($this->frameworkConfiguration['controllerConfiguration'] as $controllerName => $allowedControllerActions) {
$unstrippedControllerName = $controllerName . 'Controller';
$controllerObjectName = 'Ecodev\\Newsletter\\Controller\\' . $unstrippedControllerName;
$controllerActions = [];
foreach ($allowedControllerActions['actions'] as $actionName) {
$unstrippedActionName = $actionName . 'Action';
try {
$actionParameters = $this->reflectionService->getMethodParameters($controllerObjectName, $unstrippedActionName);
$controllerActions[] = ['len' => count($actionParameters), 'name' => $unstrippedActionName];
} catch (ReflectionException $re) {
if ($unstrippedActionName !== 'extObjAction') {
\Ecodev\Newsletter\Tools::getLogger(__CLASS__)->critical('You have a not existing action (' . $controllerObjectName . '::' . $unstrippedActionName . ') in your module/plugin configuration. This action will not be available for Ext.Direct remote execution.');
}
}
}
$api['actions'][$unstrippedControllerName] = $controllerActions;
}
return $api;
}
/**
* Takes an array of unparsed command line arguments and options and converts it separated
* by named arguments, options and unnamed arguments.
*
* @param array $rawCommandLineArguments The unparsed command parts (such as "--foo") as an array
* @param string $controllerObjectName Object name of the designated command controller
* @param string $controllerCommandName Command name of the recognized command (ie. method name without "Command" suffix)
* @throws \TYPO3\CMS\Extbase\Mvc\Exception\InvalidArgumentMixingException
* @return array All and exceeding command line arguments
*/
protected function parseRawCommandLineArguments(array $rawCommandLineArguments, $controllerObjectName, $controllerCommandName) {
$commandLineArguments = array();
$exceedingArguments = array();
$commandMethodName = $controllerCommandName . 'Command';
$commandMethodParameters = $this->reflectionService->getMethodParameters($controllerObjectName, $commandMethodName);
$requiredArguments = array();
$optionalArguments = array();
$argumentNames = array();
foreach ($commandMethodParameters as $parameterName => $parameterInfo) {
$argumentNames[] = $parameterName;
if ($parameterInfo['optional'] === FALSE) {
$requiredArguments[strtolower($parameterName)] = array('parameterName' => $parameterName, 'type' => $parameterInfo['type']);
} else {
$optionalArguments[strtolower($parameterName)] = array('parameterName' => $parameterName, 'type' => $parameterInfo['type']);
}
}
$decidedToUseNamedArguments = FALSE;
$decidedToUseUnnamedArguments = FALSE;
$argumentIndex = 0;
while (count($rawCommandLineArguments) > 0) {
$rawArgument = array_shift($rawCommandLineArguments);
if ($rawArgument[0] === '-') {
if ($rawArgument[1] === '-') {
$rawArgument = substr($rawArgument, 2);
} else {
$rawArgument = substr($rawArgument, 1);
}
$argumentName = $this->extractArgumentNameFromCommandLinePart($rawArgument);
if (isset($optionalArguments[$argumentName])) {
$argumentValue = $this->getValueOfCurrentCommandLineOption($rawArgument, $rawCommandLineArguments, $optionalArguments[$argumentName]['type']);
$commandLineArguments[$optionalArguments[$argumentName]['parameterName']] = $argumentValue;
} elseif (isset($requiredArguments[$argumentName])) {
if ($decidedToUseUnnamedArguments) {
throw new \TYPO3\CMS\Extbase\Mvc\Exception\InvalidArgumentMixingException(sprintf('Unexpected named argument "%s". If you use unnamed arguments, all required arguments must be passed without a name.', $argumentName), 1309971821);
}
$decidedToUseNamedArguments = TRUE;
$argumentValue = $this->getValueOfCurrentCommandLineOption($rawArgument, $rawCommandLineArguments, $requiredArguments[$argumentName]['type']);
$commandLineArguments[$requiredArguments[$argumentName]['parameterName']] = $argumentValue;
unset($requiredArguments[$argumentName]);
}
} else {
if (count($requiredArguments) > 0) {
if ($decidedToUseNamedArguments) {
throw new \TYPO3\CMS\Extbase\Mvc\Exception\InvalidArgumentMixingException(sprintf('Unexpected unnamed argument "%s". If you use named arguments, all required arguments must be passed named.', $rawArgument), 1309971820);
}
$argument = array_shift($requiredArguments);
$commandLineArguments[$argument['parameterName']] = $rawArgument;
$decidedToUseUnnamedArguments = TRUE;
} else {
if ($argumentIndex < count($argumentNames)) {
$commandLineArguments[$argumentNames[$argumentIndex]] = $rawArgument;
} else {
$exceedingArguments[] = $rawArgument;
}
}
}
$argumentIndex++;
}
return array($commandLineArguments, $exceedingArguments);
}
/**
* Register method arguments for "render" by analysing the doc comment above.
*
* @return void
* @throws \TYPO3Fluid\Fluid\Core\Parser\Exception
*/
protected function registerRenderMethodArguments()
{
$methodParameters = $this->reflectionService->getMethodParameters(get_class($this), 'render');
if (count($methodParameters) === 0) {
return;
}
$methodTags = $this->reflectionService->getMethodTagsValues(get_class($this), 'render');
$paramAnnotations = array();
if (isset($methodTags['param'])) {
$paramAnnotations = $methodTags['param'];
}
$i = 0;
foreach ($methodParameters as $parameterName => $parameterInfo) {
$dataType = null;
if (isset($parameterInfo['type'])) {
$dataType = isset($parameterInfo['array']) && (bool) $parameterInfo['array'] ? 'array' : $parameterInfo['type'];
} else {
throw new \TYPO3\CMS\Fluid\Core\Exception('Could not determine type of argument "' . $parameterName . '" of the render-method in ViewHelper "' . get_class($this) . '". Either the methods docComment is invalid or some PHP optimizer strips off comments.', 1242292003);
}
$description = '';
if (isset($paramAnnotations[$i])) {
$explodedAnnotation = explode(' ', $paramAnnotations[$i]);
array_shift($explodedAnnotation);
array_shift($explodedAnnotation);
$description = implode(' ', $explodedAnnotation);
}
$defaultValue = null;
if (isset($parameterInfo['defaultValue'])) {
$defaultValue = $parameterInfo['defaultValue'];
}
$this->argumentDefinitions[$parameterName] = new ArgumentDefinition($parameterName, $dataType, $description, $parameterInfo['optional'] === false, $defaultValue, true);
$i++;
}
}
/**
* Gets the default value of argument
*
* @param \TYPO3\CMS\Extbase\Mvc\Cli\CommandArgumentDefinition $argument
* @return mixed
*/
protected function getDefaultArgumentValue(\TYPO3\CMS\Extbase\Mvc\Cli\CommandArgumentDefinition $argument)
{
$type = $this->getArgumentType($argument);
$argumentName = $argument->getName();
$command = $this->commandManager->getCommandByIdentifier($this->task->getCommandIdentifier());
$argumentReflection = $this->reflectionService->getMethodParameters($command->getControllerClassName(), $command->getControllerCommandName() . 'Command');
$defaultValue = $argumentReflection[$argumentName]['defaultValue'];
if ($type === 'boolean') {
$defaultValue = (bool) $defaultValue ? 1 : 0;
}
return $defaultValue;
}
/**
* Detects and registers any validators for arguments:
* - by the data type specified in the param annotations
* - additional validators specified in the validate annotations of a method
*
* @param string $className
* @param string $methodName
* @param array $methodParameters Optional pre-compiled array of method parameters
* @param array $methodValidateAnnotations Optional pre-compiled array of validate annotations (as array)
* @return ConjunctionValidator[] An Array of ValidatorConjunctions for each method parameters.
* @throws \TYPO3\CMS\Extbase\Validation\Exception\InvalidValidationConfigurationException
* @throws \TYPO3\CMS\Extbase\Validation\Exception\NoSuchValidatorException
* @throws \TYPO3\CMS\Extbase\Validation\Exception\InvalidTypeHintException
*/
public function buildMethodArgumentsValidatorConjunctions($className, $methodName, array $methodParameters = NULL, array $methodValidateAnnotations = NULL)
{
/** @var ConjunctionValidator[] $validatorConjunctions */
$validatorConjunctions = array();
if ($methodParameters === NULL) {
$methodParameters = $this->reflectionService->getMethodParameters($className, $methodName);
}
if (count($methodParameters) === 0) {
return $validatorConjunctions;
}
foreach ($methodParameters as $parameterName => $methodParameter) {
/** @var ConjunctionValidator $validatorConjunction */
$validatorConjunction = $this->createValidator('TYPO3\\CMS\\Extbase\\Validation\\Validator\\ConjunctionValidator');
if (!array_key_exists('type', $methodParameter)) {
throw new Exception\InvalidTypeHintException('Missing type information, probably no @param annotation for parameter "$' . $parameterName . '" in ' . $className . '->' . $methodName . '()', 1281962564);
}
// @todo: remove check for old underscore model name syntax once it's possible
if (strpbrk($methodParameter['type'], '_\\') === FALSE) {
$typeValidator = $this->createValidator($methodParameter['type']);
} elseif (preg_match('/[\\_]Model[\\_]/', $methodParameter['type']) !== FALSE) {
$possibleValidatorClassName = str_replace(array('\\Model\\', '_Model_'), array('\\Validator\\', '_Validator_'), $methodParameter['type']) . 'Validator';
$typeValidator = $this->createValidator($possibleValidatorClassName);
} else {
$typeValidator = NULL;
}
if ($typeValidator !== NULL) {
$validatorConjunction->addValidator($typeValidator);
}
$validatorConjunctions[$parameterName] = $validatorConjunction;
}
if ($methodValidateAnnotations === NULL) {
$validateAnnotations = $this->getMethodValidateAnnotations($className, $methodName);
$methodValidateAnnotations = array_map(function ($validateAnnotation) {
return array('type' => $validateAnnotation['validatorName'], 'options' => $validateAnnotation['validatorOptions'], 'argumentName' => $validateAnnotation['argumentName']);
}, $validateAnnotations);
}
foreach ($methodValidateAnnotations as $annotationParameters) {
$newValidator = $this->createValidator($annotationParameters['type'], $annotationParameters['options']);
if ($newValidator === NULL) {
throw new Exception\NoSuchValidatorException('Invalid validate annotation in ' . $className . '->' . $methodName . '(): Could not resolve class name for validator "' . $annotationParameters['type'] . '".', 1239853109);
}
if (isset($validatorConjunctions[$annotationParameters['argumentName']])) {
$validatorConjunctions[$annotationParameters['argumentName']]->addValidator($newValidator);
} elseif (strpos($annotationParameters['argumentName'], '.') !== FALSE) {
$objectPath = explode('.', $annotationParameters['argumentName']);
$argumentName = array_shift($objectPath);
$validatorConjunctions[$argumentName]->addValidator($this->buildSubObjectValidator($objectPath, $newValidator));
} else {
throw new Exception\InvalidValidationConfigurationException('Invalid validate annotation in ' . $className . '->' . $methodName . '(): Validator specified for argument name "' . $annotationParameters['argumentName'] . '", but this argument does not exist.', 1253172726);
}
}
return $validatorConjunctions;
}
/**
* Detects and registers any validators for arguments:
* - by the data type specified in the param annotations
* - additional validators specified in the validate annotations of a method
*
* @param string $className
* @param string $methodName
* @param array $methodParameters Optional pre-compiled array of method parameters
* @param array $methodValidateAnnotations Optional pre-compiled array of validate annotations (as array)
* @return ConjunctionValidator[] An Array of ValidatorConjunctions for each method parameters.
* @throws \TYPO3\CMS\Extbase\Validation\Exception\InvalidValidationConfigurationException
* @throws \TYPO3\CMS\Extbase\Validation\Exception\NoSuchValidatorException
* @throws \TYPO3\CMS\Extbase\Validation\Exception\InvalidTypeHintException
*/
public function buildMethodArgumentsValidatorConjunctions($className, $methodName, array $methodParameters = null, array $methodValidateAnnotations = null)
{
/** @var ConjunctionValidator[] $validatorConjunctions */
$validatorConjunctions = [];
if ($methodParameters === null) {
$methodParameters = $this->reflectionService->getMethodParameters($className, $methodName);
}
if (empty($methodParameters)) {
return $validatorConjunctions;
}
foreach ($methodParameters as $parameterName => $methodParameter) {
/** @var ConjunctionValidator $validatorConjunction */
$validatorConjunction = $this->createValidator(ConjunctionValidator::class);
if (!array_key_exists('type', $methodParameter)) {
throw new Exception\InvalidTypeHintException('Missing type information, probably no @param annotation for parameter "$' . $parameterName . '" in ' . $className . '->' . $methodName . '()', 1281962564);
}
// @todo: remove check for old underscore model name syntax once it's possible
if (strpbrk($methodParameter['type'], '_\\') === false) {
$typeValidator = $this->createValidator($methodParameter['type']);
} else {
$typeValidator = null;
}
if ($typeValidator !== null) {
$validatorConjunction->addValidator($typeValidator);
}
$validatorConjunctions[$parameterName] = $validatorConjunction;
}
if ($methodValidateAnnotations === null) {
$validateAnnotations = $this->getMethodValidateAnnotations($className, $methodName);
$methodValidateAnnotations = array_map(function ($validateAnnotation) {
return ['type' => $validateAnnotation['validatorName'], 'options' => $validateAnnotation['validatorOptions'], 'argumentName' => $validateAnnotation['argumentName']];
}, $validateAnnotations);
}
foreach ($methodValidateAnnotations as $annotationParameters) {
$newValidator = $this->createValidator($annotationParameters['type'], $annotationParameters['options']);
if ($newValidator === null) {
throw new Exception\NoSuchValidatorException('Invalid validate annotation in ' . $className . '->' . $methodName . '(): Could not resolve class name for validator "' . $annotationParameters['type'] . '".', 1239853109);
}
if (isset($validatorConjunctions[$annotationParameters['argumentName']])) {
$validatorConjunctions[$annotationParameters['argumentName']]->addValidator($newValidator);
} elseif (strpos($annotationParameters['argumentName'], '.') !== false) {
$objectPath = explode('.', $annotationParameters['argumentName']);
$argumentName = array_shift($objectPath);
$validatorConjunctions[$argumentName]->addValidator($this->buildSubObjectValidator($objectPath, $newValidator));
} else {
throw new Exception\InvalidValidationConfigurationException('Invalid validate annotation in ' . $className . '->' . $methodName . '(): Validator specified for argument name "' . $annotationParameters['argumentName'] . '", but this argument does not exist.', 1253172726);
}
}
return $validatorConjunctions;
}
/**
* Initializes the arguments array of this controller by creating an empty argument object for each of the
* method arguments found in the designated command method.
*
* @throws \TYPO3\CMS\Extbase\Mvc\Exception\InvalidArgumentTypeException
* @return void
*/
protected function initializeCommandMethodArguments()
{
$methodParameters = $this->reflectionService->getMethodParameters(get_class($this), $this->commandMethodName);
foreach ($methodParameters as $parameterName => $parameterInfo) {
$dataType = NULL;
if (isset($parameterInfo['type'])) {
$dataType = $parameterInfo['type'];
} elseif ($parameterInfo['array']) {
$dataType = 'array';
}
if ($dataType === NULL) {
throw new \TYPO3\CMS\Extbase\Mvc\Exception\InvalidArgumentTypeException('The argument type for parameter $' . $parameterName . ' of method ' . get_class($this) . '->' . $this->commandMethodName . '() could not be detected.', 1306755296);
}
$defaultValue = isset($parameterInfo['defaultValue']) ? $parameterInfo['defaultValue'] : NULL;
$this->arguments->addNewArgument($parameterName, $dataType, $parameterInfo['optional'] === FALSE, $defaultValue);
}
}
/**
* Initializes the arguments array of this controller by creating an empty argument object for each of the
* method arguments found in the designated command method.
*
* @throws \TYPO3\CMS\Extbase\Mvc\Exception\InvalidArgumentTypeException
* @return void
* @throws InvalidArgumentTypeException
*/
protected function initializeCommandMethodArguments()
{
$methodParameters = $this->reflectionService->getMethodParameters(get_class($this), $this->commandMethodName);
foreach ($methodParameters as $parameterName => $parameterInfo) {
$dataType = null;
if (isset($parameterInfo['type'])) {
$dataType = $parameterInfo['type'];
} elseif ($parameterInfo['array']) {
$dataType = 'array';
}
if ($dataType === null) {
throw new InvalidArgumentTypeException(sprintf('The argument type for parameter $%s of method %s->%s() could not be detected.', $parameterName, get_class($this), $this->commandMethodName), 1306755296);
}
$defaultValue = isset($parameterInfo['defaultValue']) ? $parameterInfo['defaultValue'] : null;
$this->arguments->addNewArgument($parameterName, $dataType, $parameterInfo['optional'] === false, $defaultValue);
}
}
/**
* Returns an array of \TYPO3\CMS\Extbase\Mvc\Cli\CommandArgumentDefinition that contains
* information about required/optional arguments of this command.
* If the command does not expect any arguments, an empty array is returned
*
* @return array<\TYPO3\CMS\Extbase\Mvc\Cli\CommandArgumentDefinition>
*/
public function getArgumentDefinitions()
{
if (!$this->hasArguments()) {
return array();
}
$commandArgumentDefinitions = array();
$commandMethodReflection = $this->getCommandMethodReflection();
$annotations = $commandMethodReflection->getTagsValues();
$commandParameters = $this->reflectionService->getMethodParameters($this->controllerClassName, $this->controllerCommandName . 'Command');
$i = 0;
foreach ($commandParameters as $commandParameterName => $commandParameterDefinition) {
$explodedAnnotation = preg_split('/\\s+/', $annotations['param'][$i], 3);
$description = !empty($explodedAnnotation[2]) ? $explodedAnnotation[2] : '';
$required = $commandParameterDefinition['optional'] !== TRUE;
$commandArgumentDefinitions[] = $this->objectManager->get(\TYPO3\CMS\Extbase\Mvc\Cli\CommandArgumentDefinition::class, $commandParameterName, $required, $description);
$i++;
}
return $commandArgumentDefinitions;
}
/**
* Initializes the arguments array of this controller by creating an empty argument object for each of the
* method arguments found in the designated command method.
*
* @param string $commandMethodName
* @return Arguments
* @throws InvalidArgumentTypeException
*/
protected function getCommandMethodArguments($commandMethodName)
{
$arguments = $this->objectManager->get('TYPO3\\CMS\\Extbase\\Mvc\\Controller\\Arguments');
$methodParameters = $this->reflectionService->getMethodParameters(self::INSTALL_COMMAND_CONTROLLER_CLASS, $commandMethodName);
foreach ($methodParameters as $parameterName => $parameterInfo) {
$dataType = NULL;
if (isset($parameterInfo['type'])) {
$dataType = $parameterInfo['type'];
} elseif ($parameterInfo['array']) {
$dataType = 'array';
}
if ($dataType === NULL) {
throw new InvalidArgumentTypeException(sprintf('The argument type for parameter $%s of method %s->%s() could not be detected.', $parameterName, self::INSTALL_COMMAND_CONTROLLER_CLASS, $commandMethodName), 1306755296);
}
$defaultValue = isset($parameterInfo['defaultValue']) ? $parameterInfo['defaultValue'] : NULL;
$arguments->addNewArgument($parameterName, $dataType, $parameterInfo['optional'] === FALSE, $defaultValue);
}
return $arguments;
}
/**
* Ext Direct does not provide named arguments by now, so we have
* to map them by reflecting on the action parameters.
*
* @return array The mapped arguments
* @author Robert Lemke <*****@*****.**>
* @author Christopher Hlubek <*****@*****.**>
*/
public function getArguments()
{
if ($this->data === array()) {
return array();
}
$arguments = array();
if (!$this->request->isFormPost()) {
$parameters = $this->reflectionService->getMethodParameters($this->getControllerObjectName(), $this->getControllerActionName() . 'Action');
// TODO Add checks for parameters
foreach ($parameters as $name => $options) {
$parameterIndex = $options['position'];
if (isset($this->data[$parameterIndex])) {
$arguments[$name] = $this->convertObjectToArray($this->data[$parameterIndex]);
}
}
} else {
// TODO Reuse setArgumentsFromRawRequestData from Web/RequestBuilder
}
return $arguments;
}
/**
* Builds a new instance of $objectType with the given $possibleConstructorArgumentValues. If
* constructor argument values are missing from the given array the method
* looks for a default value in the constructor signature. Furthermore, the constructor arguments are removed from $possibleConstructorArgumentValues
*
* @param array &$possibleConstructorArgumentValues
* @param string $objectType
* @return object The created instance
* @throws \TYPO3\CMS\Extbase\Property\Exception\InvalidTargetException if a required constructor argument is missing
*/
protected function buildObject(array &$possibleConstructorArgumentValues, $objectType) {
$specificObjectType = $this->objectContainer->getImplementationClassName($objectType);
if ($this->reflectionService->hasMethod($specificObjectType, '__construct')) {
$constructorSignature = $this->reflectionService->getMethodParameters($specificObjectType, '__construct');
$constructorArguments = array();
foreach ($constructorSignature as $constructorArgumentName => $constructorArgumentInformation) {
if (array_key_exists($constructorArgumentName, $possibleConstructorArgumentValues)) {
$constructorArguments[] = $possibleConstructorArgumentValues[$constructorArgumentName];
unset($possibleConstructorArgumentValues[$constructorArgumentName]);
} elseif ($constructorArgumentInformation['optional'] === TRUE) {
$constructorArguments[] = $constructorArgumentInformation['defaultValue'];
} else {
throw new \TYPO3\CMS\Extbase\Property\Exception\InvalidTargetException('Missing constructor argument "' . $constructorArgumentName . '" for object of type "' . $objectType . '".', 1268734872);
}
}
return call_user_func_array(array($this->objectManager, 'get'), array_merge(array($objectType), $constructorArguments));
} else {
return $this->objectManager->get($objectType);
}
}
/**
* Returns an array of \TYPO3\CMS\Extbase\Mvc\Cli\CommandArgumentDefinition that contains
* information about required/optional arguments of this command.
* If the command does not expect any arguments, an empty array is returned
*
* @return array<\TYPO3\CMS\Extbase\Mvc\Cli\CommandArgumentDefinition>
*/
public function getArgumentDefinitions()
{
if (!$this->hasArguments()) {
return array();
}
$commandArgumentDefinitions = array();
$commandMethodReflection = $this->getCommandMethodReflection();
$annotations = $commandMethodReflection->getTagsValues();
$commandParameters = $this->reflectionService->getMethodParameters($this->controllerClassName, $this->controllerCommandName . 'Command');
$i = 0;
foreach ($commandParameters as $commandParameterName => $commandParameterDefinition) {
$explodedAnnotation = explode(' ', $annotations['param'][$i]);
array_shift($explodedAnnotation);
array_shift($explodedAnnotation);
$description = ltrim(implode(' ', $explodedAnnotation));
$required = $commandParameterDefinition['optional'] !== TRUE;
$commandArgumentDefinitions[] = $this->objectManager->get('TYPO3\\CMS\\Extbase\\Mvc\\Cli\\CommandArgumentDefinition', $commandParameterName, $required, $description);
$i++;
}
return $commandArgumentDefinitions;
}
/**
* Builds a new instance of $objectType with the given $possibleConstructorArgumentValues.
* If constructor argument values are missing from the given array the method looks for a
* default value in the constructor signature.
*
* Furthermore, the constructor arguments are removed from $possibleConstructorArgumentValues
*
* @param array &$possibleConstructorArgumentValues
* @param string $objectType
* @return object The created instance
* @throws \TYPO3\CMS\Extbase\Property\Exception\InvalidTargetException if a required constructor argument is missing
*/
protected function buildObject(array &$possibleConstructorArgumentValues, $objectType)
{
$className = $objectType;
if (method_exists($className, '__construct')) {
$constructorSignature = $this->reflectionService->getMethodParameters($className, '__construct');
$constructorArguments = array();
foreach ($constructorSignature as $constructorArgumentName => $constructorArgumentInformation) {
if (array_key_exists($constructorArgumentName, $possibleConstructorArgumentValues)) {
$constructorArguments[] = $possibleConstructorArgumentValues[$constructorArgumentName];
unset($possibleConstructorArgumentValues[$constructorArgumentName]);
} elseif ($constructorArgumentInformation['optional'] === true) {
$constructorArguments[] = $constructorArgumentInformation['defaultValue'];
} else {
throw new \TYPO3\CMS\Extbase\Property\Exception\InvalidTargetException('Missing constructor argument "' . $constructorArgumentName . '" for object of type "' . $objectType . '".', 1268734872);
}
}
$classReflection = new \ReflectionClass($className);
return $classReflection->newInstanceArgs($constructorArguments);
} else {
return new $className();
}
}
/**
* @test
*/
public function getMethodParametersWithShortTypeNames()
{
$service = new ReflectionService();
$parameters = $service->getMethodParameters(get_class($this), 'fixtureMethodForMethodTagsValuesWithShortTypes');
$this->assertSame(array('dummy' => array('position' => 0, 'byReference' => FALSE, 'array' => FALSE, 'optional' => FALSE, 'allowsNull' => TRUE, 'class' => NULL, 'type' => 'boolean'), 'foo' => array('position' => 1, 'byReference' => FALSE, 'array' => FALSE, 'optional' => FALSE, 'allowsNull' => TRUE, 'class' => NULL, 'type' => 'integer')), $parameters);
}
/**
* Register method arguments for "render" by analysing the doc comment above.
*
* @return void
* @throws \TYPO3\CMS\Fluid\Core\Parser\Exception
*/
private function registerRenderMethodArguments()
{
$methodParameters = $this->reflectionService->getMethodParameters(get_class($this), 'render');
if (count($methodParameters) === 0) {
return;
}
if (\TYPO3\CMS\Fluid\Fluid::$debugMode) {
$methodTags = $this->reflectionService->getMethodTagsValues(get_class($this), 'render');
$paramAnnotations = array();
if (isset($methodTags['param'])) {
$paramAnnotations = $methodTags['param'];
}
}
$i = 0;
foreach ($methodParameters as $parameterName => $parameterInfo) {
$dataType = NULL;
if (isset($parameterInfo['type'])) {
$dataType = $parameterInfo['type'];
} elseif ($parameterInfo['array']) {
$dataType = 'array';
}
if ($dataType === NULL) {
throw new \TYPO3\CMS\Fluid\Core\Parser\Exception('could not determine type of argument "' . $parameterName . '" of the render-method in ViewHelper "' . get_class($this) . '". Either the methods docComment is invalid or some PHP optimizer strips off comments.', 1242292003);
}
$description = '';
if (\TYPO3\CMS\Fluid\Fluid::$debugMode && isset($paramAnnotations[$i])) {
$explodedAnnotation = explode(' ', $paramAnnotations[$i]);
array_shift($explodedAnnotation);
array_shift($explodedAnnotation);
$description = implode(' ', $explodedAnnotation);
}
$defaultValue = NULL;
if (isset($parameterInfo['defaultValue'])) {
$defaultValue = $parameterInfo['defaultValue'];
}
$this->argumentDefinitions[$parameterName] = new \TYPO3\CMS\Fluid\Core\ViewHelper\ArgumentDefinition($parameterName, $dataType, $description, $parameterInfo['optional'] === FALSE, $defaultValue, TRUE);
$i++;
}
}
