anthony/pm-convert
1
0
Fork 0
Code Issues 1 Pull Requests Releases Activity

Some refactorings related to main Processor class

Browse Source
This commit is contained in:
Anthony Axenov 2024-08-04 23:37:39 +08:00
parent 2bf9345f69
commit 9ee4a8c290
Signed by: anthony
GPG Key ID: EA9EC32FF7CCD4EC
16 changed files with 668 additions and 339 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

@ -1,5 +1,7 @@
/.idea
/.vscode
/vendor
/nbproject
.phpunit.result.cache
.phpunit.cache

2
README.md
View File

@ -70,7 +70,7 @@ Possible ARGUMENTS:
-p, --preserve - do not delete OUTPUT_PATH (if exists)
--dump - convert provided arguments into settings file in `pwd`
-h, --help - show this help message and exit
-v, --version - show version info and exit
--version - show version info and exit
If no ARGUMENTS passed then --help implied.
If both -f and -d are specified then only unique set of files from both arguments will be converted.

15
pm-convert
View File

@ -2,10 +2,12 @@
<?php
declare(strict_types=1);
use PmConverter\Handler;
const EOL = PHP_EOL;
const DS = DIRECTORY_SEPARATOR;
use PmConverter\Processor;
const PM_VERSION = '1.7';
$paths = [
__DIR__ . '/../../autoload.php',
@ -22,14 +24,15 @@ foreach ($paths as $path) {
is_null($file) && throw new RuntimeException('Unable to locate autoload.php file.');
$processor = new Processor($argv);
$handler = new Handler();
try {
$processor->handle();
$handler->init($argv);
$handler->start();
} catch (InvalidArgumentException $e) {
fwrite(STDERR, sprintf('ERROR: %s%s', $e->getMessage(), EOL));
print(implode(EOL, Processor::usage()));
die(1);
$handler::printHelp();
exit(1);
} catch (Exception $e) {
fwrite(STDERR, sprintf('ERROR: %s%s', $e->getMessage(), EOL));
die(1);
exit(1);
}

178
src/ArgumentParser.php Normal file
View File

@ -0,0 +1,178 @@
<?php
declare(strict_types=1);
namespace PmConverter;
use InvalidArgumentException;
use PmConverter\Converters\ConvertFormat;
use PmConverter\Enums\ArgumentNames as AN;
class ArgumentParser
{
/**
* @var array Raw arguments passed from cli ($argv)
*/
protected readonly array $raw;
/**
* @var array Parsed and ready to use
*/
protected array $parsed;
/**
* Constructor
*
* @param array $argv Raw arguments passed from cli ($argv)
*/
public function __construct(array $argv)
{
$this->raw = array_slice($argv, 1);
}
/**
* Parses raw arguments
*
* @return array Settings according to settings file format
*/
public function parse(): array
{
foreach ($this->raw as $idx => $arg) {
switch ($arg) {
case '-c':
case '--config':
if (empty($this->raw[$idx + 1])) {
throw new InvalidArgumentException('a configuration file path is expected for -c (--config)');
}
if (isset($this->parsed[AN::Config])) {
printf(
"INFO: Config file is already set to '%s' and will be overwritten to '%s'",
$this->parsed[AN::Config],
$this->raw[$idx + 1],
);
}
$this->parsed[AN::Config] = $this->raw[$idx + 1];
break;
case '-d':
case '--dir':
if (empty($this->raw[$idx + 1])) {
throw new InvalidArgumentException('a directory path is expected for -d (--dir)');
}
$this->parsed[AN::Directories][] = $this->raw[$idx + 1];
break;
case '-f':
case '--file':
if (empty($this->raw[$idx + 1])) {
throw new InvalidArgumentException('a directory path is expected for -f (--file)');
}
$this->parsed[AN::Files][] = $this->raw[$idx + 1];
break;
case '-e':
case '--env':
if (empty($this->raw[$idx + 1])) {
throw new InvalidArgumentException('an environment file path is expected for -e (--env)');
}
$this->parsed[AN::Environment][] = $this->raw[$idx + 1];
break;
case '-o':
case '--output':
if (empty($this->raw[$idx + 1])) {
throw new InvalidArgumentException('an output path is expected for -o (--output)');
}
$this->parsed[AN::Output][] = $this->raw[$idx + 1];
break;
case '-p':
case '--preserve':
$this->parsed[AN::PreserveOutput] = true;
break;
case '--http':
$this->parsed[AN::Formats][] = ConvertFormat::Http;
break;
case '--curl':
$this->parsed[AN::Formats][] = ConvertFormat::Curl;
break;
case '--wget':
$this->parsed[AN::Formats][] = ConvertFormat::Wget;
break;
case '--v2.0':
$this->parsed[AN::Formats][] = ConvertFormat::Postman20;
break;
case '--v2.1':
$this->parsed[AN::Formats][] = ConvertFormat::Postman21;
break;
case '-a':
case '--all':
foreach (ConvertFormat::cases() as $format) {
$this->parsed[AN::Formats][] = $format;
}
break;
case '--var':
$definition = trim($this->raw[$idx + 1]);
$name = strtok($definition, '='); // take first part before equal sign as var name
$value = strtok(''); // take the rest of argument as var value
if (isset($this->parsed[AN::Vars][$name])) {
printf(
"INFO: Variable '%s' is already set to '%s' and will be overwritten to '%s'",
$name,
$this->parsed[AN::Vars][$name],
$value,
);
}
$this->parsed[AN::Vars][$name] = $value;
break;
case '--dev':
$this->parsed[AN::DevMode] = true;
break;
case '-v':
case '--verbose':
$this->parsed[AN::Verbose] = true;
break;
case '--dump':
$this->parsed[AN::Dump] = true;
break;
case '--version':
$this->parsed[AN::Version] = true;
break;
case '-h':
case '--help':
$this->parsed[AN::Help] = true;
break;
}
}
foreach ([AN::Directories, AN::Files, AN::Formats] as $field) {
if (!empty($this->parsed[$field])) {
$this->parsed[$field] = array_unique($this->parsed[$field] ?? []);
}
}
return $this->parsed;
}
/**
* Returns parsed arguments (if set) or parses raw ones
*
* @return array
*/
public function parsed(): array
{
return $this->parsed ??= $this->parse();
}
}

1
src/Collection.php
View File

@ -7,6 +7,7 @@ namespace PmConverter;
use Exception;
use Generator;
use JsonException;
use PmConverter\Enums\CollectionVersion;
use Stringable;
/**

4
src/Converters/Abstract/AbstractRequest.php
View File

@ -4,11 +4,11 @@ declare(strict_types=1);
namespace PmConverter\Converters\Abstract;
use PmConverter\CollectionVersion;
use PmConverter\Converters\RequestContract;
use PmConverter\Enums\CollectionVersion;
use PmConverter\Enums\HttpVersion;
use PmConverter\Exceptions\EmptyHttpVerbException;
use PmConverter\Exceptions\InvalidHttpVersionException;
use PmConverter\HttpVersion;
use Stringable;
/**

2
src/Converters/Postman20/Postman20Converter.php
View File

@ -5,8 +5,8 @@ declare(strict_types=1);
namespace PmConverter\Converters\Postman20;
use PmConverter\Collection;
use PmConverter\CollectionVersion;
use PmConverter\Converters\Abstract\AbstractConverter;
use PmConverter\Enums\CollectionVersion;
use PmConverter\Exceptions\CannotCreateDirectoryException;
use PmConverter\Exceptions\DirectoryIsNotWriteableException;
use PmConverter\FileSystem;

2
src/Converters/Postman21/Postman21Converter.php
View File

@ -5,8 +5,8 @@ declare(strict_types=1);
namespace PmConverter\Converters\Postman21;
use PmConverter\Collection;
use PmConverter\CollectionVersion;
use PmConverter\Converters\Abstract\AbstractConverter;
use PmConverter\Enums\CollectionVersion;
use PmConverter\Exceptions\CannotCreateDirectoryException;
use PmConverter\Exceptions\DirectoryIsNotWriteableException;
use PmConverter\FileSystem;

25
src/Enums/ArgumentNames.php Normal file
View File

@ -0,0 +1,25 @@
<?php
declare(strict_types=1);
namespace PmConverter\Enums;
/**
* Argument names
*/
class ArgumentNames
{
public const Config = 'config';
public const Directories = 'directories';
public const Files = 'files';
public const Environment = 'environment';
public const Output = 'output';
public const PreserveOutput = 'preserveOutput';
public const Formats = 'formats';
public const Vars = 'vars';
public const DevMode = 'devMode';
public const Verbose = 'verbose';
public const Dump = 'dump';
public const Version = 'version';
public const Help = 'help';
}

2
src/CollectionVersion.php → src/Enums/CollectionVersion.php
View File

@ -2,7 +2,7 @@
declare(strict_types=1);
namespace PmConverter;
namespace PmConverter\Enums;
enum CollectionVersion: string
{

2
src/HttpVersion.php → src/Enums/HttpVersion.php
View File

@ -2,7 +2,7 @@
declare(strict_types=1);
namespace PmConverter;
namespace PmConverter\Enums;
enum HttpVersion: string
{

1
src/FileSystem.php
View File

@ -6,6 +6,7 @@ namespace PmConverter;
use Exception;
use JsonException;
use PmConverter\Enums\CollectionVersion;
use PmConverter\Exceptions\CannotCreateDirectoryException;
use PmConverter\Exceptions\DirectoryIsNotReadableException;
use PmConverter\Exceptions\DirectoryIsNotWriteableException;

223
src/Handler.php Normal file
View File

@ -0,0 +1,223 @@
<?php
declare(strict_types = 1);
namespace PmConverter;
use JsonException;
use PmConverter\Enums\ArgumentNames as AN;
class Handler
{
/**
* @var array Ready to use arguments
*/
protected array $arguments;
/**
* @var Settings Settings read from file and merged with provided in cli
*/
protected Settings $settings;
/**
* @var Environment Environment laoded from file with custom vars provided
*/
protected Environment $env;
/**
* @var Processor Object that do convertions according to settings
*/
protected Processor $processor;
/**
* Initializes main flow
*
* @param array $argv Raw arguments passed from cli
* @return void
* @throws JsonException
* @throws \Exception
*/
public function init(array $argv): void
{
$this->arguments = (new ArgumentParser($argv))->parsed();
if (!empty($this->arguments[AN::Help])) {
self::printHelp();
exit;
}
if (!empty($this->arguments[AN::Version])) {
self::printVersion();
exit;
}
$this->settings = new Settings();
$this->settings->loadFromFile($this->arguments[AN::Config] ?? null);
$this->settings->override($this->arguments);
empty($arguments[AN::Dump]) || $this->handleSettingsDump();
$this->env = Environment::instance()
->readFromFile($this->settings->envFilepath())
->setCustomVars($this->settings->vars());
$this->processor = new Processor($this->settings, $this->env);
}
/**
* Starts convertions
*
* @return void
* @throws Exceptions\CannotCreateDirectoryException
* @throws Exceptions\DirectoryIsNotReadableException
* @throws Exceptions\DirectoryIsNotWriteableException
* @throws Exceptions\DirectoryNotExistsException
* @throws Exceptions\IncorrectSettingsFileException
* @throws JsonException
*/
public function start(): void
{
self::printArray(self::version(), self::copyright());
$this->processor->start();
}
/**
* Handles settings file saving when requested by --dump
*
* @return never
*/
protected function handleSettingsDump(): never
{
$answer = 'o';
if ($this->settings->fileExists()) {
echo 'Settings file already exists: ' . $this->settings->filePath() . EOL;
echo 'Do you want to (o)verwrite it, (b)ackup it and create new one or (c)ancel (default)?' . EOL;
$answer = strtolower(trim(readline('> ')));
}
if (!in_array($answer, ['o', 'b'])) {
die('Current settings file has not been changed' . EOL);
}
if ($answer === 'b') {
$filepath = $this->settings->backup();
printf("Settings file has been backed up to file:%s\t%s%s", EOL, $filepath, EOL);
}
$this->settings->dump();
printf("Arguments has been converted into settings file:%s\t%s%s", EOL, $this->settings->filePath(), EOL);
die('Review and edit it if needed.' . EOL);
}
/**
* Returns usage help strings
*
* @return array
*/
protected static function help(): array
{
return array_merge(self::version(), [
'Usage:',
"\t./pm-convert -f|-d PATH -o OUTPUT_PATH [ARGUMENTS] [FORMATS]",
"\tphp pm-convert -f|-d PATH -o OUTPUT_PATH [ARGUMENTS] [FORMATS]",
"\tcomposer pm-convert -f|-d PATH -o OUTPUT_PATH [ARGUMENTS] [FORMATS]",
"\t./vendor/bin/pm-convert -f|-d PATH -o OUTPUT_PATH [ARGUMENTS] [FORMATS]",
'',
'Possible ARGUMENTS:',
"\t-f, --file - a PATH to a single collection file to convert from",
"\t-d, --dir - a PATH to a directory with collections to convert from",
"\t-o, --output - a directory OUTPUT_PATH to put results in",
"\t-e, --env - use environment file with variables to replace in requests",
"\t--var \"NAME=VALUE\" - force replace specified env variable called NAME with custom VALUE",
"\t-p, --preserve - do not delete OUTPUT_PATH (if exists)",
"\t --dump - convert provided arguments into settings file in `pwd",
"\t-h, --help - show this help message and exit",
"\t-v, --version - show version info and exit",
'',
'If no ARGUMENTS passed then --help implied.',
'If both -f and -d are specified then only unique set of files from both arguments will be converted.',
'-f or -d are required to be specified at least once, but each may be specified multiple times.',
'PATH must be a valid path to readable json-file or directory.',
'OUTPUT_PATH must be a valid path to writeable directory.',
'If -o or -e was specified several times then only last one will be used.',
'',
'Possible FORMATS:',
"\t--http - generate raw *.http files (default)",
"\t--curl - generate shell scripts with curl command",
"\t--wget - generate shell scripts with wget command",
"\t--v2.0 - convert from Postman Collection Schema v2.1 into v2.0",
"\t--v2.1 - convert from Postman Collection Schema v2.0 into v2.1",
"\t-a, --all - convert to all of formats listed above",
'',
'If no FORMATS specified then --http implied.',
'Any of FORMATS can be specified at the same time or replaced by --all.',
'',
'Example:',
" ./pm-convert \ ",
" -f ~/dir1/first.postman_collection.json \ ",
" --directory ~/team \ ",
" --file ~/dir2/second.postman_collection.json \ ",
" --env ~/localhost.postman_environment.json \ ",
" -d ~/personal \ ",
" --var \"myvar=some value\" \ ",
" -o ~/postman_export \ ",
" --all",
"",
], self::copyright());
}
/**
* Prints usage help message in stdout
*
* @return void
*/
public static function printHelp(): void
{
self::printArray(self::help());
}
/**
* Returns version strings
*
* @return string[]
*/
protected static function version(): array
{
return ['Postman collection converter v' . PM_VERSION];
}
/**
* Prints version message in stdout
*
* @return void
*/
public static function printVersion(): void
{
self::printArray(self::version());
}
/**
* Returns copyright strings
*
* @return string[]
*/
protected static function copyright(): array
{
return [
'Anthony Axenov (c) 2023 - ' . (int)date('Y') . ', MIT license',
'https://git.axenov.dev/anthony/pm-convert',
// '', //TODO
];
}
/**
* Prints an arrays of string to stdout
*
* @param ...$strings
* @return void
*/
protected static function printArray(...$strings): void
{
fwrite(STDOUT, implode("\n", array_merge(...$strings)));
}
}

261
src/Processor.php
View File

@ -6,12 +6,9 @@ namespace PmConverter;
use Exception;
use Generator;
use InvalidArgumentException;
use JetBrains\PhpStorm\NoReturn;
use JsonException;
use PmConverter\Converters\Abstract\AbstractConverter;
use PmConverter\Converters\ConverterContract;
use PmConverter\Converters\ConvertFormat;
use PmConverter\Exceptions\CannotCreateDirectoryException;
use PmConverter\Exceptions\DirectoryIsNotReadableException;
use PmConverter\Exceptions\DirectoryIsNotWriteableException;
@ -19,15 +16,10 @@ use PmConverter\Exceptions\DirectoryNotExistsException;
use PmConverter\Exceptions\IncorrectSettingsFileException;
/**
* Main class
* Processor class
*/
class Processor
{
/**
* Converter version
*/
public const VERSION = '1.6.1';
/**
* @var int Initial timestamp
*/
@ -38,150 +30,23 @@ class Processor
*/
protected readonly int $initRam;
/**
* @var Settings Settings (lol)
*/
protected Settings $settings;
/**
* @var ConverterContract[] Converters will be used for conversion according to chosen formats
*/
protected array $converters = [];
/**
* @var bool Do we need to save settings file and exit or not?
*/
protected bool $needDumpSettings = false;
/**
* @var Environment
*/
public Environment $env;
/**
* Constructor
*
* @param array $argv Arguments came from cli
* @throws IncorrectSettingsFileException
* @throws JsonException
* @param Settings $settings Settings (lol)
* @param Environment $env Environment
*/
public function __construct(protected readonly array $argv)
{
public function __construct(
protected Settings $settings,
protected Environment $env,
) {
$this->initTime = hrtime(true);
$this->initRam = memory_get_usage(true);
$this->settings = Settings::init();
$this->env = Environment::instance()
->readFromFile($this->settings->envFilepath())
->setCustomVars($this->settings->vars());
$this->parseArgs();
$this->needDumpSettings && $this->dumpSettingsFile();
}
/**
* Parses an array of arguments came from cli
*
* @return void
* @throws JsonException
*/
protected function parseArgs(): void
{
$arguments = array_slice($this->argv, 1);
$needHelp = count($arguments) === 0 && !$this->settings::fileExists();
foreach ($arguments as $idx => $arg) {
switch ($arg) {
case '-f':
case '--file':
$this->settings->addFilePath($this->argv[$idx + 1]);
break;
case '-o':
case '--output':
if (empty($this->argv[$idx + 1])) {
throw new InvalidArgumentException('-o is required');
}
$this->settings->setOutputPath($this->argv[$idx + 1]);
break;
case '-d':
case '--dir':
if (empty($this->argv[$idx + 1])) {
throw new InvalidArgumentException('a directory path is expected for -d (--dir)');
}
$this->settings->addDirPath($this->argv[$idx + 1]);
break;
case '-e':
case '--env':
$this->settings->setEnvFilepath($this->argv[$idx + 1]);
break;
case '-p':
case '--preserve':
$this->settings->setPreserveOutput(true);
break;
case '--http':
$this->settings->addFormat(ConvertFormat::Http);
break;
case '--curl':
$this->settings->addFormat(ConvertFormat::Curl);
break;
case '--wget':
$this->settings->addFormat(ConvertFormat::Wget);
break;
case '--v2.0':
$this->settings->addFormat(ConvertFormat::Postman20);
break;
case '--v2.1':
$this->settings->addFormat(ConvertFormat::Postman21);
break;
case '-a':
case '--all':
foreach (ConvertFormat::cases() as $format) {
$this->settings->addFormat($format);
}
break;
case '--var':
//TODO split by first equal sign
$this->env->setCustomVar(...explode('=', trim($this->argv[$idx + 1])));
break;
case '--dev':
$this->settings->setDevMode(true);
break;
case '--dump':
$this->needDumpSettings = true;
break;
case '-v':
case '--version':
die(implode(EOL, $this->version()) . EOL);
case '-h':
case '--help':
$needHelp = true;
break;
}
}
if ($needHelp) {
die(implode(EOL, $this->usage()) . EOL);
}
if (empty($this->settings->collectionPaths())) {
throw new InvalidArgumentException('there are no collections to convert');
}
if (empty($this->settings->outputPath())) {
throw new InvalidArgumentException('-o is required');
}
if (empty($this->settings->formats())) {
$this->settings->addFormat(ConvertFormat::Http);
}
}
/**
@ -193,41 +58,14 @@ class Processor
* @throws DirectoryIsNotWriteableException
* @throws DirectoryNotExistsException
* @throws JsonException
* @throws IncorrectSettingsFileException
*/
public function handle(): void
public function start(): void
{
$this->prepareOutputDirectory();
$this->initConverters();
$this->convert();
}
/**
* Writes all settings into file if --dump provided
*
* @return never
*/
#[NoReturn]
protected function dumpSettingsFile(): never
{
$answer = 'o';
if ($this->settings::fileExists()) {
echo 'Settings file already exists: ' . $this->settings::filepath() . EOL;
echo 'Do you want to (o)verwrite it, (b)ackup it and create new one or (c)ancel (default)?' . EOL;
$answer = strtolower(trim(readline('> ')));
}
if (!in_array($answer, ['o', 'b'])) {
die('Current settings file has not been changed' . EOL);
}
if ($answer === 'b') {
$filepath = $this->settings->backup();
printf("Settings file has been backed up to file:%s\t%s%s", EOL, $filepath, EOL);
}
$this->settings->dump($this->env->customVars());
printf("Arguments has been converted into settings file:%s\t%s%s", EOL, $this->settings::filepath(), EOL);
die('Review and edit it if needed.' . EOL);
}
/**
* Initializes output directory
*
@ -264,7 +102,7 @@ class Processor
* @return Generator<Collection>
* @throws JsonException
*/
protected function newCollection(): Generator
protected function nextCollection(): Generator
{
foreach ($this->settings->collectionPaths() as $collectionPath) {
yield Collection::fromFile($collectionPath);
@ -280,9 +118,7 @@ class Processor
{
$count = count($this->settings->collectionPaths());
$current = $success = 0;
$collection = null;
print(implode(EOL, array_merge($this->version(), $this->copyright())) . EOL . EOL);
foreach ($this->newCollection() as $collection) {
foreach ($this->nextCollection() as $collection) {
++$current;
printf("Converting '%s' (%d/%d):%s", $collection->name(), $current, $count, EOL);
foreach ($this->converters as $type => $converter) {
@ -297,7 +133,7 @@ class Processor
} catch (Exception $e) {
printf(' ERROR %s: %s%s', $e->getCode(), $e->getMessage(), EOL);
if ($this->settings->isDevMode()) {
array_map(static fn ($line) => printf(' %s%s', $line, EOL), $e->getTrace());
array_map(static fn (string $line) => printf(' %s%s', $line, EOL), $e->getTrace());
}
}
}
@ -326,79 +162,4 @@ class Processor
$ram = (memory_get_peak_usage(true) - $this->initRam) / 1024 / 1024;
printf("Converted %d/%d in %.2f $timeFmt using up to %.2f MiB RAM%s", $success, $count, $time, $ram, EOL);
}
/**
* @return string[]
*/
public static function version(): array
{
return ['Postman collection converter v' . self::VERSION];
}
/**
* @return string[]
*/
public static function copyright(): array
{
$years = ($year = (int)date('Y')) > 2023 ? "2023 - $year" : $year;
return [
"Anthony Axenov (c) $years, MIT license",
'https://git.axenov.dev/anthony/pm-convert'
];
}
/**
* @return array
*/
public static function usage(): array
{
return array_merge(static::version(), [
'Usage:',
"\t./pm-convert -f|-d PATH -o OUTPUT_PATH [ARGUMENTS] [FORMATS]",
"\tphp pm-convert -f|-d PATH -o OUTPUT_PATH [ARGUMENTS] [FORMATS]",
"\tcomposer pm-convert -f|-d PATH -o OUTPUT_PATH [ARGUMENTS] [FORMATS]",
"\t./vendor/bin/pm-convert -f|-d PATH -o OUTPUT_PATH [ARGUMENTS] [FORMATS]",
'',
'Possible ARGUMENTS:',
"\t-f, --file - a PATH to a single collection file to convert from",
"\t-d, --dir - a PATH to a directory with collections to convert from",
"\t-o, --output - a directory OUTPUT_PATH to put results in",
"\t-e, --env - use environment file with variables to replace in requests",
"\t--var \"NAME=VALUE\" - force replace specified env variable called NAME with custom VALUE",
"\t-p, --preserve - do not delete OUTPUT_PATH (if exists)",
"\t --dump - convert provided arguments into settings file in `pwd",
"\t-h, --help - show this help message and exit",
"\t-v, --version - show version info and exit",
'',
'If no ARGUMENTS passed then --help implied.',
'If both -f and -d are specified then only unique set of files from both arguments will be converted.',
'-f or -d are required to be specified at least once, but each may be specified multiple times.',
'PATH must be a valid path to readable json-file or directory.',
'OUTPUT_PATH must be a valid path to writeable directory.',
'If -o or -e was specified several times then only last one will be used.',
'',
'Possible FORMATS:',
"\t--http - generate raw *.http files (default)",
"\t--curl - generate shell scripts with curl command",
"\t--wget - generate shell scripts with wget command",
"\t--v2.0 - convert from Postman Collection Schema v2.1 into v2.0",
"\t--v2.1 - convert from Postman Collection Schema v2.0 into v2.1",
"\t-a, --all - convert to all of formats listed above",
'',
'If no FORMATS specified then --http implied.',
'Any of FORMATS can be specified at the same time or replaced by --all.',
'',
'Example:',
" ./pm-convert \ ",
" -f ~/dir1/first.postman_collection.json \ ",
" --directory ~/team \ ",
" --file ~/dir2/second.postman_collection.json \ ",
" --env ~/localhost.postman_environment.json \ ",
" -d ~/personal \ ",
" --var \"myvar=some value\" \ ",
" -o ~/postman_export \ ",
" --all",
"",
], static::copyright());
}
}

283
src/Settings.php
View File

@ -4,10 +4,11 @@ declare(strict_types=1);
namespace PmConverter;
use Exception;
use InvalidArgumentException;
use JsonException;
use PmConverter\Converters\ConvertFormat;
use PmConverter\Exceptions\IncorrectSettingsFileException;
use PmConverter\Enums\ArgumentNames as AN;
/**
* Class responsible for settings storage and dumping
@ -15,76 +16,201 @@ use PmConverter\Exceptions\IncorrectSettingsFileException;
class Settings
{
/**
* @var string Full path to settings file
* @var string|null Full path to settings file
*/
protected static string $filepath;
protected ?string $filePath;
/**
* @var bool Flag to output some debug-specific messages
*/
protected bool $devMode = false;
protected bool $devMode;
/**
* @var string[] Paths to collection directories
*/
protected array $directories = [];
protected array $dirPaths;
/**
* @var string[] Paths to collection files
*/
protected array $collectionPaths = [];
protected array $collectionPaths;
/**
* @var string Output path where to put results in
* @var string|null Output path where to put results in
*/
protected string $outputPath = '';
protected ?string $outputPath;
/**
* @var bool Flag to remove output directories or not before conversion started
*/
protected bool $preserveOutput = false;
protected bool $preserveOutput;
/**
* @var string[] Additional variables
*/
protected array $vars = [];
protected array $vars;
/**
* @var ConvertFormat[] Formats to convert a collections into
*/
protected array $formats = [];
protected array $formats;
/**
* @var string Path to environment file
* @var string|null Path to environment file
*/
protected string $envFilepath = '';
protected ?string $envFilePath;
/**
* @return bool
* @param array $settings
*/
public static function fileExists(): bool
public function __construct()
{
return file_exists(self::$filepath);
$this->loadFromDefaults();
// foreach ($settings[AN::Directories] ?? [] as $path) {
// $this->addDirPath($path);
// }
//
// foreach ($settings[AN::Files] ?? [] as $path) {
// $this->addFilePath($path);
// }
//
// $this->setDevMode(!empty($settings[AN::DevMode]));
//
// $this->setPreserveOutput(!empty($settings[AN::PreserveOutput]));
//
// isset($settings[AN::Environment]) && $this->setEnvFilepath($settings[AN::Environment]);
//
// isset($settings[AN::Output]) && $this->setOutputPath($settings[AN::Output]);
//
// foreach ($settings->formats ?? [] as $format) {
// $this->addFormat(ConvertFormat::fromArg($format));
// }
//
// foreach ($settings[AN::Vars] ?? [] as $name => $value) {
// $this[AN::Vars][$name] = $value;
// }
}
/**
* @return self
* @throws IncorrectSettingsFileException
* Loads settings from file
*
* @param string|null $filePath
* @return void
* @throws Exception
*/
public function loadFromFile(?string $filePath = null): void
{
if (is_null($filePath)) {
$filePath = sprintf('%s%spm-convert-settings.json', $_SERVER['PWD'], DS);
}
$filePath = trim($filePath);
if (!file_exists($filePath)) {
throw new Exception("file does not exist: $filePath");
}
if (!is_file($filePath)) {
throw new Exception("not a file: $filePath");
}
if (!is_readable($filePath)) {
throw new Exception("not a readable file: $filePath");
}
$content = file_get_contents($filePath);
$settings = json_decode($content ?: '{}', true, JSON_THROW_ON_ERROR);
$this->setFromArray($settings);
$this->filePath = $filePath;
}
/**
* Rewrites some defined settings with new values
*
* @param array $settings
* @return void
* @throws JsonException
*/
public static function init(): self
public function override(array $settings): void
{
$content = '{}';
self::$filepath = sprintf('%s%spm-convert-settings.json', $_SERVER['PWD'], DS);
if (self::fileExists()) {
$content = trim(file_get_contents(self::$filepath));
$settings = array_replace_recursive($this->__serialize(), $settings);
$this->setFromArray($settings);
}
try {
$settings = json_decode($content ?: '{}', flags: JSON_THROW_ON_ERROR);
} catch (JsonException $e) {
throw new IncorrectSettingsFileException('Incorrect settings file: ' . $e->getMessage(), $e->getCode());
/**
* Loads settings with default values
*
* @return void
* @throws JsonException
*/
public function loadFromDefaults(): void
{
$this->setFromArray(self::defaults());
}
return new self($settings);
/**
* Returns default settings values
*
* @return array
*/
public static function defaults(?string $key = null): mixed
{
$values = [
AN::Config => null,
AN::Directories => [],
AN::Files => [],
AN::Environment => null,
AN::Output => null,
AN::PreserveOutput => false,
AN::Formats => ['http'],
AN::Vars => [],
AN::DevMode => false,
AN::Verbose => false,
];
return $key ? $values[$key] : $values;
}
/**
* Set settings from array
*
* @param array $settings
* @return void
* @throws JsonException
*/
protected function setFromArray(array $settings): void
{
foreach ($settings[AN::Directories] ?? self::defaults(AN::Directories) as $path) {
$this->addDirPath($path);
}
foreach ($settings[AN::Files] ?? self::defaults(AN::Files) ?? [] as $path) {
$this->addFilePath($path);
}
$this->setEnvFilePath($settings[AN::Environment] ?? self::defaults(AN::Environment));
$this->setOutputPath($settings[AN::Output] ?? self::defaults(AN::Output));
$this->setPreserveOutput($settings[AN::PreserveOutput] ?? self::defaults(AN::PreserveOutput));
foreach ($settings[AN::Formats] ?? self::defaults(AN::Formats) as $format) {
$this->addFormat(ConvertFormat::fromArg($format));
}
$this->vars = $settings[AN::Vars] ?? self::defaults(AN::Vars);
$this->setDevMode($settings[AN::DevMode] ?? self::defaults(AN::DevMode));
}
/**
* Checks wether settings file exists or not
*
* @return bool
*/
public function fileExists(): bool
{
return is_file($this->filePath)
&& is_readable($this->filePath)
&& is_writable($this->filePath);
}
/**
@ -92,77 +218,65 @@ class Settings
*
* @return string
*/
public static function filepath(): string
public function filePath(): string
{
return self::$filepath;
}
/**
* @param object $settings
* @throws JsonException
*/
protected function __construct(object $settings)
{
foreach ($settings->directories ?? [] as $path) {
$this->addDirPath($path);
}
foreach ($settings->files ?? [] as $path) {
$this->addFilePath($path);
}
$this->setDevMode(!empty($settings->devMode));
$this->setPreserveOutput(!empty($settings->preserveOutput));
isset($settings->environment) && $this->setEnvFilepath($settings->environment);
isset($settings->output) && $this->setOutputPath($settings->output);
foreach ($settings->formats ?? [] as $format) {
$this->addFormat(ConvertFormat::fromArg($format));
}
foreach ($settings->vars ?? [] as $name => $value) {
$this->vars[$name] = $value;
}
return $this->filePath;
}
/**
* Adds directory path into current settings array and fills files array with its content
*
* @param string $path
* @return void
* @throws JsonException
*/
public function addDirPath(string $path): void
{
$this->directories = array_unique(array_merge(
$this->directories ?? [],
$this->dirPaths = array_unique(array_merge(
$this->dirPaths ?? [],
[FileSystem::normalizePath($path)]
));
$files = array_filter(
FileSystem::dirContents($path),
static fn ($filename) => FileSystem::isCollectionFile($filename)
);
$this->collectionPaths = array_unique(array_merge($this->collectionPaths ?? [], $files));
}
/**
* Adds collection file into current settings array
*
* @param string $path
* @return void
* @throws JsonException
*/
public function addFilePath(string $path): void
{
$normpath = FileSystem::normalizePath($path);
if (!FileSystem::isCollectionFile($normpath)) {
$normPath = FileSystem::normalizePath($path);
if (!FileSystem::isCollectionFile($normPath)) {
throw new InvalidArgumentException("not a valid collection: $path");
}
in_array($path, $this->collectionPaths) || $this->collectionPaths[] = $path;
}
/**
* @param string $outputPath
* Sets output directory path
*
* @param string|null $outputPath
* @return void
*/
public function setOutputPath(string $outputPath): void
public function setOutputPath(?string $outputPath): void
{
$this->outputPath = $outputPath;
}
/**
* Sets developer mode setting
*
* @param bool $devMode
* @return void
*/
@ -172,6 +286,8 @@ class Settings
}
/**
* Adds a format to convert to into current settings array
*
* @param ConvertFormat $format
* @return void
*/
@ -191,6 +307,8 @@ class Settings
}
/**
* Sets a setting responsible for saving old convertion results
*
* @param bool $preserveOutput
* @return void
*/
@ -200,15 +318,21 @@ class Settings
}
/**
* @param string $filepath
* Sets environment filepath setting
*
* @param string|null $filepath
* @return void
*/
public function setEnvFilepath(string $filepath): void
public function setEnvFilePath(?string $filepath): void
{
$this->envFilepath = FileSystem::normalizePath($filepath);
$this->envFilePath = is_string($filepath)
? FileSystem::normalizePath($filepath)
: $filepath;
}
/**
* Returns current value of developer mode setting
*
* @return bool
*/
public function isDevMode(): bool
@ -217,6 +341,8 @@ class Settings
}
/**
* Returns current value of collection files setting
*
* @return string[]
*/
public function collectionPaths(): array
@ -225,6 +351,8 @@ class Settings
}
/**
* Returns current value of output directory path setting
*
* @return string
*/
public function outputPath(): string
@ -233,6 +361,8 @@ class Settings
}
/**
* Returns current value of preserve output setting
*
* @return bool
*/
public function isPreserveOutput(): bool
@ -241,6 +371,8 @@ class Settings
}
/**
* Returns current convert formats
*
* @return ConvertFormat[]
*/
public function formats(): array
@ -249,11 +381,13 @@ class Settings
}
/**
* Returns current value of environment filepath setting
*
* @return string
*/
public function envFilepath(): string
{
return $this->envFilepath;
return $this->envFilePath;
}
/**
@ -264,17 +398,17 @@ class Settings
public function __serialize(): array
{
return [
'dev' => $this->isDevMode(),
'directories' => $this->directories,
'files' => $this->collectionPaths(),
'environment' => $this->envFilepath(),
'output' => $this->outputPath(),
'preserve-output' => $this->isPreserveOutput(),
'formats' => array_values(array_map(
AN::DevMode => $this->isDevMode(),
AN::Directories => $this->dirPaths,
AN::Files => $this->collectionPaths(),
AN::Environment => $this->envFilepath(),
AN::Output => $this->outputPath(),
AN::PreserveOutput => $this->isPreserveOutput(),
AN::Formats => array_values(array_map(
static fn (ConvertFormat $format) => $format->toArg(),
$this->formats(),
)),
'vars' => $this->vars,
AN::Vars => $this->vars,
];
}
@ -307,7 +441,8 @@ class Settings
*/
public function backup(): string
{
copy(self::$filepath, $newfilepath = self::$filepath . '.bak.' . time());
return $newfilepath;
$newFilePath = $this->filePath() . '.bak.' . time();
copy($this->filePath(), $newFilePath);
return $newFilePath;
}
}

4
tests/AbstractRequestTest.php
View File

@ -10,7 +10,7 @@ class AbstractRequestTest extends TestCase
{
/**
* @covers PmConverter\Converters\Abstract\AbstractRequest
* @covers PmConverter\HttpVersion
* @covers \PmConverter\Enums\HttpVersion
* @return void
* @throws InvalidHttpVersionException
*/
@ -25,7 +25,7 @@ class AbstractRequestTest extends TestCase
/**
* @covers PmConverter\Converters\Abstract\AbstractRequest
* @covers PmConverter\Converters\Abstract\AbstractRequest::getVerb()
* @covers PmConverter\HttpVersion
* @covers \PmConverter\Enums\HttpVersion
* @return void
* @throws InvalidHttpVersionException
*/