PHP PathUtility::getRelativePathTo方法代码示例

 /**
  * Return a public path pointing to a resource.
  *
  * @param string $resource
  * @return string
  */
 public static function getRelativePath($resource)
 {
     // If file is not found, resolve the path
     if (!is_file(PATH_site . $resource)) {
         $resource = substr(self::resolvePath($resource), strlen(PATH_site));
     }
     return PathUtility::getRelativePathTo(PathUtility::dirname(PATH_site . $resource)) . PathUtility::basename($resource);
 }

 /**
  * Get url
  *
  * @param bool $relativeToCurrentScript Determines whether the URL returned should be relative to the current script, in case it is relative at all.
  * @return string
  */
 public function getUrl($relativeToCurrentScript = false)
 {
     $url = $this->url;
     if ($relativeToCurrentScript && !GeneralUtility::isValidUrl($url)) {
         $absolutePathToContainingFolder = PathUtility::dirname(PATH_site . $url);
         $pathPart = PathUtility::getRelativePathTo($absolutePathToContainingFolder);
         $filePart = substr(PATH_site . $url, strlen($absolutePathToContainingFolder) + 1);
         $url = $pathPart . $filePart;
     }
     return $url;
 }

 /**
  * @param ResourceStorage $storage
  * @param AbstractDriver $driver
  * @param ResourceInterface $resource
  * @param boolean $relativeToCurrentScript
  * @param array $urlData
  */
 public function getPublicUrl(ResourceStorage $storage, AbstractDriver $driver, ResourceInterface $resource, $relativeToCurrentScript, array $urlData)
 {
     if (!$driver instanceof LocalDriver) {
         // We cannot handle other files than local files yet
         return;
     }
     $publicUrl = $this->resourcePublisher->getResourceWebUri($resource);
     if ($publicUrl !== FALSE) {
         // If requested, make the path relative to the current script in order to make it possible
         // to use the relative file
         if ($relativeToCurrentScript) {
             $publicUrl = PathUtility::getRelativePathTo(PathUtility::dirname(PATH_site . $publicUrl)) . PathUtility::basename($publicUrl);
         }
         // $urlData['publicUrl'] is passed by reference, so we can change that here and the value will be taken into account
         $urlData['publicUrl'] = $publicUrl;
     }
 }

 /**
  * @param string $content
  * @param array $conf
  * @return string
  */
 public function getTemplateFromName($content, $conf)
 {
     $basename = $content;
     if ($conf['paths'][0] === '<') {
         $key = trim(substr($conf['paths'], 1));
         $typoScriptParser = GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\TypoScript\\Parser\\TypoScriptParser');
         list($name, $conf['paths.']) = $typoScriptParser->getVal($key, $GLOBALS['TSFE']->tmpl->setup);
     }
     $paths = ArrayUtility::sortArrayWithIntegerKeys($conf['paths.']);
     $paths = array_reverse($paths, TRUE);
     foreach ($paths as $path) {
         // why does it have to be relative?
         $test_file = PathUtility::getRelativePathTo(GeneralUtility::getFileAbsFileName($path)) . $basename;
         if (is_file($test_file)) {
             return $test_file;
         }
         if (is_file($test_file . '.html')) {
             return $test_file . '.html';
         }
     }
     return $content;
 }

 /**
  * Returns the public URL to a file.
  *
  * @param \TYPO3\CMS\Core\Resource\ResourceInterface $resource
  * @param bool  $relativeToCurrentScript    Determines whether the URL returned should be relative to the current script, in case it is relative at all (only for the LocalDriver)
  * @return string
  */
 public function getPublicUrl(\TYPO3\CMS\Core\Resource\ResourceInterface $resource, $relativeToCurrentScript = false)
 {
     if (\TYPO3\CMS\Core\Utility\GeneralUtility::isFirstPartOfStr($resource->getIdentifier(), '/_processed_/')) {
         $publicUrl = '../typo3temp/yag' . $resource->getIdentifier();
         // TODO: ....!!!!
     } else {
         $item = $resource->getProperty('yagItem');
         if (!$item instanceof \Tx_Yag_Domain_Model_Item) {
             $pathInfo = new PathInfo($resource->getIdentifier());
             $item = $this->getItem($pathInfo);
         }
         $publicUrl = $this->yagFileSystemDiv->getFileRelFileName($item->getSourceuri());
     }
     if ($relativeToCurrentScript) {
         $publicUrl = PathUtility::getRelativePathTo(PathUtility::dirname(PATH_site . $publicUrl)) . PathUtility::basename($publicUrl);
     }
     return $publicUrl;
 }

 /**
  * Returns a publicly accessible URL for a file.
  *
  * WARNING: Access to the file may be restricted by further means, e.g.
  * some web-based authentication. You have to take care of this yourself.
  *
  * @param ResourceInterface $resourceObject The file or folder object
  * @param bool $relativeToCurrentScript Determines whether the URL returned should be relative to the current script, in case it is relative at all (only for the LocalDriver)
  * @return string
  */
 public function getPublicUrl(ResourceInterface $resourceObject, $relativeToCurrentScript = false)
 {
     $publicUrl = null;
     if ($this->isOnline()) {
         // Pre-process the public URL by an accordant slot
         $this->emitPreGeneratePublicUrlSignal($resourceObject, $relativeToCurrentScript, array('publicUrl' => &$publicUrl));
         if ($publicUrl === null && $resourceObject instanceof File && ($helper = OnlineMediaHelperRegistry::getInstance()->getOnlineMediaHelper($resourceObject)) !== false) {
             $publicUrl = $helper->getPublicUrl($resourceObject, $relativeToCurrentScript);
         }
         // If slot did not handle the signal, use the default way to determine public URL
         if ($publicUrl === null) {
             if ($this->hasCapability(self::CAPABILITY_PUBLIC)) {
                 $publicUrl = $this->driver->getPublicUrl($resourceObject->getIdentifier());
             }
             if ($publicUrl === null && $resourceObject instanceof FileInterface) {
                 $queryParameterArray = array('eID' => 'dumpFile', 't' => '');
                 if ($resourceObject instanceof File) {
                     $queryParameterArray['f'] = $resourceObject->getUid();
                     $queryParameterArray['t'] = 'f';
                 } elseif ($resourceObject instanceof ProcessedFile) {
                     $queryParameterArray['p'] = $resourceObject->getUid();
                     $queryParameterArray['t'] = 'p';
                 }
                 $queryParameterArray['token'] = GeneralUtility::hmac(implode('|', $queryParameterArray), 'resourceStorageDumpFile');
                 $publicUrl = 'index.php?' . str_replace('+', '%20', http_build_query($queryParameterArray));
             }
             // If requested, make the path relative to the current script in order to make it possible
             // to use the relative file
             if ($publicUrl !== null && $relativeToCurrentScript && !GeneralUtility::isValidUrl($publicUrl)) {
                 $absolutePathToContainingFolder = PathUtility::dirname(PATH_site . $publicUrl);
                 $pathPart = PathUtility::getRelativePathTo($absolutePathToContainingFolder);
                 $filePart = substr(PATH_site . $publicUrl, strlen($absolutePathToContainingFolder) + 1);
                 $publicUrl = $pathPart . $filePart;
             }
         }
     }
     return $publicUrl;
 }

 /**
  * Returns the public URL to a file. For the local driver, this will always
  * return a path relative to PATH_site.
  *
  * @param \TYPO3\CMS\Core\Resource\ResourceInterface  $fileOrFolder
  * @param bool $relativeToCurrentScript Determines whether the URL returned should be relative to the current script, in case it is relative at all (only for the LocalDriver)
  * @return string
  */
 public function getPublicUrl(\TYPO3\CMS\Core\Resource\ResourceInterface $fileOrFolder, $relativeToCurrentScript = FALSE)
 {
     if ($this->configuration['pathType'] === 'relative' && rtrim($this->configuration['basePath'], '/') !== '') {
         $publicUrl = rtrim($this->configuration['basePath'], '/') . '/' . ltrim($fileOrFolder->getIdentifier(), '/');
     } elseif (isset($this->baseUri)) {
         $publicUrl = $this->baseUri . ltrim($fileOrFolder->getIdentifier(), '/');
     } else {
         throw new \TYPO3\CMS\Core\Resource\Exception('Public URL of file cannot be determined', 1329765518);
     }
     // If requested, make the path relative to the current script in order to make it possible
     // to use the relative file
     if ($relativeToCurrentScript) {
         $publicUrl = \TYPO3\CMS\Core\Utility\PathUtility::getRelativePathTo(dirname(PATH_site . $publicUrl)) . basename($publicUrl);
     }
     return $publicUrl;
 }

 /**
  * Add all *.css files of the directory $path to the stylesheets
  *
  * @param string $path directory to add
  * @return void
  */
 public function addStyleSheetDirectory($path)
 {
     $path = GeneralUtility::getFileAbsFileName($path);
     // Read all files in directory and sort them alphabetically
     $cssFiles = GeneralUtility::getFilesInDir($path, 'css');
     foreach ($cssFiles as $cssFile) {
         $this->pageRenderer->addCssFile(PathUtility::getRelativePathTo($path) . $cssFile);
     }
 }

 /**
  * Resolve path
  *
  * @param string $resourcePath
  * @return NULL|string
  */
 protected function resolvePath($resourcePath)
 {
     $absoluteFilePath = \TYPO3\CMS\Core\Utility\GeneralUtility::getFileAbsFileName($resourcePath);
     $absolutePath = dirname($absoluteFilePath);
     $fileName = basename($absoluteFilePath);
     return \TYPO3\CMS\Core\Utility\PathUtility::getRelativePathTo($absolutePath) . $fileName;
 }

 /**
  * Get relative path from absolute path, but don't touch if it's already a relative path
  *
  * @param string $path
  * @return string
  */
 public static function getRelativeFolder($path)
 {
     if (PathUtility::isAbsolutePath($path)) {
         $path = PathUtility::getRelativePathTo($path);
     }
     return $path;
 }

 /**
  * Collects information about the file
  * @param  string $filename Filename
  * @return array            Array of collected information
  */
 private function getFileInformation($filename, $throwExeptions = TRUE)
 {
     $fileProperties = array();
     $fileProperties['filename'] = $filename;
     if (strlen(trim($filename)) == 0 && $throwExeptions) {
         throw new \Exception(LocalizationUtility::translate('iconFontSelector.exception.missingFilename', 't3kit_extension_tools'), 20);
     }
     $fileProperties['absFileName'] = GeneralUtility::getFileAbsFileName($filename);
     $fileProperties['fileExists'] = file_exists($fileProperties['absFileName']);
     if (!$fileProperties['fileExists'] && $throwExeptions) {
         throw new \Exception(LocalizationUtility::translate('iconFontSelector.exception.fileExists', 't3kit_extension_tools') . ' (' . $filename . ')', 21);
     }
     $pathInfo = PathUtility::pathinfo($fileProperties['absFileName']);
     $fileProperties['dirname'] = $pathInfo['dirname'];
     $fileProperties['basename'] = $pathInfo['basename'];
     $fileProperties['extension'] = $pathInfo['extension'];
     $fileProperties['filename'] = $pathInfo['filename'];
     $fileProperties['isAllowedAbsPath'] = GeneralUtility::isAllowedAbsPath($fileProperties['absFileName']);
     if (!$fileProperties['isAllowedAbsPath'] && $throwExeptions) {
         throw new \Exception(LocalizationUtility::translate('iconFontSelector.exception.isAllowedAbsPath', 't3kit_extension_tools'), 22);
     }
     $fileProperties['relativePath'] = PathUtility::getRelativePathTo($fileProperties['dirname']);
     return $fileProperties;
 }

 /**
  * signal slot for public url generation of a file
  * @see \TYPO3\CMS\Core\Resource\ResourceStorage and the function getPublicUrl
  * 
  * @param \TYPO3\CMS\Core\Resource\ResourceStorage $t
  * @param \TYPO3\CMS\Core\Resource\Driver\LocalDriver $driver
  * @param object $resourceObject e.g. \TYPO3\CMS\Core\Resource\File, \TYPO3\CMS\Core\Resource\Folder, \TYPO3\CMS\Core\Resource\ProcessedFile
  * @param boolean $relativeToCurrentScript
  * @param array $urlData
  * 
  * @return void
  */
 public function preGeneratePublicUrl($t, $driver, $resourceObject, $relativeToCurrentScript, $urlData)
 {
     $this->emSettings = unserialize($GLOBALS['TYPO3_CONF_VARS']['EXT']['extConf'][$this->extKey]);
     // check if resource is file
     if (is_a($resourceObject, 'TYPO3\\CMS\\Core\\Resource\\File')) {
         $fileData = $this->getFileData($resourceObject);
         $newPublicUrl = '';
         $enable = true;
         // check if TYPO3 is in frontend mode
         if (TYPO3_MODE === 'FE') {
             if ($this->emSettings['disable_fe']) {
                 $enable = false;
             } else {
                 // check filetypes field
                 if (!empty($this->emSettings['filetypes_fe'])) {
                     $filetypes = explode(',', $this->emSettings['filetypes_fe']);
                     if (in_array($fileData['extension'], $filetypes)) {
                     } else {
                         $enable = false;
                     }
                 }
                 if ($enable) {
                     $newPublicUrl = $driver->getPublicUrl($fileData['identifier']);
                 }
             }
         }
         // check if TYPO3 is in backend mode and make the path relative to the current script
         // in order to make it possible to use the relative file
         if (TYPO3_MODE === 'BE' && $relativeToCurrentScript) {
             //DebuggerUtility::var_dump($this->emSettings);
             if ($this->emSettings['disable_be']) {
                 $enable = false;
             } else {
                 // check filetypes field
                 if (!empty($this->emSettings['filetypes_be'])) {
                     $filetypes = explode(',', $this->emSettings['filetypes_be']);
                     if (in_array($fileData['extension'], $filetypes)) {
                     } else {
                         $enable = false;
                     }
                 }
                 if ($enable) {
                     $publicUrl = $driver->getPublicUrl($fileData['identifier']);
                     $absolutePathToContainingFolder = PathUtility::dirname(PATH_site . $publicUrl);
                     $pathPart = PathUtility::getRelativePathTo($absolutePathToContainingFolder);
                     $filePart = substr(PATH_site . $publicUrl, strlen($absolutePathToContainingFolder) + 1);
                     $newPublicUrl = $pathPart . $filePart;
                 }
             }
         }
         if (!empty($newPublicUrl) && !empty($fileData['modDate']) && $enable) {
             $urlData['publicUrl'] = $newPublicUrl . '?v=' . $fileData['modDate'];
         }
     }
 }

 /**
  * this method creates sprite icon names for all tables in TCA (including their possible type-icons)
  * where there is no "typeicon_classes" of this TCA table ctrl section
  * (moved form \TYPO3\CMS\Backend\Utility\IconUtility)
  *
  * @return array Array as $iconName => $fileName
  */
 protected function collectTcaSpriteIcons()
 {
     $tcaTables = array_keys($GLOBALS['TCA']);
     $resultArray = array();
     // Path (relative from typo3 dir) for skin-Images
     if (isset($GLOBALS['TBE_STYLES']['skinImgAutoCfg']['relDir'])) {
         $skinPath = $GLOBALS['TBE_STYLES']['skinImgAutoCfg']['relDir'];
     } else {
         $skinPath = '';
     }
     // check every table in the TCA, if an icon is needed
     foreach ($tcaTables as $tableName) {
         // This method is only needed for TCA tables where
         // typeicon_classes are not configured
         if (is_array($GLOBALS['TCA'][$tableName]) && !is_array($GLOBALS['TCA'][$tableName]['ctrl']['typeicon_classes'])) {
             $tcaCtrl = $GLOBALS['TCA'][$tableName]['ctrl'];
             // Adding the default Icon (without types)
             if (isset($tcaCtrl['iconfile'])) {
                 // In CSS we need a path relative to the css file
                 // [TCA][ctrl][iconfile] defines icons without path info to reside in gfx/i/
                 if (\TYPO3\CMS\Core\Utility\StringUtility::beginsWith($tcaCtrl['iconfile'], 'EXT:')) {
                     list($extensionKey, $relativePath) = explode('/', substr($tcaCtrl['iconfile'], 4), 2);
                     $pathInfo = PathUtility::pathinfo(\TYPO3\CMS\Core\Utility\ExtensionManagementUtility::extPath($extensionKey) . $relativePath);
                     $path = PathUtility::getRelativePathTo($pathInfo['dirname']);
                     $icon = $path . $pathInfo['basename'];
                 } elseif (strpos($tcaCtrl['iconfile'], '/') !== false) {
                     $icon = $tcaCtrl['iconfile'];
                     $icon = GeneralUtility::resolveBackPath($icon);
                 } else {
                     $icon = $skinPath . 'gfx/i/' . $tcaCtrl['iconfile'];
                     $icon = GeneralUtility::resolveBackPath($icon);
                 }
                 $resultArray['tcarecords-' . $tableName . '-default'] = $icon;
             }
         }
     }
     return $resultArray;
 }