dependabot-composer 0.108.10 → 0.108.11

data/helpers/vendor/composer/composer/src/Composer/Downloader/GzipDownloader.php

@@ -0,0 +1,84 @@
+<?php
+
+/*
+ * This file is part of Composer.
+ *
+ * (c) Nils Adermann <naderman@naderman.de>
+ *     Jordi Boggiano <j.boggiano@seld.be>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Composer\Downloader;
+
+use Composer\Config;
+use Composer\Cache;
+use Composer\EventDispatcher\EventDispatcher;
+use Composer\Package\PackageInterface;
+use Composer\Util\Platform;
+use Composer\Util\ProcessExecutor;
+use Composer\Util\RemoteFilesystem;
+use Composer\IO\IOInterface;
+
+/**
+ * GZip archive downloader.
+ *
+ * @author Pavel Puchkin <i@neoascetic.me>
+ */
+class GzipDownloader extends ArchiveDownloader
+{
+    protected $process;
+
+    public function __construct(IOInterface $io, Config $config, EventDispatcher $eventDispatcher = null, Cache $cache = null, ProcessExecutor $process = null, RemoteFilesystem $rfs = null)
+    {
+        $this->process = $process ?: new ProcessExecutor($io);
+        parent::__construct($io, $config, $eventDispatcher, $cache, $rfs);
+    }
+
+    protected function extract($file, $path)
+    {
+        $targetFilepath = $path . DIRECTORY_SEPARATOR . basename(substr($file, 0, -3));
+
+        // Try to use gunzip on *nix
+        if (!Platform::isWindows()) {
+            $command = 'gzip -cd ' . ProcessExecutor::escape($file) . ' > ' . ProcessExecutor::escape($targetFilepath);
+
+            if (0 === $this->process->execute($command, $ignoredOutput)) {
+                return;
+            }
+
+            if (extension_loaded('zlib')) {
+                // Fallback to using the PHP extension.
+                $this->extractUsingExt($file, $targetFilepath);
+
+                return;
+            }
+
+            $processError = 'Failed to execute ' . $command . "\n\n" . $this->process->getErrorOutput();
+            throw new \RuntimeException($processError);
+        }
+
+        // Windows version of PHP has built-in support of gzip functions
+        $this->extractUsingExt($file, $targetFilepath);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function getFileName(PackageInterface $package, $path)
+    {
+        return $path.'/'.pathinfo(parse_url($package->getDistUrl(), PHP_URL_PATH), PATHINFO_BASENAME);
+    }
+
+    private function extractUsingExt($file, $targetFilepath)
+    {
+        $archiveFile = gzopen($file, 'rb');
+        $targetFile = fopen($targetFilepath, 'wb');
+        while ($string = gzread($archiveFile, 4096)) {
+            fwrite($targetFile, $string, Platform::strlen($string));
+        }
+        gzclose($archiveFile);
+        fclose($targetFile);
+    }
+}

data/helpers/vendor/composer/composer/src/Composer/Downloader/HgDownloader.php

@@ -0,0 +1,100 @@
+<?php
+
+/*
+ * This file is part of Composer.
+ *
+ * (c) Nils Adermann <naderman@naderman.de>
+ *     Jordi Boggiano <j.boggiano@seld.be>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Composer\Downloader;
+
+use Composer\Package\PackageInterface;
+use Composer\Util\ProcessExecutor;
+use Composer\Util\Hg as HgUtils;
+
+/**
+ * @author Per Bernhardt <plb@webfactory.de>
+ */
+class HgDownloader extends VcsDownloader
+{
+    /**
+     * {@inheritDoc}
+     */
+    public function doDownload(PackageInterface $package, $path, $url)
+    {
+        $hgUtils = new HgUtils($this->io, $this->config, $this->process);
+
+        $cloneCommand = function ($url) use ($path) {
+            return sprintf('hg clone %s %s', ProcessExecutor::escape($url), ProcessExecutor::escape($path));
+        };
+
+        $hgUtils->runCommand($cloneCommand, $url, $path);
+
+        $ref = ProcessExecutor::escape($package->getSourceReference());
+        $command = sprintf('hg up %s', $ref);
+        if (0 !== $this->process->execute($command, $ignoredOutput, realpath($path))) {
+            throw new \RuntimeException('Failed to execute ' . $command . "\n\n" . $this->process->getErrorOutput());
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function doUpdate(PackageInterface $initial, PackageInterface $target, $path, $url)
+    {
+        $hgUtils = new HgUtils($this->io, $this->config, $this->process);
+
+        $ref = $target->getSourceReference();
+        $this->io->writeError(" Updating to ".$target->getSourceReference());
+
+        if (!$this->hasMetadataRepository($path)) {
+            throw new \RuntimeException('The .hg directory is missing from '.$path.', see https://getcomposer.org/commit-deps for more information');
+        }
+
+        $command = function ($url) use ($ref) {
+            return sprintf('hg pull %s && hg up %s', ProcessExecutor::escape($url), ProcessExecutor::escape($ref));
+        };
+
+        $hgUtils->runCommand($command, $url, $path);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getLocalChanges(PackageInterface $package, $path)
+    {
+        if (!is_dir($path.'/.hg')) {
+            return null;
+        }
+
+        $this->process->execute('hg st', $output, realpath($path));
+
+        return trim($output) ?: null;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function getCommitLogs($fromReference, $toReference, $path)
+    {
+        $command = sprintf('hg log -r %s:%s --style compact', ProcessExecutor::escape($fromReference), ProcessExecutor::escape($toReference));
+
+        if (0 !== $this->process->execute($command, $output, realpath($path))) {
+            throw new \RuntimeException('Failed to execute ' . $command . "\n\n" . $this->process->getErrorOutput());
+        }
+
+        return $output;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function hasMetadataRepository($path)
+    {
+        return is_dir($path . '/.hg');
+    }
+}

data/helpers/vendor/composer/composer/src/Composer/Downloader/PathDownloader.php

@@ -0,0 +1,202 @@
+<?php
+
+/*
+ * This file is part of Composer.
+ *
+ * (c) Nils Adermann <naderman@naderman.de>
+ *     Jordi Boggiano <j.boggiano@seld.be>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Composer\Downloader;
+
+use Composer\Package\Archiver\ArchivableFilesFinder;
+use Composer\Package\Dumper\ArrayDumper;
+use Composer\Package\PackageInterface;
+use Composer\Package\Version\VersionGuesser;
+use Composer\Package\Version\VersionParser;
+use Composer\Util\Platform;
+use Composer\Util\ProcessExecutor;
+use Composer\Util\Filesystem as ComposerFilesystem;
+use Symfony\Component\Filesystem\Exception\IOException;
+use Symfony\Component\Filesystem\Filesystem;
+
+/**
+ * Download a package from a local path.
+ *
+ * @author Samuel Roze <samuel.roze@gmail.com>
+ * @author Johann Reinke <johann.reinke@gmail.com>
+ */
+class PathDownloader extends FileDownloader implements VcsCapableDownloaderInterface
+{
+    const STRATEGY_SYMLINK = 10;
+    const STRATEGY_MIRROR = 20;
+
+    /**
+     * {@inheritdoc}
+     */
+    public function download(PackageInterface $package, $path, $output = true)
+    {
+        $url = $package->getDistUrl();
+        $realUrl = realpath($url);
+        if (false === $realUrl || !file_exists($realUrl) || !is_dir($realUrl)) {
+            throw new \RuntimeException(sprintf(
+                'Source path "%s" is not found for package %s',
+                $url,
+                $package->getName()
+            ));
+        }
+
+        if (strpos(realpath($path) . DIRECTORY_SEPARATOR, $realUrl . DIRECTORY_SEPARATOR) === 0) {
+            // IMPORTANT NOTICE: If you wish to change this, don't. You are wasting your time and ours.
+            //
+            // Please see https://github.com/composer/composer/pull/5974 and https://github.com/composer/composer/pull/6174
+            // for previous attempts that were shut down because they did not work well enough or introduced too many risks.
+            throw new \RuntimeException(sprintf(
+                'Package %s cannot install to "%s" inside its source at "%s"',
+                $package->getName(),
+                realpath($path),
+                $realUrl
+            ));
+        }
+
+        // Get the transport options with default values
+        $transportOptions = $package->getTransportOptions() + array('symlink' => null);
+
+        // When symlink transport option is null, both symlink and mirror are allowed
+        $currentStrategy = self::STRATEGY_SYMLINK;
+        $allowedStrategies = array(self::STRATEGY_SYMLINK, self::STRATEGY_MIRROR);
+
+        $mirrorPathRepos = getenv('COMPOSER_MIRROR_PATH_REPOS');
+        if ($mirrorPathRepos) {
+            $currentStrategy = self::STRATEGY_MIRROR;
+        }
+
+        if (true === $transportOptions['symlink']) {
+            $currentStrategy = self::STRATEGY_SYMLINK;
+            $allowedStrategies = array(self::STRATEGY_SYMLINK);
+        } elseif (false === $transportOptions['symlink']) {
+            $currentStrategy = self::STRATEGY_MIRROR;
+            $allowedStrategies = array(self::STRATEGY_MIRROR);
+        }
+
+        // Check we can use junctions safely if we are on Windows
+        if (Platform::isWindows() && self::STRATEGY_SYMLINK === $currentStrategy && !$this->safeJunctions()) {
+            $currentStrategy = self::STRATEGY_MIRROR;
+            $allowedStrategies = array(self::STRATEGY_MIRROR);
+        }
+
+        $fileSystem = new Filesystem();
+        $this->filesystem->removeDirectory($path);
+
+        if ($output) {
+            $this->io->writeError(sprintf(
+                '  - Installing <info>%s</info> (<comment>%s</comment>): ',
+                $package->getName(),
+                $package->getFullPrettyVersion()
+            ), false);
+        }
+
+        $isFallback = false;
+        if (self::STRATEGY_SYMLINK == $currentStrategy) {
+            try {
+                if (Platform::isWindows()) {
+                    // Implement symlinks as NTFS junctions on Windows
+                    $this->io->writeError(sprintf('Junctioning from %s', $url), false);
+                    $this->filesystem->junction($realUrl, $path);
+                } else {
+                    $absolutePath = $path;
+                    if (!$this->filesystem->isAbsolutePath($absolutePath)) {
+                        $absolutePath = getcwd() . DIRECTORY_SEPARATOR . $path;
+                    }
+                    $shortestPath = $this->filesystem->findShortestPath($absolutePath, $realUrl);
+                    $path = rtrim($path, "/");
+                    $this->io->writeError(sprintf('Symlinking from %s', $url), false);
+                    $fileSystem->symlink($shortestPath, $path);
+                }
+            } catch (IOException $e) {
+                if (in_array(self::STRATEGY_MIRROR, $allowedStrategies)) {
+                    $this->io->writeError('');
+                    $this->io->writeError('    <error>Symlink failed, fallback to use mirroring!</error>');
+                    $currentStrategy = self::STRATEGY_MIRROR;
+                    $isFallback = true;
+                } else {
+                    throw new \RuntimeException(sprintf('Symlink from "%s" to "%s" failed!', $realUrl, $path));
+                }
+            }
+        }
+
+        // Fallback if symlink failed or if symlink is not allowed for the package
+        if (self::STRATEGY_MIRROR == $currentStrategy) {
+            $fs = new ComposerFilesystem();
+            $realUrl = $fs->normalizePath($realUrl);
+
+            $this->io->writeError(sprintf('%sMirroring from %s', $isFallback ? '    ' : '', $url), false);
+            $iterator = new ArchivableFilesFinder($realUrl, array());
+            $fileSystem->mirror($realUrl, $path, $iterator);
+        }
+
+        $this->io->writeError('');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function remove(PackageInterface $package, $path, $output = true)
+    {
+        /**
+         * For junctions don't blindly rely on Filesystem::removeDirectory as it may be overzealous. If a process
+         * inadvertently locks the file the removal will fail, but it would fall back to recursive delete which
+         * is disastrous within a junction. So in that case we have no other real choice but to fail hard.
+         */
+        if (Platform::isWindows() && $this->filesystem->isJunction($path)) {
+            if ($output) {
+                $this->io->writeError("  - Removing junction for <info>" . $package->getName() . "</info> (<comment>" . $package->getFullPrettyVersion() . "</comment>)");
+            }
+            if (!$this->filesystem->removeJunction($path)) {
+                $this->io->writeError("    <warning>Could not remove junction at " . $path . " - is another process locking it?</warning>");
+                throw new \RuntimeException('Could not reliably remove junction for package ' . $package->getName());
+            }
+        } else {
+            parent::remove($package, $path, $output);
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getVcsReference(PackageInterface $package, $path)
+    {
+        $parser = new VersionParser;
+        $guesser = new VersionGuesser($this->config, new ProcessExecutor($this->io), $parser);
+        $dumper = new ArrayDumper;
+
+        $packageConfig = $dumper->dump($package);
+        if ($packageVersion = $guesser->guessVersion($packageConfig, $path)) {
+            return $packageVersion['commit'];
+        }
+    }
+
+    /**
+     * Returns true if junctions can be created and safely used on Windows
+     *
+     * A PHP bug makes junction detection fragile, leading to possible data loss
+     * when removing a package. See https://bugs.php.net/bug.php?id=77552
+     *
+     * For safety we require a minimum version of Windows 7, so we can call the
+     * system rmdir which will preserve target content if given a junction.
+     *
+     * The PHP bug was fixed in 7.2.16 and 7.3.3 (requires at least Windows 7).
+     *
+     * @return bool
+     */
+    private function safeJunctions()
+    {
+        // We need to call mklink, and rmdir on Windows 7 (version 6.1)
+        return function_exists('proc_open') &&
+            (PHP_WINDOWS_VERSION_MAJOR > 6 ||
+            (PHP_WINDOWS_VERSION_MAJOR === 6 && PHP_WINDOWS_VERSION_MINOR >= 1));
+    }
+}

data/helpers/vendor/composer/composer/src/Composer/Downloader/PearPackageExtractor.php

@@ -0,0 +1,266 @@
+<?php
+
+/*
+ * This file is part of Composer.
+ *
+ * (c) Nils Adermann <naderman@naderman.de>
+ *     Jordi Boggiano <j.boggiano@seld.be>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Composer\Downloader;
+
+use Composer\Util\Filesystem;
+
+/**
+ * Extractor for pear packages.
+ *
+ * Composer cannot rely on tar files structure when place it inside package target dir. Correct source files
+ * disposition must be read from package.xml
+ * This extract pear package source files to target dir.
+ *
+ * @author Alexey Prilipko <palex@farpost.com>
+ */
+class PearPackageExtractor
+{
+    private static $rolesWithoutPackageNamePrefix = array('php', 'script', 'www');
+    /** @var Filesystem */
+    private $filesystem;
+    private $file;
+
+    public function __construct($file)
+    {
+        if (!is_file($file)) {
+            throw new \UnexpectedValueException('PEAR package file is not found at '.$file);
+        }
+
+        $this->filesystem = new Filesystem();
+        $this->file = $file;
+    }
+
+    /**
+     * Installs PEAR source files according to package.xml definitions and removes extracted files
+     *
+     * @param  string                    $target target install location. all source installation would be performed relative to target path.
+     * @param  array                     $roles  types of files to install. default role for PEAR source files are 'php'.
+     * @param  array                     $vars   used for replacement tasks
+     * @throws \RuntimeException
+     * @throws \UnexpectedValueException
+     */
+    public function extractTo($target, array $roles = array('php' => '/', 'script' => '/bin'), $vars = array())
+    {
+        $extractionPath = $target.'/tarball';
+
+        try {
+            $archive = new \PharData($this->file);
+            $archive->extractTo($extractionPath, null, true);
+
+            if (!is_file($this->combine($extractionPath, '/package.xml'))) {
+                throw new \RuntimeException('Invalid PEAR package. It must contain package.xml file.');
+            }
+
+            $fileCopyActions = $this->buildCopyActions($extractionPath, $roles, $vars);
+            $this->copyFiles($fileCopyActions, $extractionPath, $target, $roles, $vars);
+            $this->filesystem->removeDirectory($extractionPath);
+        } catch (\Exception $exception) {
+            throw new \UnexpectedValueException(sprintf('Failed to extract PEAR package %s to %s. Reason: %s', $this->file, $target, $exception->getMessage()), 0, $exception);
+        }
+    }
+
+    /**
+     * Perform copy actions on files
+     *
+     * @param array $files array of copy actions ('from', 'to') with relative paths
+     * @param string $source path to source dir.
+     * @param string $target path to destination dir
+     * @param array $roles array [role => roleRoot] relative root for files having that role
+     * @param array $vars  list of values can be used for replacement tasks
+     */
+    private function copyFiles($files, $source, $target, $roles, $vars)
+    {
+        foreach ($files as $file) {
+            $from = $this->combine($source, $file['from']);
+            $to = $this->combine($target, $roles[$file['role']]);
+            $to = $this->combine($to, $file['to']);
+            $tasks = $file['tasks'];
+            $this->copyFile($from, $to, $tasks, $vars);
+        }
+    }
+
+    private function copyFile($from, $to, $tasks, $vars)
+    {
+        if (!is_file($from)) {
+            throw new \RuntimeException('Invalid PEAR package. package.xml defines file that is not located inside tarball.');
+        }
+
+        $this->filesystem->ensureDirectoryExists(dirname($to));
+
+        if (0 == count($tasks)) {
+            $copied = copy($from, $to);
+        } else {
+            $content = file_get_contents($from);
+            $replacements = array();
+            foreach ($tasks as $task) {
+                $pattern = $task['from'];
+                $varName = $task['to'];
+                if (isset($vars[$varName])) {
+                    if ($varName === 'php_bin' && false === strpos($to, '.bat')) {
+                        $replacements[$pattern] = preg_replace('{\.bat$}', '', $vars[$varName]);
+                    } else {
+                        $replacements[$pattern] = $vars[$varName];
+                    }
+                }
+            }
+            $content = strtr($content, $replacements);
+
+            $copied = file_put_contents($to, $content);
+        }
+
+        if (false === $copied) {
+            throw new \RuntimeException(sprintf('Failed to copy %s to %s', $from, $to));
+        }
+    }
+
+    /**
+     * Builds list of copy and list of remove actions that would transform extracted PEAR tarball into installed package.
+     *
+     * @param  string            $source string path to extracted files
+     * @param  array             $roles  array [role => roleRoot] relative root for files having that role
+     * @param  array             $vars   list of values can be used for replacement tasks
+     * @throws \RuntimeException
+     * @return array             array of 'source' => 'target', where source is location of file in the tarball (relative to source
+     *                                  path, and target is destination of file (also relative to $source path)
+     */
+    private function buildCopyActions($source, array $roles, $vars)
+    {
+        /** @var \SimpleXmlElement $package */
+        $package = simplexml_load_string(file_get_contents($this->combine($source, 'package.xml')));
+        if (false === $package) {
+            throw new \RuntimeException('Package definition file is not valid.');
+        }
+
+        $packageSchemaVersion = $package['version'];
+        if ('1.0' == $packageSchemaVersion) {
+            $children = $package->release->filelist->children();
+            $packageName = (string) $package->name;
+            $packageVersion = (string) $package->release->version;
+            $sourceDir = $packageName . '-' . $packageVersion;
+            $result = $this->buildSourceList10($children, $roles, $sourceDir, '', null, $packageName);
+        } elseif ('2.0' == $packageSchemaVersion || '2.1' == $packageSchemaVersion) {
+            $children = $package->contents->children();
+            $packageName = (string) $package->name;
+            $packageVersion = (string) $package->version->release;
+            $sourceDir = $packageName . '-' . $packageVersion;
+            $result = $this->buildSourceList20($children, $roles, $sourceDir, '', null, $packageName);
+
+            $namespaces = $package->getNamespaces();
+            $package->registerXPathNamespace('ns', $namespaces['']);
+            $releaseNodes = $package->xpath('ns:phprelease');
+            $this->applyRelease($result, $releaseNodes, $vars);
+        } else {
+            throw new \RuntimeException('Unsupported schema version of package definition file.');
+        }
+
+        return $result;
+    }
+
+    private function applyRelease(&$actions, $releaseNodes, $vars)
+    {
+        foreach ($releaseNodes as $releaseNode) {
+            $requiredOs = $releaseNode->installconditions && $releaseNode->installconditions->os && $releaseNode->installconditions->os->name ? (string) $releaseNode->installconditions->os->name : '';
+            if ($requiredOs && $vars['os'] != $requiredOs) {
+                continue;
+            }
+
+            if ($releaseNode->filelist) {
+                foreach ($releaseNode->filelist->children() as $action) {
+                    if ('install' == $action->getName()) {
+                        $name = (string) $action['name'];
+                        $as = (string) $action['as'];
+                        if (isset($actions[$name])) {
+                            $actions[$name]['to'] = $as;
+                        }
+                    } elseif ('ignore' == $action->getName()) {
+                        $name = (string) $action['name'];
+                        unset($actions[$name]);
+                    } else {
+                        // unknown action
+                    }
+                }
+            }
+            break;
+        }
+    }
+
+    private function buildSourceList10($children, $targetRoles, $source, $target, $role, $packageName)
+    {
+        $result = array();
+
+        // enumerating files
+        foreach ($children as $child) {
+            /** @var $child \SimpleXMLElement */
+            if ($child->getName() == 'dir') {
+                $dirSource = $this->combine($source, (string) $child['name']);
+                $dirTarget = $child['baseinstalldir'] ?: $target;
+                $dirRole = $child['role'] ?: $role;
+                $dirFiles = $this->buildSourceList10($child->children(), $targetRoles, $dirSource, $dirTarget, $dirRole, $packageName);
+                $result = array_merge($result, $dirFiles);
+            } elseif ($child->getName() == 'file') {
+                $fileRole = (string) $child['role'] ?: $role;
+                if (isset($targetRoles[$fileRole])) {
+                    $fileName = (string) ($child['name'] ?: $child[0]); // $child[0] means text content
+                    $fileSource = $this->combine($source, $fileName);
+                    $fileTarget = $this->combine((string) $child['baseinstalldir'] ?: $target, $fileName);
+                    if (!in_array($fileRole, self::$rolesWithoutPackageNamePrefix)) {
+                        $fileTarget = $packageName . '/' . $fileTarget;
+                    }
+                    $result[(string) $child['name']] = array('from' => $fileSource, 'to' => $fileTarget, 'role' => $fileRole, 'tasks' => array());
+                }
+            }
+        }
+
+        return $result;
+    }
+
+    private function buildSourceList20($children, $targetRoles, $source, $target, $role, $packageName)
+    {
+        $result = array();
+
+        // enumerating files
+        foreach ($children as $child) {
+            /** @var $child \SimpleXMLElement */
+            if ('dir' == $child->getName()) {
+                $dirSource = $this->combine($source, $child['name']);
+                $dirTarget = $child['baseinstalldir'] ?: $target;
+                $dirRole = $child['role'] ?: $role;
+                $dirFiles = $this->buildSourceList20($child->children(), $targetRoles, $dirSource, $dirTarget, $dirRole, $packageName);
+                $result = array_merge($result, $dirFiles);
+            } elseif ('file' == $child->getName()) {
+                $fileRole = (string) $child['role'] ?: $role;
+                if (isset($targetRoles[$fileRole])) {
+                    $fileSource = $this->combine($source, (string) $child['name']);
+                    $fileTarget = $this->combine((string) ($child['baseinstalldir'] ?: $target), (string) $child['name']);
+                    $fileTasks = array();
+                    foreach ($child->children('http://pear.php.net/dtd/tasks-1.0') as $taskNode) {
+                        if ('replace' == $taskNode->getName()) {
+                            $fileTasks[] = array('from' => (string) $taskNode->attributes()->from, 'to' => (string) $taskNode->attributes()->to);
+                        }
+                    }
+                    if (!in_array($fileRole, self::$rolesWithoutPackageNamePrefix)) {
+                        $fileTarget = $packageName . '/' . $fileTarget;
+                    }
+                    $result[(string) $child['name']] = array('from' => $fileSource, 'to' => $fileTarget, 'role' => $fileRole, 'tasks' => $fileTasks);
+                }
+            }
+        }
+
+        return $result;
+    }
+
+    private function combine($left, $right)
+    {
+        return rtrim($left, '/') . '/' . ltrim($right, '/');
+    }
+}