PHP Filesystem::makePathRelative方法代码示例

 /**
  * @param string $targetPath
  * @param string $installPath
  * @param array $map
  * @param bool $isSymlink
  * @param bool $isRelative
  *
  * @throws IOException
  * @throws \InvalidArgumentException
  *
  * @api
  *
  * @quality:method [B]
  */
 public function publish($targetPath, $installPath, array $map, $isSymlink, $isRelative)
 {
     $targetPath = rtrim($targetPath, '/');
     $installPath = rtrim($installPath, '/');
     $this->filesystem->mkdir($targetPath, 0777);
     foreach ($map as $from => $to) {
         $targetDir = realpath($targetPath) . '/' . $to;
         $sourceDir = realpath($installPath) . '/' . $from;
         $this->filesystem->remove($targetDir);
         if ($isSymlink) {
             $this->io->write(sprintf('Trying to install AdminLTE %s assets as symbolic links.', $from));
             $originDir = $sourceDir;
             if ($isRelative) {
                 $originDir = $this->filesystem->makePathRelative($sourceDir, realpath($targetPath));
             }
             try {
                 $this->filesystem->symlink($originDir, $targetDir);
                 $this->io->write(sprintf('The AdminLTE %s assets were installed using symbolic links.', $from));
             } catch (IOException $e) {
                 $this->hardCopy($sourceDir, $targetDir);
                 $this->io->write(sprintf('It looks like your system doesn\'t support symbolic links,
                     so the AdminLTE %s assets were installed by copying them.', $from));
             }
         } else {
             $this->io->write(sprintf('Installing AdminLTE %s assets as <comment>hard copies</comment>.', $from));
             $this->hardCopy($sourceDir, $targetDir);
         }
     }
 }

 private function symlinkPackageToVendor($packagePath, $vendorPath)
 {
     $relative = $this->fileSystem->makePathRelative(realpath($packagePath), realpath($vendorPath . '/../'));
     $this->fileSystem->rename($vendorPath, $vendorPath . '_linked', true);
     $this->fileSystem->symlink($relative, $vendorPath);
     $this->fileSystem->remove($vendorPath . '_linked');
 }

 /**
  * Adds extra JS to load on pages using the Scribite editor.
  *
  * @param Zikula_Event $event
  */
 public function getScribiteEditorHelpers(Zikula_Event $event)
 {
     // intended is using the add() method to add a helper like below
     $helpers = $event->getSubject();
     $helpers->add(['module' => 'CmfcmfMediaModule', 'type' => 'javascript', 'path' => $this->fs->makePathRelative($this->resourceRoot . '/public/js/vendor', $this->zikulaRoot) . 'toastr.min.js']);
     $helpers->add(['module' => 'CmfcmfMediaModule', 'type' => 'stylesheet', 'path' => $this->fs->makePathRelative($this->resourceRoot . '/public/css/vendor', $this->zikulaRoot) . 'toastr.min.css']);
     $helpers->add(['module' => 'CmfcmfMediaModule', 'type' => 'javascript', 'path' => $this->fs->makePathRelative($this->resourceRoot . '/public/js', $this->zikulaRoot) . 'util.js']);
 }

 /**
  * @param string $src
  *
  * @return Configuration
  */
 private function createConfig($src)
 {
     $configuration = new Configuration($src);
     $configuration->setJsonFile('component.json');
     $configuration->setEndpoint('https://bower.herokuapp.com');
     $configuration->setCache(new FilesystemCache($this->target . '/cache'));
     $configuration->setAssetDirectory($this->filesystem->makePathRelative($this->target . '/components', $src));
     return $configuration;
 }

 public function __construct(TranslatorInterface $translator, $kernelCacheDir, $kernelRootDir)
 {
     $this->fs = new Filesystem();
     $this->cacheFile = $kernelCacheDir . "/CmfcmfMediaModule.zip";
     $zikulaDir = realpath($kernelRootDir . '/..');
     $this->moduleDir = $this->fs->makePathRelative(realpath(__DIR__ . '/..'), $zikulaDir);
     $this->domain = \ZLanguage::getModuleDomain('CmfcmfMediaModule');
     $this->translator = $translator;
 }

 protected function getCompilationOptions()
 {
     $fs = new Filesystem();
     $fs->mkdir(dirname($this->getBootstrapLessFile()));
     $assets_dir = $fs->makePathRelative(realpath($this->getAssetsDir()), realpath(dirname($this->getBootstrapLessFile())));
     $variablesDir = $fs->makePathRelative(realpath(dirname($this->getVariablesFile())), realpath(dirname($this->getBootstrapLessFile())));
     $variablesFile = sprintf('%s%s', $variablesDir, basename($this->getVariablesFile()));
     return array('variables_dir' => $variablesDir, 'variables_file' => $variablesFile, 'assets_dir' => $assets_dir);
 }

 /**
  * @param Bundle  $bundle
  * @param string  $type
  * @param boolean $regenerate
  *
  * @return string
  */
 public function show(Bundle $bundle, $type = 'long', $regenerate = false)
 {
     $relativePath = $this->filesystem->makePathRelative($this->cacheDir, $this->rootDir);
     $filename = sprintf('%sbadges/%s/%s-%s.png', $relativePath, $type, $bundle->getOwnerName(), $bundle->getName());
     if (false !== $regenerate || !$this->filesystem->exists($filename)) {
         $this->generate($bundle);
     }
     return $filename;
 }

 private function symlink($target, $link)
 {
     // echo __LINE__, "\n", $target, " ==> " , $link, "\n" ;
     if (!file_exists($target)) {
         throw new \Exception(sprintf("`%s` is not exists", $target));
     }
     if (is_link($link)) {
         $_target = readlink($link);
         if (realpath($_target) != realpath($target)) {
             // throw new \Exception( sprintf("`%s` should be a link point to `%s`, but it point to `%s`",  $link , $target, $_target ) ) ;
             unlink($link);
         } else {
             return;
         }
     } else {
         if (file_exists($link)) {
             throw new \Exception(sprintf("`%s` should be a link point to `%s`", $link, $target));
         }
     }
     $_path = $this->file_system->makePathRelative($target, dirname($link));
     $_path = rtrim($_path, '/');
     symlink($_path, $link);
     if (!file_exists($link)) {
         throw new \Exception(sprintf("`%s` is not exists, link to `%s` -> `%s`", $link, $_path, $target));
     }
 }

 /**
  * Links Drupal core, modules, themes and assets into Drupal root.
  *
  * @param Event $event
  */
 public static function prepareDrupalRoot(Event $event)
 {
     $options = self::getOptions($event);
     $composer = $event->getComposer();
     $filesystem = new Filesystem();
     $originDir = realpath($composer->getConfig()->get('vendor-dir') . '/drupal/drupal');
     $targetDir = realpath($options['drupal-root']);
     if (is_dir($originDir)) {
         if ($options['drupal-install']['relative']) {
             $originDir = rtrim($filesystem->makePathRelative($originDir, $targetDir), '/');
         }
         $directories = array('includes', 'misc', 'modules', 'themes');
         foreach ($directories as $directory) {
             $filesystem->remove($targetDir . '/' . $directory);
             if ($options['drupal-install']['symlink']) {
                 $event->getIO()->write(sprintf('Creating symlink for Drupal\'s \'%s\' directory', $directory));
                 $filesystem->symlink($originDir . '/' . $directory, $targetDir . '/' . $directory);
             } else {
                 $event->getIO()->write(sprintf('Copying Drupal\'s \'%s\' directory to web root', $directory));
                 $filesystem->mkdir($targetDir . '/' . $directory, 0777);
                 // We use a custom iterator to ignore VCS files
                 $filesystem->mirror($originDir . '/' . $directory, $targetDir . '/' . $directory, Finder::create()->ignoreDotFiles(false)->in($originDir));
             }
         }
     }
 }

 /**
  * @param $dir
  * @param  InputInterface  $input
  * @param  OutputInterface $output
  * @return bool
  */
 private function installPluginAssets($dir, InputInterface $input, OutputInterface $output)
 {
     // Create the specific assets directory otherwise symlink will fail.
     $assetsDir = $dir . '/assets/plugins/';
     $this->filesystem->mkdir($assetsDir, 0777);
     $plugins = $this->getContainer()->get('simplr.pluginmanager')->getActivePlugins();
     if (!empty($plugins)) {
         foreach ($plugins as $name => $configuration) {
             $activePluginPath = $this->getContainer()->get('simplr.pluginmanager')->getPathToPlugin($name);
             if (is_dir($originDir = $activePluginPath . '/Resources/public')) {
                 $targetDir = $assetsDir . strtolower($name);
                 $output->writeln(sprintf("Installing assets for plugin <comment>%s</comment> into <comment>%s</comment>", $name, $targetDir));
                 $this->filesystem->remove($targetDir);
                 if ($input->getOption('symlink')) {
                     if ($input->getOption('relative')) {
                         $relativeOriginDir = $this->filesystem->makePathRelative($originDir, realpath($assetsDir));
                     } else {
                         $relativeOriginDir = $originDir;
                     }
                     $this->filesystem->symlink($relativeOriginDir, $targetDir);
                 } else {
                     $this->filesystem->mkdir($targetDir, 0777);
                     // We use a custom iterator to ignore VCS files
                     $this->filesystem->mirror($originDir, $targetDir, Finder::create()->in($originDir));
                 }
             }
         }
     } else {
         $output->writeln('Installing assets for plugins... no plugins found!');
     }
     return true;
 }

 public function bbs_twig_template(\Twig_Environment $env, $file, $path, $templateid = 0)
 {
     /**
      * @var $loader \Symfony\Bundle\TwigBundle\Loader\FilesystemLoader
      */
     $loader = $env->getLoader();
     $tplfile = $loader->getCacheKey($file);
     if (null === $this->file_system) {
         $this->file_system = new \Symfony\Component\Filesystem\Filesystem();
     }
     $tplfile = rtrim($this->file_system->makePathRelative($tplfile, DISCUZ_ROOT), '/');
     if (empty($path) || !is_string($path)) {
         throw new \Exception(sprintf("path(%s) must be string", json_encode($path)));
     }
     $this->cache['app_template_cache_file'] = './data/template/' . (defined('STYLEID') ? STYLEID . '_' : '_') . $templateid . '_' . preg_replace('/\\W/', '_', $file) . '.tpl.php';
     $tpldir = './template/default';
     $_pos = strpos($path, ':');
     if (false !== $_pos) {
         if ($_pos !== strrpos($path, ':')) {
             throw new \Exception(sprintf('not implement locate plugin tempalte dir:%s', $path));
         }
         $tpldir = sprintf('./source/plugin/%s/template', substr($path, 0, $_pos));
     }
     checktplrefresh($tplfile, $tplfile, @filemtime(DISCUZ_ROOT . $this->cache['app_template_cache_file']), $templateid, $this->cache['app_template_cache_file'], $tpldir, $path);
     unset($tplfile, $tpldir, $loader, $env, $path, $templateid, $_pos);
     extract($GLOBALS, EXTR_REFS);
     include DISCUZ_ROOT . $this->cache['app_template_cache_file'];
 }

 /**
  * @return GitRepository
  */
 protected function initializeLocalRepository()
 {
     $cloneUrl = $this->filesystem->makePathRelative(self::REMOTE_REPOSITORY_DIRECTORY, dirname(self::LOCAL_REPOSITORY_DIRECTORY));
     $localRepository = new GitRepository($this->gitWrapper, self::LOCAL_REPOSITORY_DIRECTORY);
     $localRepository->create($cloneUrl);
     return $localRepository;
 }

 /**
  * Get relative path.
  *
  * @param string $namespace
  *
  * @return string
  */
 public function levelUp($namespace)
 {
     if (empty($namespace)) {
         return '';
     } else {
         return $this->fs->makePathRelative($this->outputDir, $this->getPathByNamespace($namespace, true));
     }
 }

 /**
  * Prints trace / call stack / backtrace of an exception.
  *
  * @param  array  $trace The back trace to print out.
  */
 private function printExceptionTrace(array $trace)
 {
     $trace = array_reverse($trace);
     $this->output->writeln('Call Stack:');
     foreach ($trace as $i => $call) {
         $this->output->writeln(sprintf('    %d. <info>%s%s%s(</info>%s<info>)</info> in <comment>%s</comment>:%d', $i + 1, $call['class'], $call['type'], $call['function'], $this->parseCallArguments($call['args']), $this->filesystem->makePathRelative($call['file'], $this->cwd), $call['line']));
     }
 }

 /**
  * Checks if giving a relative path results in the same path under water.
  */
 public function testCacheDirLocation()
 {
     $cacheDirLocation = $this->cache->getDirectory();
     $filesystem = new Filesystem();
     $relative = $filesystem->makePathRelative($cacheDirLocation, __DIR__);
     $newCache = new Cache($relative);
     $this->assertEquals($cacheDirLocation, $newCache->getDirectory());
 }