/** * clear Cache ajax handler * * @param array $ajaxParams * @param AjaxRequestHandler $ajaxObj */ public function clear($ajaxParams, AjaxRequestHandler $ajaxObj) { if ($this->isProduction() || !$this->isAdmin()) { return; } /** @var \TYPO3\CMS\Core\Cache\CacheManager $cacheManager */ $cacheManager = GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Cache\\CacheManager'); $cacheManager->getCache('autoloader')->flush(); // Dump new class loading information if (GeneralUtility::compat_version('7.0') && !\TYPO3\CMS\Core\Core\Bootstrap::usesComposerClassLoading()) { ClassLoadingInformation::dumpClassLoadingInformation(); } }
/** * Returns the class name for a new instance, taking into account * registered implementations for this class * * @param string $className Base class name to evaluate * @return string Final class name to instantiate with "new [classname] */ protected static function getClassName($className) { if (class_exists($className)) { while (static::classHasImplementation($className)) { $className = static::getImplementationForClass($className); } } return ClassLoadingInformation::getClassNameForAlias($className); }
/** * Writes class loading information if not yet present * * @return Bootstrap * @internal This is not a public API method, do not use in own extensions */ public function ensureClassLoadingInformationExists() { if (!self::$usesComposerClassLoading && !ClassLoadingInformation::isClassLoadingInformationAvailable()) { ClassLoadingInformation::dumpClassLoadingInformation(); ClassLoadingInformation::registerClassLoadingInformation(); } return $this; }
/** * Resolve a viewhelper name. * * @param string $namespaceIdentifier Namespace identifier for the view helper. * @param string $methodIdentifier Method identifier, might be hierarchical like "link.url" * @return string The fully qualified class name of the viewhelper */ protected function resolveViewHelperName($namespaceIdentifier, $methodIdentifier) { if (isset($this->viewHelperNameToImplementationClassNameRuntimeCache[$namespaceIdentifier][$methodIdentifier])) { $name = $this->viewHelperNameToImplementationClassNameRuntimeCache[$namespaceIdentifier][$methodIdentifier]; } else { $explodedViewHelperName = explode('.', $methodIdentifier); $namespaceSeparator = strpos($this->namespaces[$namespaceIdentifier], \TYPO3\CMS\Fluid\Fluid::NAMESPACE_SEPARATOR) !== false ? \TYPO3\CMS\Fluid\Fluid::NAMESPACE_SEPARATOR : \TYPO3\CMS\Fluid\Fluid::LEGACY_NAMESPACE_SEPARATOR; if (count($explodedViewHelperName) > 1) { $className = implode($namespaceSeparator, array_map('ucfirst', $explodedViewHelperName)); } else { $className = ucfirst($explodedViewHelperName[0]); } $className .= 'ViewHelper'; $name = $this->namespaces[$namespaceIdentifier] . $namespaceSeparator . $className; $name = \TYPO3\CMS\Core\Core\ClassLoadingInformation::getClassNameForAlias($name); // The name isn't cached in viewHelperNameToImplementationClassNameRuntimeCache here because the // class could be overloaded by extbase object manager. Thus the cache is filled in // initializeViewHelperAndAddItToStack after getting the real object from the object manager. } return $name; }
/** * Internal implementation for getting a class. * * @param string $className * @param array $givenConstructorArguments the list of constructor arguments as array * @throws \TYPO3\CMS\Extbase\Object\Exception * @throws \TYPO3\CMS\Extbase\Object\Exception\CannotBuildObjectException * @return object the built object */ protected function getInstanceInternal($className, $givenConstructorArguments = []) { $className = $this->getImplementationClassName($className); if ($className === \TYPO3\CMS\Extbase\Object\Container\Container::class) { return $this; } if ($className === \TYPO3\CMS\Core\Cache\CacheManager::class) { return \TYPO3\CMS\Core\Utility\GeneralUtility::makeInstance(\TYPO3\CMS\Core\Cache\CacheManager::class); } if ($className === \TYPO3\CMS\Core\Package\PackageManager::class) { return \TYPO3\CMS\Core\Utility\GeneralUtility::makeInstance(\TYPO3\CMS\Core\Package\PackageManager::class); } $className = \TYPO3\CMS\Core\Core\ClassLoadingInformation::getClassNameForAlias($className); if (isset($this->singletonInstances[$className])) { if (!empty($givenConstructorArguments)) { throw new \TYPO3\CMS\Extbase\Object\Exception('Object "' . $className . '" fetched from singleton cache, thus, explicit constructor arguments are not allowed.', 1292857934); } return $this->singletonInstances[$className]; } $classInfo = $this->getClassInfo($className); $classIsSingleton = $classInfo->getIsSingleton(); if (!$classIsSingleton) { if (array_key_exists($className, $this->prototypeObjectsWhichAreCurrentlyInstanciated) !== false) { throw new \TYPO3\CMS\Extbase\Object\Exception\CannotBuildObjectException('Cyclic dependency in prototype object, for class "' . $className . '".', 1295611406); } $this->prototypeObjectsWhichAreCurrentlyInstanciated[$className] = true; } $instance = $this->instanciateObject($classInfo, $givenConstructorArguments); $this->injectDependencies($instance, $classInfo); $this->initializeObject($instance, $classInfo); if (!$classIsSingleton) { unset($this->prototypeObjectsWhichAreCurrentlyInstanciated[$className]); } return $instance; }
/** * Determine the type converter to be used. If no converter has been found, an exception is raised. * * @param mixed $source * @param string $targetType * @param PropertyMappingConfigurationInterface $configuration * @throws Exception\TypeConverterException * @throws Exception\InvalidTargetException * @return \TYPO3\CMS\Extbase\Property\TypeConverterInterface Type Converter which should be used to convert between $source and $targetType. */ protected function findTypeConverter($source, $targetType, PropertyMappingConfigurationInterface $configuration) { if ($configuration->getTypeConverter() !== null) { return $configuration->getTypeConverter(); } $sourceType = $this->determineSourceType($source); if (!is_string($targetType)) { throw new Exception\InvalidTargetException('The target type was no string, but of type "' . gettype($targetType) . '"', 1297941727); } $targetType = $this->parseCompositeType($targetType); // This is needed to correctly convert old class names to new ones // This compatibility layer will be removed with 7.0 $targetType = \TYPO3\CMS\Core\Core\ClassLoadingInformation::getClassNameForAlias($targetType); $targetType = TypeHandlingUtility::normalizeType($targetType); $converter = null; if (TypeHandlingUtility::isSimpleType($targetType)) { if (isset($this->typeConverters[$sourceType][$targetType])) { $converter = $this->findEligibleConverterWithHighestPriority($this->typeConverters[$sourceType][$targetType], $source, $targetType); } } else { $converter = $this->findFirstEligibleTypeConverterInObjectHierarchy($source, $sourceType, $targetType); } if ($converter === null) { throw new Exception\TypeConverterException('No converter found which can be used to convert from "' . $sourceType . '" to "' . $targetType . '".'); } return $converter; }
/** * @param PackageInterface $package * @throws \TYPO3\CMS\Core\Exception */ protected function registerTransientClassLoadingInformationForPackage(PackageInterface $package) { ClassLoadingInformation::registerTransientClassLoadingInformationForPackage($package); }
/** * @param PackageInterface $package * @throws \TYPO3\CMS\Core\Exception */ protected function registerTransientClassLoadingInformationForPackage(PackageInterface $package) { if (Bootstrap::usesComposerClassLoading()) { return; } ClassLoadingInformation::registerTransientClassLoadingInformationForPackage($package); }
/** * Set a single option (denoted by $optionKey) for the given $typeConverter. * * @param string $typeConverter class name of type converter * @param string $optionKey * @param mixed $optionValue * @return \TYPO3\CMS\Extbase\Property\PropertyMappingConfiguration this * @api */ public function setTypeConverterOption($typeConverter, $optionKey, $optionValue) { if (strpos($typeConverter, '_') !== false) { $typeConverter = ClassLoadingInformation::getClassNameForAlias($typeConverter); } foreach ($this->getTypeConvertersWithParentClasses($typeConverter) as $typeConverter) { $this->configuration[$typeConverter][$optionKey] = $optionValue; } return $this; }
call_user_func(function () { $testbase = new \TYPO3\CMS\Core\Tests\Testbase(); $testbase->enableDisplayErrors(); $testbase->defineBaseConstants(); $testbase->defineSitePath(); $testbase->defineTypo3ModeBe(); $testbase->setTypo3TestingContext(); $testbase->createDirectory(PATH_site . 'typo3conf/ext'); $testbase->createDirectory(PATH_site . 'typo3temp/assets'); $testbase->createDirectory(PATH_site . 'typo3temp/var/tests'); $testbase->createDirectory(PATH_site . 'typo3temp/var/transient'); $testbase->createDirectory(PATH_site . 'uploads'); // Retrieve an instance of class loader and inject to core bootstrap $classLoaderFilepath = __DIR__ . '/../../../../vendor/autoload.php'; if (!file_exists($classLoaderFilepath)) { die('ClassLoader can\'t be loaded. Please check your path or set an environment variable \'TYPO3_PATH_WEB\' to your root path.'); } $classLoader = (require $classLoaderFilepath); \TYPO3\CMS\Core\Core\Bootstrap::getInstance()->initializeClassLoader($classLoader)->setRequestType(TYPO3_REQUESTTYPE_BE | TYPO3_REQUESTTYPE_CLI)->baseSetup(); // Initialize default TYPO3_CONF_VARS $configurationManager = new \TYPO3\CMS\Core\Configuration\ConfigurationManager(); $GLOBALS['TYPO3_CONF_VARS'] = $configurationManager->getDefaultConfiguration(); // Avoid failing tests that rely on HTTP_HOST retrieval $GLOBALS['TYPO3_CONF_VARS']['SYS']['trustedHostsPattern'] = '.*'; \TYPO3\CMS\Core\Core\Bootstrap::getInstance()->disableCoreCache()->initializeCachingFramework()->initializePackageManagement(\TYPO3\CMS\Core\Package\UnitTestPackageManager::class); if (!\TYPO3\CMS\Core\Core\Bootstrap::usesComposerClassLoading()) { // Dump autoload info if in non composer mode \TYPO3\CMS\Core\Core\ClassLoadingInformation::dumpClassLoadingInformation(); \TYPO3\CMS\Core\Core\ClassLoadingInformation::registerClassLoadingInformation(); } });
/** * Writes class loading information if not yet present * * @return Bootstrap * @internal This is not a public API method, do not use in own extensions */ public function ensureClassLoadingInformationExists() { if (!self::$usesComposerClassLoading && !ClassLoadingInformation::classLoadingInformationExists()) { ClassLoadingInformation::writeClassLoadingInformation(); ClassLoadingInformation::registerClassLoadingInformation(); } return $this; }
/** * Dumps Extension Autoload Information * * @return \TYPO3\CMS\Install\Status\StatusInterface */ protected function dumpAutoload() : \TYPO3\CMS\Install\Status\StatusInterface { if (Bootstrap::usesComposerClassLoading()) { $message = GeneralUtility::makeInstance(\TYPO3\CMS\Install\Status\NoticeStatus::class); $message->setTitle('Skipped generating additional class loading information in composer mode.'); } else { ClassLoadingInformation::dumpClassLoadingInformation(); $message = GeneralUtility::makeInstance(\TYPO3\CMS\Install\Status\OkStatus::class); $message->setTitle('Successfully dumped class loading information for extensions.'); } return $message; }
/** * Updates class loading information. * * This command is only needed during development. The extension manager takes care * creating or updating this info properly during extension (de-)activation. * * @return void * @cli */ public function dumpClassLoadingInformationCommand() { if (Bootstrap::usesComposerClassLoading()) { $this->output->outputLine('<error>Class loading information is managed by composer. Use "composer dump-autoload" command to update the information.</error>'); $this->quit(1); } else { ClassLoadingInformation::dumpClassLoadingInformation(); $this->output->outputLine('Class Loading information has been updated.'); } }
/** * Writes class loading information if not yet present * * @return Bootstrap * @internal This is not a public API method, do not use in own extensions * @deprecated since TYPO3 v8, will be removed in TYPO3 v9. Use the Install Tool to dump autoload information. */ public function ensureClassLoadingInformationExists() { if (!self::$usesComposerClassLoading && !ClassLoadingInformation::isClassLoadingInformationAvailable()) { GeneralUtility::logDeprecatedFunction(); ClassLoadingInformation::dumpClassLoadingInformation(); ClassLoadingInformation::registerClassLoadingInformation(); } return $this; }