322 lines
10 KiB
PHP
322 lines
10 KiB
PHP
<?php
|
|
|
|
/*
|
|
* This file is part of the Fxp Composer Asset Plugin package.
|
|
*
|
|
* (c) François Pluchino <francois.pluchino@gmail.com>
|
|
*
|
|
* For the full copyright and license information, please view the LICENSE
|
|
* file that was distributed with this source code.
|
|
*/
|
|
|
|
namespace Fxp\Composer\AssetPlugin\Converter;
|
|
|
|
use Composer\Config;
|
|
use Composer\IO\NullIO;
|
|
use Composer\Repository\Vcs\VcsDriverInterface;
|
|
use Fxp\Composer\AssetPlugin\Assets;
|
|
use Fxp\Composer\AssetPlugin\Exception\InvalidArgumentException;
|
|
use Fxp\Composer\AssetPlugin\Type\AssetTypeInterface;
|
|
use Fxp\Composer\AssetPlugin\Util\Validator;
|
|
|
|
/**
|
|
* Utils for package converter.
|
|
*
|
|
* @author François Pluchino <francois.pluchino@gmail.com>
|
|
*/
|
|
abstract class PackageUtil
|
|
{
|
|
/**
|
|
* @var string[]
|
|
*/
|
|
private static $extensions = array(
|
|
'.zip',
|
|
'.tar',
|
|
'.tar.gz',
|
|
'.tar.bz2',
|
|
'.tar.Z',
|
|
'.tar.xz',
|
|
'.bz2',
|
|
'.gz',
|
|
);
|
|
|
|
/**
|
|
* Checks if the version is a URL version.
|
|
*
|
|
* @param AssetTypeInterface $assetType The asset type
|
|
* @param string $dependency The dependency
|
|
* @param string $version The version
|
|
* @param array $vcsRepos The list of new vcs configs
|
|
* @param array $composer The partial composer data
|
|
*
|
|
* @return string[] The new dependency and the new version
|
|
*/
|
|
public static function checkUrlVersion(AssetTypeInterface $assetType, $dependency, $version, array &$vcsRepos, array $composer)
|
|
{
|
|
if (preg_match('/(\:\/\/)|\@/', $version)) {
|
|
list($url, $version) = static::splitUrlVersion($version);
|
|
|
|
if (!static::isUrlArchive($url) && static::hasUrlDependencySupported($url)) {
|
|
$vcsRepos[] = array(
|
|
'type' => sprintf('%s-vcs', $assetType->getName()),
|
|
'url' => $url,
|
|
'name' => $assetType->formatComposerName($dependency),
|
|
);
|
|
} else {
|
|
$dependency = static::getUrlFileDependencyName($assetType, $composer, $dependency);
|
|
$vcsRepos[] = array(
|
|
'type' => 'package',
|
|
'package' => array(
|
|
'name' => $assetType->formatComposerName($dependency),
|
|
'type' => $assetType->getComposerType(),
|
|
'version' => static::getUrlFileDependencyVersion($assetType, $url, $version),
|
|
'dist' => array(
|
|
'url' => $url,
|
|
'type' => 'file',
|
|
),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
return array($dependency, $version);
|
|
}
|
|
|
|
/**
|
|
* Check if the url is a url of a archive file.
|
|
*
|
|
* @param string $url The url
|
|
*
|
|
* @return bool
|
|
*/
|
|
public static function isUrlArchive($url)
|
|
{
|
|
if (0 === strpos($url, 'http')) {
|
|
foreach (self::$extensions as $extension) {
|
|
if (substr($url, -strlen($extension)) === $extension) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Checks if the version is a alias version.
|
|
*
|
|
* @param AssetTypeInterface $assetType The asset type
|
|
* @param string $dependency The dependency
|
|
* @param string $version The version
|
|
*
|
|
* @return string[] The new dependency and the new version
|
|
*/
|
|
public static function checkAliasVersion(AssetTypeInterface $assetType, $dependency, $version)
|
|
{
|
|
$pos = strpos($version, '#');
|
|
|
|
if ($pos > 0 && !preg_match('{[0-9a-f]{40}$}', $version)) {
|
|
$dependency = substr($version, 0, $pos);
|
|
$version = substr($version, $pos);
|
|
$searchVerion = substr($version, 1);
|
|
|
|
if (false === strpos($version, '*') && Validator::validateTag($searchVerion, $assetType)) {
|
|
$dependency .= '-'.str_replace('#', '', $version);
|
|
}
|
|
}
|
|
|
|
return array($dependency, $version);
|
|
}
|
|
|
|
/**
|
|
* Convert the dependency version.
|
|
*
|
|
* @param AssetTypeInterface $assetType The asset type
|
|
* @param string $dependency The dependency
|
|
* @param string $version The version
|
|
*
|
|
* @return string[] The new dependency and the new version
|
|
*/
|
|
public static function convertDependencyVersion(AssetTypeInterface $assetType, $dependency, $version)
|
|
{
|
|
$containsHash = false !== strpos($version, '#');
|
|
$version = str_replace('#', '', $version);
|
|
$version = empty($version) ? '*' : trim($version);
|
|
$searchVersion = str_replace(array(' ', '<', '>', '=', '^', '~'), '', $version);
|
|
|
|
// sha version or branch version
|
|
// sha size: 4-40. See https://git-scm.com/book/tr/v2/Git-Tools-Revision-Selection#_short_sha_1
|
|
if ($containsHash && preg_match('{^[0-9a-f]{4,40}$}', $version)) {
|
|
$version = 'dev-default#'.$version;
|
|
} elseif ('*' !== $version && !Validator::validateTag($searchVersion, $assetType) && !static::depIsRange($version)) {
|
|
$version = static::convertBrachVersion($assetType, $version);
|
|
}
|
|
|
|
return array($dependency, $version);
|
|
}
|
|
|
|
/**
|
|
* Converts the simple key of package.
|
|
*
|
|
* @param array $asset The asset data
|
|
* @param string $assetKey The asset key
|
|
* @param array $composer The composer data
|
|
* @param string $composerKey The composer key
|
|
*/
|
|
public static function convertStringKey(array $asset, $assetKey, array &$composer, $composerKey)
|
|
{
|
|
if (isset($asset[$assetKey])) {
|
|
$composer[$composerKey] = $asset[$assetKey];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Converts the simple key of package.
|
|
*
|
|
* @param array $asset The asset data
|
|
* @param string $assetKey The asset key
|
|
* @param array $composer The composer data
|
|
* @param array $composerKey The array with composer key name and closure
|
|
*
|
|
* @throws InvalidArgumentException When the 'composerKey' argument of asset packager converter is not an string or an array with the composer key and closure
|
|
*/
|
|
public static function convertArrayKey(array $asset, $assetKey, array &$composer, $composerKey)
|
|
{
|
|
if (2 !== count($composerKey)
|
|
|| !is_string($composerKey[0]) || !$composerKey[1] instanceof \Closure) {
|
|
throw new InvalidArgumentException('The "composerKey" argument of asset packager converter must be an string or an array with the composer key and closure');
|
|
}
|
|
|
|
$closure = $composerKey[1];
|
|
$composerKey = $composerKey[0];
|
|
$data = isset($asset[$assetKey]) ? $asset[$assetKey] : null;
|
|
$previousData = isset($composer[$composerKey]) ? $composer[$composerKey] : null;
|
|
$data = $closure($data, $previousData);
|
|
|
|
if (null !== $data) {
|
|
$composer[$composerKey] = $data;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Split the URL and version.
|
|
*
|
|
* @param string $version The url and version (in the same string)
|
|
*
|
|
* @return string[] The url and version
|
|
*/
|
|
protected static function splitUrlVersion($version)
|
|
{
|
|
$pos = strpos($version, '#');
|
|
|
|
// number version or empty version
|
|
if (false !== $pos) {
|
|
$url = substr($version, 0, $pos);
|
|
$version = substr($version, $pos);
|
|
} else {
|
|
$url = $version;
|
|
$version = '#';
|
|
}
|
|
|
|
return array($url, $version);
|
|
}
|
|
|
|
/**
|
|
* Get the name of url file dependency.
|
|
*
|
|
* @param AssetTypeInterface $assetType The asset type
|
|
* @param array $composer The partial composer
|
|
* @param string $dependency The dependency name
|
|
*
|
|
* @return string The dependency name
|
|
*/
|
|
protected static function getUrlFileDependencyName(AssetTypeInterface $assetType, array $composer, $dependency)
|
|
{
|
|
$prefix = isset($composer['name'])
|
|
? substr($composer['name'], strlen($assetType->getComposerVendorName()) + 1).'-'
|
|
: '';
|
|
|
|
return $prefix.$dependency.'-file';
|
|
}
|
|
|
|
/**
|
|
* Get the version of url file dependency.
|
|
*
|
|
* @param AssetTypeInterface $assetType The asset type
|
|
* @param string $url The url
|
|
* @param string $version The version
|
|
*
|
|
* @return string The version
|
|
*/
|
|
protected static function getUrlFileDependencyVersion(AssetTypeInterface $assetType, $url, $version)
|
|
{
|
|
if ('#' !== $version) {
|
|
return substr($version, 1);
|
|
}
|
|
|
|
if (preg_match('/(\d+)(\.\d+)(\.\d+)?(\.\d+)?/', $url, $match)) {
|
|
return $assetType->getVersionConverter()->convertVersion($match[0]);
|
|
}
|
|
|
|
return '0.0.0.0';
|
|
}
|
|
|
|
/**
|
|
* Check if url is supported by vcs drivers.
|
|
*
|
|
* @param string $url The url
|
|
*
|
|
* @return bool
|
|
*/
|
|
protected static function hasUrlDependencySupported($url)
|
|
{
|
|
$io = new NullIO();
|
|
$config = new Config();
|
|
|
|
/* @var VcsDriverInterface $driver */
|
|
foreach (Assets::getVcsDrivers() as $driver) {
|
|
$supported = $driver::supports($io, $config, $url);
|
|
|
|
if ($supported) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Check if the version of dependency is a range version.
|
|
*
|
|
* @param string $version
|
|
*
|
|
* @return bool
|
|
*/
|
|
protected static function depIsRange($version)
|
|
{
|
|
$version = trim($version);
|
|
|
|
return (bool) preg_match('/[\<\>\=\^\~\ ]/', $version);
|
|
}
|
|
|
|
/**
|
|
* Convert the dependency branch version.
|
|
*
|
|
* @param AssetTypeInterface $assetType The asset type
|
|
* @param string $version The version
|
|
*
|
|
* @return string
|
|
*/
|
|
protected static function convertBrachVersion(AssetTypeInterface $assetType, $version)
|
|
{
|
|
$oldVersion = $version;
|
|
$version = 'dev-'.$assetType->getVersionConverter()->convertVersion($version);
|
|
|
|
if (!Validator::validateBranch($oldVersion)) {
|
|
$version .= ' || '.$oldVersion;
|
|
}
|
|
|
|
return $version;
|
|
}
|
|
}
|