mirror of
https://github.com/shivammathur/setup-php.git
synced 2024-10-18 20:20:14 +07:00
512 lines
14 KiB
TypeScript
512 lines
14 KiB
TypeScript
import * as utils from './utils';
|
|
import path from 'path';
|
|
import fs from 'fs';
|
|
|
|
type RS = Record<string, string>;
|
|
type RSRS = Record<string, RS>;
|
|
|
|
interface IRef {
|
|
ref: string;
|
|
node_id: string;
|
|
url: string;
|
|
object: RS;
|
|
}
|
|
|
|
/**
|
|
* Function to get version in semver format.
|
|
*
|
|
* @param data
|
|
*/
|
|
export async function getSemverVersion(data: RS): Promise<string> {
|
|
const search: string = data['version_prefix'] + data['version'];
|
|
const url = `https://api.github.com/repos/${data['repository']}/git/matching-refs/tags%2F${search}.`;
|
|
const token: string = await utils.readEnv('COMPOSER_TOKEN');
|
|
const response: RS = await utils.fetch(url, token);
|
|
if (response.error || response.data === '[]') {
|
|
data['error'] = response.error ?? `No version found with prefix ${search}.`;
|
|
return data['version'];
|
|
} else {
|
|
const refs = JSON.parse(response['data']).reverse();
|
|
const ref = refs.find((i: IRef) => /.*\d+.\d+.\d+$/.test(i['ref']));
|
|
const tag: string = (ref || refs[0])['ref'].split('/').pop();
|
|
return tag.replace(/^v(\d)/, '$1');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Function to get latest version from releases.atom
|
|
*
|
|
* @param data
|
|
*/
|
|
export async function getLatestVersion(data: RS): Promise<string> {
|
|
if (!data['version'] && data['fetch_latest'] === 'false') {
|
|
return 'latest';
|
|
}
|
|
const resp: Record<string, string> = await utils.fetch(
|
|
`${data['github']}/${data['repository']}/releases.atom`
|
|
);
|
|
if (resp['data']) {
|
|
const releases: string[] = [
|
|
...resp['data'].matchAll(/releases\/tag\/([a-zA-Z]*)?(\d+.\d+.\d+)"/g)
|
|
].map(match => match[2]);
|
|
|
|
return (
|
|
releases
|
|
.sort((a: string, b: string) =>
|
|
a.localeCompare(b, undefined, {numeric: true})
|
|
)
|
|
.pop() || 'latest'
|
|
);
|
|
}
|
|
return 'latest';
|
|
}
|
|
|
|
/**
|
|
* Function to get tool version
|
|
*
|
|
* @param version
|
|
* @param data
|
|
*/
|
|
export async function getVersion(version: string, data: RS): Promise<string> {
|
|
// semver_regex - https://semver.org/
|
|
const semver_regex =
|
|
/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
|
|
const composer_regex = /^composer:(stable|preview|snapshot|[1|2])$/;
|
|
const constraint_regex = /[><=^~]+.*/;
|
|
const major_minor_regex = /^\d+(\.\d+)?$/;
|
|
data['version'] = version.replace(/v?(\d)/, '$1').replace(/\.x/, '');
|
|
switch (true) {
|
|
case composer_regex.test(data['release']):
|
|
case semver_regex.test(data['version']):
|
|
case constraint_regex.test(data['version']) && data['type'] === 'composer':
|
|
return data['version'];
|
|
case major_minor_regex.test(data['version']) && data['type'] === 'composer':
|
|
data['release'] = `${data['tool']}:${data['version']}.*`;
|
|
return `${data['version']}.*`;
|
|
case data['repository'] && major_minor_regex.test(data['version']):
|
|
return await getSemverVersion(data);
|
|
default:
|
|
return data['version'].replace(/[><=^~]*/, '');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Function to parse the release tool:version
|
|
*
|
|
* @param release
|
|
* @param data
|
|
*/
|
|
export async function getRelease(release: string, data: RS): Promise<string> {
|
|
release = release.includes('/') ? release.split('/')[1] : release;
|
|
return release.includes(':')
|
|
? [data['tool'], release.split(':')[1]].join(':')
|
|
: data['tool'];
|
|
}
|
|
|
|
/**
|
|
* Function to add/move composer in the tools list
|
|
*
|
|
* @param tools_list
|
|
*/
|
|
export async function filterList(tools_list: string[]): Promise<string[]> {
|
|
const regex_any = /^composer($|:.*)/;
|
|
const regex_valid =
|
|
/^composer:?($|preview$|snapshot$|v?\d+(\.\d+)?$|v?\d+\.\d+\.\d+[\w-]*$)/;
|
|
const matches: string[] = tools_list.filter(tool => regex_valid.test(tool));
|
|
let composer = 'composer';
|
|
tools_list = tools_list.filter(tool => !regex_any.test(tool));
|
|
switch (true) {
|
|
case matches[0] == undefined:
|
|
break;
|
|
default:
|
|
composer = matches[matches.length - 1].replace(/v(\d\S*)/, '$1');
|
|
break;
|
|
}
|
|
tools_list.unshift(composer);
|
|
return tools_list;
|
|
}
|
|
|
|
/**
|
|
* Function to get the url of tool with the given version
|
|
*
|
|
* @param data
|
|
*/
|
|
export async function getUrl(data: RS): Promise<string> {
|
|
if (data['version'] === 'latest') {
|
|
return [
|
|
data['domain'],
|
|
data['repository'],
|
|
data['prefix'],
|
|
data['version'],
|
|
data['verb'],
|
|
data['tool'] + data['extension']
|
|
]
|
|
.filter(Boolean)
|
|
.join('/');
|
|
} else {
|
|
return [
|
|
data['domain'],
|
|
data['repository'],
|
|
data['prefix'],
|
|
data['verb'],
|
|
data['version_prefix'] + data['version'],
|
|
data['tool'] + data['extension']
|
|
]
|
|
.filter(Boolean)
|
|
.join('/');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Function to get the phar url in domain/tool-version.phar format
|
|
*
|
|
* @param data
|
|
*/
|
|
export async function getPharUrl(data: RS): Promise<string> {
|
|
if (data['version'] === 'latest') {
|
|
return data['domain'] + '/' + data['tool'] + '.phar';
|
|
} else {
|
|
return (
|
|
data['domain'] +
|
|
'/' +
|
|
data['tool'] +
|
|
'-' +
|
|
data['version_prefix'] +
|
|
data['version'] +
|
|
'.phar'
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Helper function to get script to setup a tool using a phar url
|
|
*
|
|
* @param data
|
|
*/
|
|
export async function addArchive(data: RS): Promise<string> {
|
|
return (
|
|
(await utils.getCommand(data['os'], 'tool')) +
|
|
(await utils.joins(data['url'], data['tool'], data['version_parameter']))
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Helper function to get script to setup a tool using composer
|
|
*
|
|
* @param data
|
|
*/
|
|
export async function addPackage(data: RS): Promise<string> {
|
|
const command = await utils.getCommand(data['os'], 'composertool');
|
|
const parts: string[] = data['repository'].split('/');
|
|
const args: string = await utils.joins(
|
|
parts[1],
|
|
data['release'],
|
|
parts[0] + '/',
|
|
data['scope']
|
|
);
|
|
return command + args;
|
|
}
|
|
|
|
/**
|
|
* Function to add blackfire-player
|
|
*
|
|
* @param data
|
|
*/
|
|
export async function addBlackfirePlayer(data: RS): Promise<string> {
|
|
if (
|
|
/5\.[5-6]|7\.0/.test(data['php_version']) &&
|
|
data['version'] == 'latest'
|
|
) {
|
|
data['version'] = '1.9.3';
|
|
}
|
|
data['url'] = await getPharUrl(data);
|
|
return addArchive(data);
|
|
}
|
|
|
|
/**
|
|
* Function to add composer
|
|
*
|
|
* @param data
|
|
*/
|
|
export async function addComposer(data: RS): Promise<string> {
|
|
const github = data['github'];
|
|
const getcomposer = data['domain'];
|
|
let cache_url = `${github}/shivammathur/composer-cache/releases/latest/download/composer-${
|
|
data['php_version']
|
|
}-${data['version'].replace('latest', 'stable')}.phar`;
|
|
let source_url = `${getcomposer}/composer.phar`;
|
|
switch (true) {
|
|
case /^snapshot$/.test(data['version']):
|
|
break;
|
|
case /^preview$|^[1-2]$/.test(data['version']):
|
|
source_url = `${getcomposer}/composer-${data['version']}.phar`;
|
|
break;
|
|
case /^\d+\.\d+\.\d+[\w-]*$/.test(data['version']):
|
|
cache_url = `${github}/${data['repository']}/releases/download/${data['version']}/composer.phar`;
|
|
source_url = `${getcomposer}/composer-${data['version']}.phar`;
|
|
break;
|
|
default:
|
|
source_url = `${getcomposer}/composer-stable.phar`;
|
|
}
|
|
const use_cache: boolean = (await utils.readEnv('NO_TOOLS_CACHE')) !== 'true';
|
|
data['url'] = use_cache ? `${cache_url},${source_url}` : source_url;
|
|
data['version_parameter'] = data['version'];
|
|
return await addArchive(data);
|
|
}
|
|
|
|
/**
|
|
* Function to add Deployer
|
|
*
|
|
* @param data
|
|
*/
|
|
export async function addDeployer(data: RS): Promise<string> {
|
|
if (data['version'] === 'latest') {
|
|
data['url'] = data['domain'] + '/deployer.phar';
|
|
} else {
|
|
data['url'] =
|
|
data['domain'] + '/releases/v' + data['version'] + '/deployer.phar';
|
|
}
|
|
return await addArchive(data);
|
|
}
|
|
|
|
/**
|
|
* Function to add php-config and phpize
|
|
*
|
|
* @param data
|
|
*/
|
|
export async function addDevTools(data: RS): Promise<string> {
|
|
switch (data['os']) {
|
|
case 'linux':
|
|
case 'darwin':
|
|
return 'add_devtools ' + data['tool'];
|
|
case 'win32':
|
|
return await utils.addLog(
|
|
'$tick',
|
|
data['tool'],
|
|
data['tool'] + ' is not a windows tool',
|
|
'win32'
|
|
);
|
|
default:
|
|
return await utils.log(
|
|
'Platform ' + data['os'] + ' is not supported',
|
|
data['os'],
|
|
'error'
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Function to add PECL
|
|
*
|
|
* @param data
|
|
*/
|
|
export async function addPECL(data: RS): Promise<string> {
|
|
return await utils.getCommand(data['os'], 'pecl');
|
|
}
|
|
|
|
/**
|
|
* Function to add Phing
|
|
*
|
|
* @param data
|
|
*/
|
|
export async function addPhing(data: RS): Promise<string> {
|
|
data['url'] =
|
|
data['domain'] + '/get/phing-' + data['version'] + data['extension'];
|
|
return await addArchive(data);
|
|
}
|
|
|
|
/**
|
|
* Helper function to add Phive
|
|
*
|
|
* @param data
|
|
*/
|
|
export async function addPhive(data: RS): Promise<string> {
|
|
switch (true) {
|
|
case /5\.[3-5]/.test(data['php_version']):
|
|
return await utils.addLog(
|
|
'$cross',
|
|
'phive',
|
|
'Phive is not supported on PHP ' + data['php_version'],
|
|
data['os']
|
|
);
|
|
case /5\.6|7\.0/.test(data['php_version']):
|
|
data['version'] = '0.12.1';
|
|
break;
|
|
case /7\.1/.test(data['php_version']):
|
|
data['version'] = '0.13.5';
|
|
break;
|
|
case /7\.2/.test(data['php_version']):
|
|
data['version'] = '0.14.5';
|
|
break;
|
|
case /^latest$/.test(data['version']):
|
|
data['version'] = await getLatestVersion(data);
|
|
break;
|
|
}
|
|
data['extension'] = '-' + data['version'] + data['extension'];
|
|
data['url'] = await getUrl(data);
|
|
return await addArchive(data);
|
|
}
|
|
|
|
/**
|
|
* Function to add PHPUnit and related tools
|
|
*
|
|
* @param data
|
|
*/
|
|
export async function addPHPUnitTools(data: RS): Promise<string> {
|
|
data['url'] = await getPharUrl(data);
|
|
return await addArchive(data);
|
|
}
|
|
|
|
/**
|
|
* Function to add WP-CLI
|
|
*
|
|
* @param data
|
|
*/
|
|
export async function addWPCLI(data: RS): Promise<string> {
|
|
if (data['version'] === 'latest') {
|
|
data['uri'] = 'wp-cli/builds/blob/gh-pages/phar/wp-cli.phar?raw=true';
|
|
data['url'] = [data['domain'], data['uri']].join('/');
|
|
} else {
|
|
data['extension'] = '-' + data['version'] + data['extension'];
|
|
data['url'] = await getUrl(data);
|
|
}
|
|
return await addArchive(data);
|
|
}
|
|
|
|
/**
|
|
* Function to get information about a tool
|
|
*
|
|
* @param release
|
|
* @param php_version
|
|
* @param os
|
|
*/
|
|
export async function getData(
|
|
release: string,
|
|
php_version: string,
|
|
os: string
|
|
): Promise<RS> {
|
|
const json_file_path = path.join(__dirname, '../src/configs/tools.json');
|
|
const json_file: string = fs.readFileSync(json_file_path, 'utf8');
|
|
const json_objects: RSRS = JSON.parse(json_file);
|
|
release = release.replace(/\s+/g, '');
|
|
const parts: string[] = release.split(':');
|
|
const tool = parts[0];
|
|
const version = parts[1];
|
|
let data: RS;
|
|
if (Object.keys(json_objects).includes(tool)) {
|
|
data = json_objects[tool];
|
|
data['tool'] = tool;
|
|
} else {
|
|
const key: string | undefined = Object.keys(json_objects).find(
|
|
(key: string) => {
|
|
return json_objects[key]['alias'] == tool;
|
|
}
|
|
);
|
|
if (key) {
|
|
data = json_objects[key];
|
|
data['tool'] = key;
|
|
} else {
|
|
data = {
|
|
tool: tool.split('/')[1],
|
|
repository: tool,
|
|
type: 'composer'
|
|
};
|
|
data = !tool.includes('/') ? {tool: tool} : data;
|
|
}
|
|
}
|
|
data['github'] = 'https://github.com';
|
|
data['domain'] ??= data['github'];
|
|
data['extension'] ??= '.phar';
|
|
data['os'] = os;
|
|
data['php_version'] = php_version;
|
|
data['prefix'] = data['github'] === data['domain'] ? 'releases' : '';
|
|
data['verb'] = data['github'] === data['domain'] ? 'download' : '';
|
|
data['fetch_latest'] ??= 'false';
|
|
data['scope'] ??= 'global';
|
|
data['version_parameter'] = JSON.stringify(data['version_parameter']) || '';
|
|
data['version_prefix'] ??= '';
|
|
data['release'] = await getRelease(release, data);
|
|
data['version'] = version
|
|
? await getVersion(version, data)
|
|
: await getLatestVersion(data);
|
|
return data;
|
|
}
|
|
|
|
export const functionRecord: Record<string, (data: RS) => Promise<string>> = {
|
|
composer: addComposer,
|
|
deployer: addDeployer,
|
|
dev_tools: addDevTools,
|
|
phive: addPhive,
|
|
blackfire_player: addBlackfirePlayer,
|
|
pecl: addPECL,
|
|
phing: addPhing,
|
|
phpunit: addPHPUnitTools,
|
|
phpcpd: addPHPUnitTools,
|
|
wp_cli: addWPCLI
|
|
};
|
|
|
|
/**
|
|
* Setup tools
|
|
*
|
|
* @param tools_csv
|
|
* @param php_version
|
|
* @param os
|
|
*/
|
|
export async function addTools(
|
|
tools_csv: string,
|
|
php_version: string,
|
|
os: string
|
|
): Promise<string> {
|
|
let script = '\n';
|
|
if (tools_csv === 'none') {
|
|
return '';
|
|
} else {
|
|
script += await utils.stepLog('Setup Tools', os);
|
|
}
|
|
const tools_list = await filterList(await utils.CSVArray(tools_csv));
|
|
await utils.asyncForEach(tools_list, async function (release: string) {
|
|
const data: RS = await getData(release, php_version, os);
|
|
script += '\n';
|
|
switch (true) {
|
|
case data['error'] !== undefined:
|
|
script += await utils.addLog(
|
|
'$cross',
|
|
data['tool'],
|
|
data['error'],
|
|
data['os']
|
|
);
|
|
break;
|
|
case 'phar' === data['type']:
|
|
data['url'] = await getUrl(data);
|
|
script += await addArchive(data);
|
|
break;
|
|
case 'composer' === data['type']:
|
|
script += await addPackage(data);
|
|
break;
|
|
case 'custom-package' === data['type']:
|
|
script += await utils.customPackage(
|
|
data['tool'].split('-')[0],
|
|
'tools',
|
|
data['version'],
|
|
data['os']
|
|
);
|
|
break;
|
|
case 'custom-function' === data['type']:
|
|
script += await functionRecord[data['function']](data);
|
|
break;
|
|
case /^none$/.test(data['tool']):
|
|
break;
|
|
default:
|
|
script += await utils.addLog(
|
|
'$cross',
|
|
data['tool'],
|
|
'Tool ' + data['tool'] + ' is not supported',
|
|
data['os']
|
|
);
|
|
break;
|
|
}
|
|
});
|
|
|
|
return script;
|
|
}
|