mirror of https://github.com/friendica/friendica
238 lines
7.3 KiB
PHP
238 lines
7.3 KiB
PHP
<?php
|
|
/**
|
|
* @copyright Copyright (C) 2010-2023, the Friendica project
|
|
*
|
|
* @license GNU AGPL version 3 or any later version
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Affero General Public License as
|
|
* published by the Free Software Foundation, either version 3 of the
|
|
* License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Affero General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Affero General Public License
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
|
|
namespace Friendica\Core\Config\Util;
|
|
|
|
/**
|
|
* Util to transform back the config array into a string
|
|
*/
|
|
class ConfigFileTransformer
|
|
{
|
|
/**
|
|
* This method takes an array of config values and applies some standard rules for formatting on it
|
|
*
|
|
* Beware that the applied rules follow some basic formatting principles for node.config.php
|
|
* and doesn't support any custom formatting rules.
|
|
*
|
|
* f.e. associative array and list formatting are very complex with newlines and indentations, thus there are
|
|
* three hardcoded types of formatting for them.
|
|
*
|
|
* a negative example, what's NOT working:
|
|
* key => [ value1, [inner_value1, inner_value2], value2]
|
|
* Since this isn't necessary for config values, there's no further logic handling such complex-list-in-list scenarios
|
|
*
|
|
* @param array $data A full config array
|
|
*
|
|
* @return string The config stream, which can be saved
|
|
*/
|
|
public static function encode(array $data): string
|
|
{
|
|
// Add the typical header values
|
|
$dataString = '<?php' . PHP_EOL . PHP_EOL;
|
|
$dataString .= 'return ';
|
|
|
|
$dataString .= static::extractArray($data);
|
|
|
|
// the last array line, close it with a semicolon
|
|
$dataString .= ";" . PHP_EOL;
|
|
|
|
return $dataString;
|
|
}
|
|
|
|
/**
|
|
* Extracts an inner config array.
|
|
* Either as an associative array or as a list
|
|
*
|
|
* @param array $config The config array which should get extracted
|
|
* @param int $level The current level of recursion (necessary for tab-indentation calculation)
|
|
* @param bool $inList If true, the current array resides inside another list. Different rules may be applicable
|
|
*
|
|
* @return string The config string
|
|
*/
|
|
protected static function extractArray(array $config, int $level = 0, bool $inList = false): string
|
|
{
|
|
if (array_values($config) === $config) {
|
|
return self::extractList($config, $level, $inList);
|
|
} else {
|
|
return self::extractAssociativeArray($config, $level, $inList);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Extracts a key-value array and save it into a string
|
|
* output:
|
|
* [
|
|
* 'key' => value,
|
|
* 'key' => value,
|
|
* ...
|
|
* ]
|
|
*
|
|
* @param array $config The associative/key-value array
|
|
* @param int $level The current level of recursion (necessary for tab-indentation calculation)
|
|
* @param bool $inList If true, the current array resides inside another list. Different rules may be applicable
|
|
*
|
|
* @return string The config string
|
|
*/
|
|
protected static function extractAssociativeArray(array $config, int $level = 0, bool $inList = false): string
|
|
{
|
|
$string = '';
|
|
|
|
// Because we're in a list, we have to add a line-break first
|
|
if ($inList) {
|
|
$string .= PHP_EOL . str_repeat("\t", $level);
|
|
}
|
|
|
|
// Add a typical Line break for a taxative list of key-value pairs
|
|
$string .= '[' . PHP_EOL;
|
|
|
|
foreach ($config as $configKey => $configValue) {
|
|
$string .= str_repeat("\t", $level + 1) .
|
|
"'$configKey' => " .
|
|
static::transformConfigValue($configValue, $level) .
|
|
',' . PHP_EOL;
|
|
}
|
|
|
|
$string .= str_repeat("\t", $level) . ']';
|
|
|
|
return $string;
|
|
}
|
|
|
|
/**
|
|
* Extracts a list and save it into a string
|
|
* output1 - simple:
|
|
* [ value, value, value ]
|
|
*
|
|
* output2 - complex:
|
|
* [
|
|
* [ value, value, value ],
|
|
* value,
|
|
* [
|
|
* key => value,
|
|
* key => value,
|
|
* ],
|
|
* ]
|
|
*
|
|
* @param array $config The list
|
|
* @param int $level The current level of recursion (necessary for tab-indentation calculation)
|
|
* @param bool $inList If true, the current array resides inside another list. Different rules may be applicable
|
|
*
|
|
* @return string The config string
|
|
*/
|
|
protected static function extractList(array $config, int $level = 0, bool $inList = false): string
|
|
{
|
|
$string = '[';
|
|
|
|
$countConfigValues = count($config);
|
|
// multiline defines, if each entry uses a new line
|
|
$multiline = false;
|
|
|
|
// Search if any value is an array, because then other formatting rules are applicable
|
|
foreach ($config as $item) {
|
|
if (is_array($item)) {
|
|
$multiline = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
for ($i = 0; $i < $countConfigValues; $i++) {
|
|
$isArray = is_array($config[$i]);
|
|
|
|
/**
|
|
* In case this is an array in an array, directly extract this array again and continue
|
|
* Skip any other logic since this isn't applicable for an array in an array
|
|
*/
|
|
if ($isArray) {
|
|
$string .= PHP_EOL . str_repeat("\t", $level + 1);
|
|
$string .= static::extractArray($config[$i], $level + 1, $inList) . ',';
|
|
continue;
|
|
}
|
|
|
|
if ($multiline) {
|
|
$string .= PHP_EOL . str_repeat("\t", $level + 1);
|
|
}
|
|
|
|
$string .= static::transformConfigValue($config[$i], $level, true);
|
|
|
|
// add trailing commas or whitespaces for certain config entries
|
|
if (($i < ($countConfigValues - 1))) {
|
|
$string .= ',';
|
|
if (!$multiline) {
|
|
$string .= ' ';
|
|
}
|
|
}
|
|
}
|
|
|
|
// Add a new line for the last bracket as well
|
|
if ($multiline) {
|
|
$string .= PHP_EOL . str_repeat("\t", $level);
|
|
}
|
|
|
|
$string .= ']';
|
|
|
|
return $string;
|
|
}
|
|
|
|
/**
|
|
* Transforms one config value and returns the corresponding text-representation
|
|
*
|
|
* @param mixed $value Any value to transform
|
|
* @param int $level The current level of recursion (necessary for tab-indentation calculation)
|
|
* @param bool $inList If true, the current array resides inside another list. Different rules may be applicable
|
|
*
|
|
* @return string
|
|
*/
|
|
protected static function transformConfigValue($value, int $level = 0, bool $inList = false): string
|
|
{
|
|
switch (gettype($value)) {
|
|
case "boolean":
|
|
return ($value ? 'true' : 'false');
|
|
case "integer":
|
|
case "double":
|
|
return $value;
|
|
case "string":
|
|
return sprintf('\'%s\'', addcslashes($value, '\'\\'));
|
|
case "array":
|
|
return static::extractArray($value, ++$level, $inList);
|
|
case "NULL":
|
|
return "null";
|
|
case "object":
|
|
if (method_exists($value, '__toString')) {
|
|
return sprintf('\'%s\'', $value);
|
|
} elseif ($value instanceof \Serializable) {
|
|
try {
|
|
return $value->serialize();
|
|
} catch (\Exception $e) {
|
|
throw new \InvalidArgumentException(sprintf('Cannot serialize %s.', gettype($value)), $e);
|
|
}
|
|
} else {
|
|
throw new \InvalidArgumentException(sprintf('%s is an object without stringify.', gettype($value)));
|
|
}
|
|
case "resource":
|
|
case "resource (closed)":
|
|
throw new \InvalidArgumentException(sprintf('%s in configs are not supported yet.', gettype($value)));
|
|
case "unknown type":
|
|
throw new \InvalidArgumentException(sprintf('%s is an unknown value', $value));
|
|
default:
|
|
throw new \InvalidArgumentException(sprintf('%s is currently unsupported', $value));
|
|
}
|
|
}
|
|
}
|