Public Access
gitea-actions[bot]
318 lines
11 KiB
PHP
318 lines
11 KiB
PHP
#!/usr/bin/env php
|
|
<?php
|
|
|
|
/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
|
|
*
|
|
* SPDX-License-Identifier: GPL-3.0-or-later
|
|
*
|
|
* FILE INFORMATION
|
|
* DEFGROUP: mokoplatform.CLI
|
|
* INGROUP: mokoplatform
|
|
* REPO: https://git.mokoconsulting.tech/MokoConsulting/mokoplatform
|
|
* PATH: /cli/metadata_read.php
|
|
* VERSION: 09.26.01
|
|
* BRIEF: Read and set metadata fields in .mokogitea/metadata.xml (or manifest.xml)
|
|
*/
|
|
|
|
declare(strict_types=1);
|
|
|
|
require_once __DIR__ . '/../lib/Enterprise/CliFramework.php';
|
|
|
|
use MokoEnterprise\CliFramework;
|
|
|
|
/** Field name → XPath mapping into the metadata XML */
|
|
const FIELD_MAP = [
|
|
// identity
|
|
'name' => 'identity/name',
|
|
'display-name' => 'identity/display-name',
|
|
'org' => 'identity/org',
|
|
'description' => 'identity/description',
|
|
'license' => 'identity/license',
|
|
'version' => 'identity/version',
|
|
// governance
|
|
'platform' => 'governance/platform',
|
|
'standards-version' => 'governance/standards-version',
|
|
'standards-source' => 'governance/standards-source',
|
|
// build
|
|
'language' => 'build/language',
|
|
'package-type' => 'build/package-type',
|
|
'entry-point' => 'build/entry-point',
|
|
// deploy
|
|
'source-dir' => 'deploy/source-dir',
|
|
'remote-subdir' => 'deploy/remote-subdir',
|
|
'excludes' => 'deploy/excludes',
|
|
'dev-host' => 'deploy/dev-host',
|
|
'demo-host' => 'deploy/demo-host',
|
|
];
|
|
|
|
class MetadataReadCli extends CliFramework
|
|
{
|
|
protected function configure(): void
|
|
{
|
|
$this->setDescription('Read or set metadata fields in .mokogitea/metadata.xml');
|
|
$this->addArgument('--path', 'Repository root path', '.');
|
|
$this->addArgument('--field', 'Single field name to read', '');
|
|
$this->addArgument('--set', 'Set field value (field=value), repeatable', '');
|
|
$this->addArgument('--all', 'Print all fields as KEY=VALUE lines', false);
|
|
$this->addArgument('--github-output', 'Append all fields to $GITHUB_OUTPUT', false);
|
|
$this->addArgument('--json', 'Output all fields as JSON', false);
|
|
}
|
|
|
|
protected function run(): int
|
|
{
|
|
$path = $this->getArgument('--path');
|
|
$field = $this->getArgument('--field');
|
|
$setValue = $this->getArgument('--set');
|
|
$showAll = $this->getArgument('--all');
|
|
$ghOutput = $this->getArgument('--github-output');
|
|
$jsonMode = $this->getArgument('--json');
|
|
|
|
$root = realpath($path) ?: $path;
|
|
|
|
// -- Locate metadata file --
|
|
$metadataFile = $this->findMetadataFile($root);
|
|
|
|
if ($metadataFile === null) {
|
|
$this->log('ERROR', "No metadata file found in {$root}");
|
|
return 1;
|
|
}
|
|
|
|
// -- Auto-migrate manifest.xml → metadata.xml --
|
|
$metadataFile = $this->migrateIfNeeded($metadataFile, $root);
|
|
|
|
// -- Set mode --
|
|
if ($setValue !== '') {
|
|
return $this->handleSet($metadataFile, $setValue);
|
|
}
|
|
|
|
// -- Read mode --
|
|
$xml = @simplexml_load_file($metadataFile);
|
|
|
|
if ($xml === false) {
|
|
// Fallback: legacy YAML format (.mokoplatform)
|
|
$fields = $this->parseLegacy($metadataFile);
|
|
} else {
|
|
$fields = $this->parseXml($xml, $metadataFile);
|
|
}
|
|
|
|
$fields = array_filter($fields, fn($v) => $v !== '');
|
|
|
|
return $this->outputFields($fields, $field, $showAll, $ghOutput, $jsonMode);
|
|
}
|
|
|
|
private function findMetadataFile(string $root): ?string
|
|
{
|
|
$candidates = [
|
|
"{$root}/.mokogitea/metadata.xml",
|
|
"{$root}/.mokogitea/manifest.xml",
|
|
"{$root}/.mokogitea/.manifest.xml",
|
|
"{$root}/.mokogitea/.mokoplatform",
|
|
];
|
|
|
|
foreach ($candidates as $candidate) {
|
|
if (file_exists($candidate)) {
|
|
return $candidate;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private function migrateIfNeeded(string $metadataFile, string $root): string
|
|
{
|
|
$newPath = "{$root}/.mokogitea/metadata.xml";
|
|
|
|
// Already at the new location
|
|
if ($metadataFile === $newPath) {
|
|
return $metadataFile;
|
|
}
|
|
|
|
// Legacy file found — migrate
|
|
if (str_ends_with($metadataFile, '.mokoplatform')) {
|
|
// YAML legacy — can't auto-migrate, just warn
|
|
$this->log('WARN', "Legacy .mokoplatform format detected — migrate to metadata.xml manually");
|
|
return $metadataFile;
|
|
}
|
|
|
|
// manifest.xml or .manifest.xml → metadata.xml
|
|
copy($metadataFile, $newPath);
|
|
unlink($metadataFile);
|
|
$this->log('INFO', "Migrated " . basename($metadataFile) . " → metadata.xml");
|
|
return $newPath;
|
|
}
|
|
|
|
private function parseXml(\SimpleXMLElement $xml, string $filePath): array
|
|
{
|
|
$fields = [];
|
|
foreach (FIELD_MAP as $name => $xpath) {
|
|
$parts = explode('/', $xpath);
|
|
$node = $xml;
|
|
foreach ($parts as $part) {
|
|
$node = $node->{$part} ?? null;
|
|
if ($node === null) break;
|
|
}
|
|
if ($name === 'license' && $node !== null) {
|
|
// Also extract spdx attribute
|
|
$fields['license'] = (string)$node;
|
|
$fields['license-spdx'] = (string)($node['spdx'] ?? '');
|
|
} else {
|
|
$fields[$name] = $node !== null ? (string)$node : '';
|
|
}
|
|
}
|
|
$fields['metadata-file'] = $filePath;
|
|
return $fields;
|
|
}
|
|
|
|
private function parseLegacy(string $filePath): array
|
|
{
|
|
$content = file_get_contents($filePath);
|
|
$fields = [];
|
|
if (preg_match('/^platform:\s*(.+)/m', $content, $m)) {
|
|
$fields['platform'] = trim($m[1], " \t\n\r\"'");
|
|
}
|
|
if (preg_match('/^standards_version:\s*(.+)/m', $content, $m)) {
|
|
$fields['standards-version'] = trim($m[1], " \t\n\r\"'");
|
|
}
|
|
if (preg_match('/^governed_repo:\s*(.+)/m', $content, $m)) {
|
|
$fields['name'] = trim($m[1], " \t\n\r\"'");
|
|
}
|
|
return $fields;
|
|
}
|
|
|
|
private function handleSet(string $metadataFile, string $setValue): int
|
|
{
|
|
// Parse field=value pairs (comma-separated or from repeated --set)
|
|
$pairs = [];
|
|
foreach (explode(',', $setValue) as $pair) {
|
|
$pair = trim($pair);
|
|
if ($pair === '') continue;
|
|
$eq = strpos($pair, '=');
|
|
if ($eq === false) {
|
|
$this->log('ERROR', "Invalid set format: '{$pair}' — expected field=value");
|
|
return 1;
|
|
}
|
|
$key = trim(substr($pair, 0, $eq));
|
|
$val = trim(substr($pair, $eq + 1));
|
|
$pairs[$key] = $val;
|
|
}
|
|
|
|
if (empty($pairs)) {
|
|
$this->log('ERROR', 'No field=value pairs provided');
|
|
return 1;
|
|
}
|
|
|
|
// Validate all fields exist in FIELD_MAP
|
|
foreach ($pairs as $key => $val) {
|
|
if (!isset(FIELD_MAP[$key])) {
|
|
$this->log('ERROR', "Unknown field: '{$key}'");
|
|
$this->log('INFO', 'Valid fields: ' . implode(', ', array_keys(FIELD_MAP)));
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
// Legacy files are read-only
|
|
if (str_ends_with($metadataFile, '.mokoplatform')) {
|
|
$this->log('ERROR', 'Cannot set fields on legacy .mokoplatform format — migrate to metadata.xml first');
|
|
return 1;
|
|
}
|
|
|
|
// Load XML
|
|
$xml = @simplexml_load_file($metadataFile);
|
|
if ($xml === false) {
|
|
$this->log('ERROR', "Failed to parse XML: {$metadataFile}");
|
|
return 1;
|
|
}
|
|
|
|
// Set each field
|
|
foreach ($pairs as $key => $val) {
|
|
$xpath = FIELD_MAP[$key];
|
|
$parts = explode('/', $xpath);
|
|
$section = $parts[0];
|
|
$element = $parts[1];
|
|
|
|
if (!isset($xml->{$section})) {
|
|
$this->log('ERROR', "Section <{$section}> not found in XML — cannot set '{$key}'");
|
|
return 1;
|
|
}
|
|
|
|
if (!isset($xml->{$section}->{$element})) {
|
|
$this->log('ERROR', "Element <{$element}> not found in <{$section}> — cannot set '{$key}'");
|
|
return 1;
|
|
}
|
|
|
|
$old = (string)$xml->{$section}->{$element};
|
|
$xml->{$section}->{$element} = $val;
|
|
$this->log('INFO', "Set {$key}: '{$old}' → '{$val}'");
|
|
}
|
|
|
|
// Write back with preserved formatting
|
|
$dom = new \DOMDocument('1.0', 'UTF-8');
|
|
$dom->preserveWhiteSpace = false;
|
|
$dom->formatOutput = true;
|
|
$dom->loadXML($xml->asXML());
|
|
$dom->save($metadataFile);
|
|
|
|
$this->log('INFO', "Updated {$metadataFile}");
|
|
return 0;
|
|
}
|
|
|
|
private function outputFields(array $fields, string $field, $showAll, $ghOutput, $jsonMode): int
|
|
{
|
|
if ($ghOutput) {
|
|
$mode = 'github-output';
|
|
} elseif ($showAll) {
|
|
$mode = 'all';
|
|
} elseif ($jsonMode) {
|
|
$mode = 'json';
|
|
} else {
|
|
$mode = 'field';
|
|
}
|
|
|
|
switch ($mode) {
|
|
case 'field':
|
|
if ($field === '') {
|
|
$this->log('ERROR', "Usage: metadata_read.php --path <dir> --field <name>");
|
|
$this->log('ERROR', " metadata_read.php --path <dir> --all");
|
|
$this->log('ERROR', " metadata_read.php --path <dir> --json");
|
|
$this->log('ERROR', " metadata_read.php --path <dir> --set field=value");
|
|
return 2;
|
|
}
|
|
echo ($fields[$field] ?? '') . "\n";
|
|
break;
|
|
|
|
case 'all':
|
|
foreach ($fields as $k => $v) {
|
|
echo "{$k}={$v}\n";
|
|
}
|
|
break;
|
|
|
|
case 'json':
|
|
echo json_encode($fields, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES) . "\n";
|
|
break;
|
|
|
|
case 'github-output':
|
|
$outputFile = getenv('GITHUB_OUTPUT');
|
|
if ($outputFile === false || $outputFile === '') {
|
|
$this->log('ERROR', 'GITHUB_OUTPUT not set — printing to stdout instead');
|
|
foreach ($fields as $k => $v) {
|
|
$envKey = str_replace('-', '_', $k);
|
|
echo "{$envKey}={$v}\n";
|
|
}
|
|
} else {
|
|
$fh = fopen($outputFile, 'a');
|
|
foreach ($fields as $k => $v) {
|
|
$envKey = str_replace('-', '_', $k);
|
|
fwrite($fh, "{$envKey}={$v}\n");
|
|
}
|
|
fclose($fh);
|
|
$this->log('INFO', "Wrote " . count($fields) . " fields to GITHUB_OUTPUT");
|
|
}
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
$app = new MetadataReadCli();
|
|
exit($app->execute());
|