dependabot-composer 0.107.13 → 0.107.14

data/helpers/vendor/composer/composer/src/Composer/Repository/RepositoryFactory.php

@@ -0,0 +1,169 @@
+<?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\Repository;
+
+use Composer\Factory;
+use Composer\IO\IOInterface;
+use Composer\Config;
+use Composer\EventDispatcher\EventDispatcher;
+use Composer\Util\RemoteFilesystem;
+use Composer\Json\JsonFile;
+
+/**
+ * @author Jordi Boggiano <j.boggiano@seld.be>
+ */
+class RepositoryFactory
+{
+    /**
+     * @param  IOInterface $io
+     * @param  Config      $config
+     * @param  string      $repository
+     * @param  bool        $allowFilesystem
+     * @return array|mixed
+     */
+    public static function configFromString(IOInterface $io, Config $config, $repository, $allowFilesystem = false)
+    {
+        if (0 === strpos($repository, 'http')) {
+            $repoConfig = array('type' => 'composer', 'url' => $repository);
+        } elseif ("json" === pathinfo($repository, PATHINFO_EXTENSION)) {
+            $json = new JsonFile($repository, Factory::createRemoteFilesystem($io, $config));
+            $data = $json->read();
+            if (!empty($data['packages']) || !empty($data['includes']) || !empty($data['provider-includes'])) {
+                $repoConfig = array('type' => 'composer', 'url' => 'file://' . strtr(realpath($repository), '\\', '/'));
+            } elseif ($allowFilesystem) {
+                $repoConfig = array('type' => 'filesystem', 'json' => $json);
+            } else {
+                throw new \InvalidArgumentException("Invalid repository URL ($repository) given. This file does not contain a valid composer repository.");
+            }
+        } elseif ('{' === substr($repository, 0, 1)) {
+            // assume it is a json object that makes a repo config
+            $repoConfig = JsonFile::parseJson($repository);
+        } else {
+            throw new \InvalidArgumentException("Invalid repository url ($repository) given. Has to be a .json file, an http url or a JSON object.");
+        }
+
+        return $repoConfig;
+    }
+
+    /**
+     * @param  IOInterface         $io
+     * @param  Config              $config
+     * @param  string              $repository
+     * @param  bool                $allowFilesystem
+     * @return RepositoryInterface
+     */
+    public static function fromString(IOInterface $io, Config $config, $repository, $allowFilesystem = false)
+    {
+        $repoConfig = static::configFromString($io, $config, $repository, $allowFilesystem);
+
+        return static::createRepo($io, $config, $repoConfig);
+    }
+
+    /**
+     * @param  IOInterface         $io
+     * @param  Config              $config
+     * @param  array               $repoConfig
+     * @return RepositoryInterface
+     */
+    public static function createRepo(IOInterface $io, Config $config, array $repoConfig)
+    {
+        $rm = static::manager($io, $config, null, Factory::createRemoteFilesystem($io, $config));
+        $repos = static::createRepos($rm, array($repoConfig));
+
+        return reset($repos);
+    }
+
+    /**
+     * @param  IOInterface|null       $io
+     * @param  Config|null            $config
+     * @param  RepositoryManager|null $rm
+     * @return RepositoryInterface[]
+     */
+    public static function defaultRepos(IOInterface $io = null, Config $config = null, RepositoryManager $rm = null)
+    {
+        if (!$config) {
+            $config = Factory::createConfig($io);
+        }
+        if ($io) {
+            $io->loadConfiguration($config);
+        }
+        if (!$rm) {
+            if (!$io) {
+                throw new \InvalidArgumentException('This function requires either an IOInterface or a RepositoryManager');
+            }
+            $rm = static::manager($io, $config, null, Factory::createRemoteFilesystem($io, $config));
+        }
+
+        return static::createRepos($rm, $config->getRepositories());
+    }
+
+    /**
+     * @param  IOInterface       $io
+     * @param  Config            $config
+     * @param  EventDispatcher   $eventDispatcher
+     * @param  RemoteFilesystem  $rfs
+     * @return RepositoryManager
+     */
+    public static function manager(IOInterface $io, Config $config, EventDispatcher $eventDispatcher = null, RemoteFilesystem $rfs = null)
+    {
+        $rm = new RepositoryManager($io, $config, $eventDispatcher, $rfs);
+        $rm->setRepositoryClass('composer', 'Composer\Repository\ComposerRepository');
+        $rm->setRepositoryClass('vcs', 'Composer\Repository\VcsRepository');
+        $rm->setRepositoryClass('package', 'Composer\Repository\PackageRepository');
+        $rm->setRepositoryClass('pear', 'Composer\Repository\PearRepository');
+        $rm->setRepositoryClass('git', 'Composer\Repository\VcsRepository');
+        $rm->setRepositoryClass('git-bitbucket', 'Composer\Repository\VcsRepository');
+        $rm->setRepositoryClass('github', 'Composer\Repository\VcsRepository');
+        $rm->setRepositoryClass('gitlab', 'Composer\Repository\VcsRepository');
+        $rm->setRepositoryClass('svn', 'Composer\Repository\VcsRepository');
+        $rm->setRepositoryClass('fossil', 'Composer\Repository\VcsRepository');
+        $rm->setRepositoryClass('perforce', 'Composer\Repository\VcsRepository');
+        $rm->setRepositoryClass('hg', 'Composer\Repository\VcsRepository');
+        $rm->setRepositoryClass('hg-bitbucket', 'Composer\Repository\VcsRepository');
+        $rm->setRepositoryClass('artifact', 'Composer\Repository\ArtifactRepository');
+        $rm->setRepositoryClass('path', 'Composer\Repository\PathRepository');
+
+        return $rm;
+    }
+
+    /**
+     * @return RepositoryInterface[]
+     */
+    private static function createRepos(RepositoryManager $rm, array $repoConfigs)
+    {
+        $repos = array();
+
+        foreach ($repoConfigs as $index => $repo) {
+            if (is_string($repo)) {
+                throw new \UnexpectedValueException('"repositories" should be an array of repository definitions, only a single repository was given');
+            }
+            if (!is_array($repo)) {
+                throw new \UnexpectedValueException('Repository "'.$index.'" ('.json_encode($repo).') should be an array, '.gettype($repo).' given');
+            }
+            if (!isset($repo['type'])) {
+                throw new \UnexpectedValueException('Repository "'.$index.'" ('.json_encode($repo).') must have a type defined');
+            }
+            $name = is_int($index) && isset($repo['url']) ? preg_replace('{^https?://}i', '', $repo['url']) : $index;
+            while (isset($repos[$name])) {
+                $name .= '2';
+            }
+            if ($repo['type'] === 'filesystem') {
+                $repos[$name] = new FilesystemRepository($repo['json']);
+            } else {
+                $repos[$name] = $rm->createRepository($repo['type'], $repo, $index);
+            }
+        }
+
+        return $repos;
+    }
+}

data/helpers/vendor/composer/composer/src/Composer/Repository/RepositoryInterface.php

@@ -0,0 +1,74 @@
+<?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\Repository;
+
+use Composer\Package\PackageInterface;
+
+/**
+ * Repository interface.
+ *
+ * @author Nils Adermann <naderman@naderman.de>
+ * @author Konstantin Kudryashov <ever.zet@gmail.com>
+ * @author Jordi Boggiano <j.boggiano@seld.be>
+ */
+interface RepositoryInterface extends \Countable
+{
+    const SEARCH_FULLTEXT = 0;
+    const SEARCH_NAME = 1;
+
+    /**
+     * Checks if specified package registered (installed).
+     *
+     * @param PackageInterface $package package instance
+     *
+     * @return bool
+     */
+    public function hasPackage(PackageInterface $package);
+
+    /**
+     * Searches for the first match of a package by name and version.
+     *
+     * @param string                                                 $name       package name
+     * @param string|\Composer\Semver\Constraint\ConstraintInterface $constraint package version or version constraint to match against
+     *
+     * @return PackageInterface|null
+     */
+    public function findPackage($name, $constraint);
+
+    /**
+     * Searches for all packages matching a name and optionally a version.
+     *
+     * @param string                                                 $name       package name
+     * @param string|\Composer\Semver\Constraint\ConstraintInterface $constraint package version or version constraint to match against
+     *
+     * @return PackageInterface[]
+     */
+    public function findPackages($name, $constraint = null);
+
+    /**
+     * Returns list of registered packages.
+     *
+     * @return PackageInterface[]
+     */
+    public function getPackages();
+
+    /**
+     * Searches the repository for packages containing the query
+     *
+     * @param string $query search query
+     * @param int    $mode  a set of SEARCH_* constants to search on, implementations should do a best effort only
+     *
+     * @return array[] an array of array('name' => '...', 'description' => '...')
+     */
+    public function search($query, $mode = 0);
+}

data/helpers/vendor/composer/composer/src/Composer/Repository/RepositoryManager.php

@@ -0,0 +1,177 @@
+<?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\Repository;
+
+use Composer\IO\IOInterface;
+use Composer\Config;
+use Composer\EventDispatcher\EventDispatcher;
+use Composer\Package\PackageInterface;
+use Composer\Util\RemoteFilesystem;
+
+/**
+ * Repositories manager.
+ *
+ * @author Jordi Boggiano <j.boggiano@seld.be>
+ * @author Konstantin Kudryashov <ever.zet@gmail.com>
+ * @author François Pluchino <francois.pluchino@opendisplay.com>
+ */
+class RepositoryManager
+{
+    private $localRepository;
+    private $repositories = array();
+    private $repositoryClasses = array();
+    private $io;
+    private $config;
+    private $eventDispatcher;
+    private $rfs;
+
+    public function __construct(IOInterface $io, Config $config, EventDispatcher $eventDispatcher = null, RemoteFilesystem $rfs = null)
+    {
+        $this->io = $io;
+        $this->config = $config;
+        $this->eventDispatcher = $eventDispatcher;
+        $this->rfs = $rfs;
+    }
+
+    /**
+     * Searches for a package by it's name and version in managed repositories.
+     *
+     * @param string                                                 $name       package name
+     * @param string|\Composer\Semver\Constraint\ConstraintInterface $constraint package version or version constraint to match against
+     *
+     * @return PackageInterface|null
+     */
+    public function findPackage($name, $constraint)
+    {
+        foreach ($this->repositories as $repository) {
+            /** @var RepositoryInterface $repository */
+            if ($package = $repository->findPackage($name, $constraint)) {
+                return $package;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Searches for all packages matching a name and optionally a version in managed repositories.
+     *
+     * @param string                                                 $name       package name
+     * @param string|\Composer\Semver\Constraint\ConstraintInterface $constraint package version or version constraint to match against
+     *
+     * @return PackageInterface[]
+     */
+    public function findPackages($name, $constraint)
+    {
+        $packages = array();
+
+        foreach ($this->getRepositories() as $repository) {
+            $packages = array_merge($packages, $repository->findPackages($name, $constraint));
+        }
+
+        return $packages;
+    }
+
+    /**
+     * Adds repository
+     *
+     * @param RepositoryInterface $repository repository instance
+     */
+    public function addRepository(RepositoryInterface $repository)
+    {
+        $this->repositories[] = $repository;
+    }
+
+    /**
+     * Adds a repository to the beginning of the chain
+     *
+     * This is useful when injecting additional repositories that should trump Packagist, e.g. from a plugin.
+     *
+     * @param RepositoryInterface $repository repository instance
+     */
+    public function prependRepository(RepositoryInterface $repository)
+    {
+        array_unshift($this->repositories, $repository);
+    }
+
+    /**
+     * Returns a new repository for a specific installation type.
+     *
+     * @param  string                    $type   repository type
+     * @param  array                     $config repository configuration
+     * @param  string                    $name   repository name
+     * @throws \InvalidArgumentException if repository for provided type is not registered
+     * @return RepositoryInterface
+     */
+    public function createRepository($type, $config, $name = null)
+    {
+        if (!isset($this->repositoryClasses[$type])) {
+            throw new \InvalidArgumentException('Repository type is not registered: '.$type);
+        }
+
+        if (isset($config['packagist']) && false === $config['packagist']) {
+            $this->io->writeError('<warning>Repository "'.$name.'" ('.json_encode($config).') has a packagist key which should be in its own repository definition</warning>');
+        }
+
+        $class = $this->repositoryClasses[$type];
+
+        $reflMethod = new \ReflectionMethod($class, '__construct');
+        $params = $reflMethod->getParameters();
+        if (isset($params[4]) && $params[4]->getClass() && $params[4]->getClass()->getName() === 'Composer\Util\RemoteFilesystem') {
+            return new $class($config, $this->io, $this->config, $this->eventDispatcher, $this->rfs);
+        }
+
+        return new $class($config, $this->io, $this->config, $this->eventDispatcher);
+    }
+
+    /**
+     * Stores repository class for a specific installation type.
+     *
+     * @param string $type  installation type
+     * @param string $class class name of the repo implementation
+     */
+    public function setRepositoryClass($type, $class)
+    {
+        $this->repositoryClasses[$type] = $class;
+    }
+
+    /**
+     * Returns all repositories, except local one.
+     *
+     * @return RepositoryInterface[]
+     */
+    public function getRepositories()
+    {
+        return $this->repositories;
+    }
+
+    /**
+     * Sets local repository for the project.
+     *
+     * @param WritableRepositoryInterface $repository repository instance
+     */
+    public function setLocalRepository(WritableRepositoryInterface $repository)
+    {
+        $this->localRepository = $repository;
+    }
+
+    /**
+     * Returns local repository for the project.
+     *
+     * @return WritableRepositoryInterface
+     */
+    public function getLocalRepository()
+    {
+        return $this->localRepository;
+    }
+}

data/helpers/vendor/composer/composer/src/Composer/Repository/RepositorySecurityException.php

@@ -0,0 +1,22 @@
+<?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\Repository;
+
+/**
+ * Thrown when a security problem, like a broken or missing signature
+ *
+ * @author Eric Daspet <edaspet@survol.fr>
+ */
+class RepositorySecurityException extends \Exception
+{
+}

data/helpers/vendor/composer/composer/src/Composer/Repository/Vcs/BitbucketDriver.php

@@ -0,0 +1,445 @@
+<?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\Repository\Vcs;
+
+use Composer\Cache;
+use Composer\Downloader\TransportException;
+use Composer\Json\JsonFile;
+use Composer\Util\Bitbucket;
+
+abstract class BitbucketDriver extends VcsDriver
+{
+    /** @var Cache */
+    protected $cache;
+    protected $owner;
+    protected $repository;
+    protected $hasIssues;
+    protected $rootIdentifier;
+    protected $tags;
+    protected $branches;
+    protected $infoCache = array();
+    protected $branchesUrl = '';
+    protected $tagsUrl = '';
+    protected $homeUrl = '';
+    protected $website = '';
+    protected $cloneHttpsUrl = '';
+
+    /**
+     * @var VcsDriver
+     */
+    protected $fallbackDriver;
+    /** @var string|null if set either git or hg */
+    protected $vcsType;
+
+    /**
+     * {@inheritDoc}
+     */
+    public function initialize()
+    {
+        preg_match('#^https?://bitbucket\.org/([^/]+)/([^/]+?)(\.git|/?)$#', $this->url, $match);
+        $this->owner = $match[1];
+        $this->repository = $match[2];
+        $this->originUrl = 'bitbucket.org';
+        $this->cache = new Cache(
+            $this->io,
+            implode('/', array(
+                $this->config->get('cache-repo-dir'),
+                $this->originUrl,
+                $this->owner,
+                $this->repository,
+            ))
+        );
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getUrl()
+    {
+        if ($this->fallbackDriver) {
+            return $this->fallbackDriver->getUrl();
+        }
+
+        return $this->cloneHttpsUrl;
+    }
+
+    /**
+     * Attempts to fetch the repository data via the BitBucket API and
+     * sets some parameters which are used in other methods
+     *
+     * @return bool
+     */
+    protected function getRepoData()
+    {
+        $resource = sprintf(
+            'https://api.bitbucket.org/2.0/repositories/%s/%s?%s',
+            $this->owner,
+            $this->repository,
+            http_build_query(
+                array('fields' => '-project,-owner'),
+                null,
+                '&'
+            )
+        );
+
+        $repoData = JsonFile::parseJson($this->getContentsWithOAuthCredentials($resource, true), $resource);
+        if ($this->fallbackDriver) {
+            return false;
+        }
+        $this->parseCloneUrls($repoData['links']['clone']);
+
+        $this->hasIssues = !empty($repoData['has_issues']);
+        $this->branchesUrl = $repoData['links']['branches']['href'];
+        $this->tagsUrl = $repoData['links']['tags']['href'];
+        $this->homeUrl = $repoData['links']['html']['href'];
+        $this->website = $repoData['website'];
+        $this->vcsType = $repoData['scm'];
+
+        return true;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getComposerInformation($identifier)
+    {
+        if ($this->fallbackDriver) {
+            return $this->fallbackDriver->getComposerInformation($identifier);
+        }
+
+        if (!isset($this->infoCache[$identifier])) {
+            if ($this->shouldCache($identifier) && $res = $this->cache->read($identifier)) {
+                return $this->infoCache[$identifier] = JsonFile::parseJson($res);
+            }
+
+            $composer = $this->getBaseComposerInformation($identifier);
+
+            if ($composer) {
+                // specials for bitbucket
+                if (!isset($composer['support']['source'])) {
+                    $label = array_search(
+                        $identifier,
+                        $this->getTags()
+                    ) ?: array_search(
+                        $identifier,
+                        $this->getBranches()
+                    ) ?: $identifier;
+
+                    if (array_key_exists($label, $tags = $this->getTags())) {
+                        $hash = $tags[$label];
+                    } elseif (array_key_exists($label, $branches = $this->getBranches())) {
+                        $hash = $branches[$label];
+                    }
+
+                    if (! isset($hash)) {
+                        $composer['support']['source'] = sprintf(
+                            'https://%s/%s/%s/src',
+                            $this->originUrl,
+                            $this->owner,
+                            $this->repository
+                        );
+                    } else {
+                        $composer['support']['source'] = sprintf(
+                            'https://%s/%s/%s/src/%s/?at=%s',
+                            $this->originUrl,
+                            $this->owner,
+                            $this->repository,
+                            $hash,
+                            $label
+                        );
+                    }
+                }
+                if (!isset($composer['support']['issues']) && $this->hasIssues) {
+                    $composer['support']['issues'] = sprintf(
+                        'https://%s/%s/%s/issues',
+                        $this->originUrl,
+                        $this->owner,
+                        $this->repository
+                    );
+                }
+                if (!isset($composer['homepage'])) {
+                    $composer['homepage'] = empty($this->website) ? $this->homeUrl : $this->website;
+                }
+            }
+
+            $this->infoCache[$identifier] = $composer;
+
+            if ($this->shouldCache($identifier)) {
+                $this->cache->write($identifier, json_encode($composer));
+            }
+        }
+
+        return $this->infoCache[$identifier];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getFileContent($file, $identifier)
+    {
+        if ($this->fallbackDriver) {
+            return $this->fallbackDriver->getFileContent($file, $identifier);
+        }
+
+        if (strpos($identifier, '/') !== false) {
+            $branches = $this->getBranches();
+            if (isset($branches[$identifier])) {
+                $identifier = $branches[$identifier];
+            }
+        }
+
+        $resource = sprintf(
+            'https://api.bitbucket.org/2.0/repositories/%s/%s/src/%s/%s',
+            $this->owner,
+            $this->repository,
+            $identifier,
+            $file
+        );
+
+        return $this->getContentsWithOAuthCredentials($resource);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getChangeDate($identifier)
+    {
+        if ($this->fallbackDriver) {
+            return $this->fallbackDriver->getChangeDate($identifier);
+        }
+
+        $resource = sprintf(
+            'https://api.bitbucket.org/2.0/repositories/%s/%s/commit/%s?fields=date',
+            $this->owner,
+            $this->repository,
+            $identifier
+        );
+        $commit = JsonFile::parseJson($this->getContentsWithOAuthCredentials($resource), $resource);
+
+        return new \DateTime($commit['date']);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getSource($identifier)
+    {
+        if ($this->fallbackDriver) {
+            return $this->fallbackDriver->getSource($identifier);
+        }
+
+        return array('type' => $this->vcsType, 'url' => $this->getUrl(), 'reference' => $identifier);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getDist($identifier)
+    {
+        if ($this->fallbackDriver) {
+            return $this->fallbackDriver->getDist($identifier);
+        }
+
+        $url = sprintf(
+            'https://bitbucket.org/%s/%s/get/%s.zip',
+            $this->owner,
+            $this->repository,
+            $identifier
+        );
+
+        return array('type' => 'zip', 'url' => $url, 'reference' => $identifier, 'shasum' => '');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getTags()
+    {
+        if ($this->fallbackDriver) {
+            return $this->fallbackDriver->getTags();
+        }
+
+        if (null === $this->tags) {
+            $this->tags = array();
+            $resource = sprintf(
+                '%s?%s',
+                $this->tagsUrl,
+                http_build_query(
+                    array(
+                        'pagelen' => 100,
+                        'fields' => 'values.name,values.target.hash,next',
+                        'sort' => '-target.date',
+                    ),
+                    null,
+                    '&'
+                )
+            );
+            $hasNext = true;
+            while ($hasNext) {
+                $tagsData = JsonFile::parseJson($this->getContentsWithOAuthCredentials($resource), $resource);
+                foreach ($tagsData['values'] as $data) {
+                    $this->tags[$data['name']] = $data['target']['hash'];
+                }
+                if (empty($tagsData['next'])) {
+                    $hasNext = false;
+                } else {
+                    $resource = $tagsData['next'];
+                }
+            }
+            if ($this->vcsType === 'hg') {
+                unset($this->tags['tip']);
+            }
+        }
+
+        return $this->tags;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getBranches()
+    {
+        if ($this->fallbackDriver) {
+            return $this->fallbackDriver->getBranches();
+        }
+
+        if (null === $this->branches) {
+            $this->branches = array();
+            $resource = sprintf(
+                '%s?%s',
+                $this->branchesUrl,
+                http_build_query(
+                    array(
+                        'pagelen' => 100,
+                        'fields' => 'values.name,values.target.hash,values.heads,next',
+                        'sort' => '-target.date',
+                    ),
+                    null,
+                    '&'
+                )
+            );
+            $hasNext = true;
+            while ($hasNext) {
+                $branchData = JsonFile::parseJson($this->getContentsWithOAuthCredentials($resource), $resource);
+                foreach ($branchData['values'] as $data) {
+                    // skip headless branches which seem to be deleted branches that bitbucket nevertheless returns in the API
+                    if ($this->vcsType === 'hg' && empty($data['heads'])) {
+                        continue;
+                    }
+
+                    $this->branches[$data['name']] = $data['target']['hash'];
+                }
+                if (empty($branchData['next'])) {
+                    $hasNext = false;
+                } else {
+                    $resource = $branchData['next'];
+                }
+            }
+        }
+
+        return $this->branches;
+    }
+
+    /**
+     * Get the remote content.
+     *
+     * @param string $url              The URL of content
+     * @param bool   $fetchingRepoData
+     *
+     * @return mixed The result
+     */
+    protected function getContentsWithOAuthCredentials($url, $fetchingRepoData = false)
+    {
+        try {
+            return parent::getContents($url);
+        } catch (TransportException $e) {
+            $bitbucketUtil = new Bitbucket($this->io, $this->config, $this->process, $this->remoteFilesystem);
+
+            if (403 === $e->getCode() || (401 === $e->getCode() && strpos($e->getMessage(), 'Could not authenticate against') === 0)) {
+                if (!$this->io->hasAuthentication($this->originUrl)
+                    && $bitbucketUtil->authorizeOAuth($this->originUrl)
+                ) {
+                    return parent::getContents($url);
+                }
+
+                if (!$this->io->isInteractive() && $fetchingRepoData) {
+                    return $this->attemptCloneFallback();
+                }
+            }
+
+            throw $e;
+        }
+    }
+
+    /**
+     * Generate an SSH URL
+     *
+     * @return string
+     */
+    abstract protected function generateSshUrl();
+
+    protected function attemptCloneFallback()
+    {
+        try {
+            $this->setupFallbackDriver($this->generateSshUrl());
+        } catch (\RuntimeException $e) {
+            $this->fallbackDriver = null;
+
+            $this->io->writeError(
+                '<error>Failed to clone the ' . $this->generateSshUrl() . ' repository, try running in interactive mode'
+                    . ' so that you can enter your Bitbucket OAuth consumer credentials</error>'
+            );
+            throw $e;
+        }
+    }
+
+    /**
+     * @param  string $url
+     * @return void
+     */
+    abstract protected function setupFallbackDriver($url);
+
+    /**
+     * @param  array $cloneLinks
+     * @return void
+     */
+    protected function parseCloneUrls(array $cloneLinks)
+    {
+        foreach ($cloneLinks as $cloneLink) {
+            if ($cloneLink['name'] === 'https') {
+                // Format: https://(user@)bitbucket.org/{user}/{repo}
+                // Strip username from URL (only present in clone URL's for private repositories)
+                $this->cloneHttpsUrl = preg_replace('/https:\/\/([^@]+@)?/', 'https://', $cloneLink['href']);
+            }
+        }
+    }
+
+    /**
+     * @return array|null
+     */
+    protected function getMainBranchData()
+    {
+        $resource = sprintf(
+            'https://api.bitbucket.org/2.0/repositories/%s/%s?fields=mainbranch',
+            $this->owner,
+            $this->repository
+        );
+
+        $data = JsonFile::parseJson($this->getContentsWithOAuthCredentials($resource), $resource);
+        if (isset($data['mainbranch'])) {
+            return $data['mainbranch'];
+        }
+
+        return null;
+    }
+}