Merge pull request 'v1.5.1' (#14 ) from dev into master

Reviewed-on: #14
Merge pull request 'v1.4.1' (#13 ) from dev into master
2023-09-17 16:42:40 +00:00 · 2023-09-10 07:59:00 +00:00 · 2023-09-10 07:32:27 +00:00
22 changed files with 332 additions and 929 deletions
--- a/README.md
+++ b/README.md
@ -8,17 +8,14 @@ Without 3rd-party dependencies.

 These formats are supported for now: `http`, `curl`, `wget`.

-> This project has been started and quickly written in my spare time to solve one exact problem in one NDA-project,
-> so it may contain stupid errors and (for sure) doesn't cover all possible cases according to collection schema.
-> Feel free to propose your improvements.
-
-Versions older than the latest are not supported, only current one is.
-If you found an error in old version please ensure if an error you found has been fixed in latest version.
-So please always use the latest version of `pm-convert`.
+> This project was quickly written in my spare time to solve one exact problem in one NDA-project, so it may
+> contain stupid errors and (for sure) doesn't cover all possible cases according to collection schema.
+> So feel free to propose your improvements.

 ## Supported features

-* collection schemas [**v2.1**](https://schema.postman.com/json/collection/v2.1.0/collection.json) and [**v2.0**](https://schema.postman.com/json/collection/v2.0.0/collection.json);
+* [collection schema **v2.1**](https://schema.postman.com/json/collection/v2.1.0/collection.json);
+* `Bearer` auth;
 * replace vars in requests by stored in collection and environment file;
 * export one or several collections (or even whole directories) into one or all of formats supported at the same time;
 * all headers (including disabled for `http`-format);
@ -28,7 +25,7 @@ So please always use the latest version of `pm-convert`.
 ## Planned features

 - support as many as possible/necessary of authentication kinds (_currently only `Bearer` supported_);
- support as many as possible/necessary of body formats (_currently only `json` and `formdata` supported_);
+- support as many as possible/necessary of body formats (_currently only `json` and `formdata`_);
 - documentation generation support (markdown) with response examples (if present) (#6);
 - maybe some another convert formats (like httpie or something...);
 - better logging;
@ -68,7 +65,6 @@ Possible ARGUMENTS:
        -e, --env           - use environment file with variables to replace in requests
        --var "NAME=VALUE"  - force replace specified env variable called NAME with custom VALUE
        -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

@ -138,62 +134,6 @@ In such case collection itself places in single root object called `collection`

 So, pm-convert will just raise actual data up on top level and write into disk.

-## Settings file
-
-You may want to specify parameters once and just use them everytime without explicit defining arguments to `pm-convert`.
-
-This might be done in several ways.
-
-1. Save this file as `pm-convert-settings.json` in your project directory:
-
-   ```json
-   {
-       "directories": [],
-       "files": [],
-       "environment": "",
-       "output": "",
-       "preserveOutput": false,
-       "formats": [],
-       "vars": {}
-   }
-   ```
-   
-   Fill it with values you need.
-
-2. Add `--dump` at the end of your command and all arguments you provided will be converted and saved as
-   `pm-convert-settings.json` in your curent working directory. For example in `--help` file will contain this:
-
-   ```json
-   {
-       "directories": [
-           "~/team",
-           "~/personal"
-       ],
-       "files": [
-           "~/dir1/first.postman_collection.json",
-           "~/dir2/second.postman_collection.json"
-       ],
-       "environment": "~/localhost.postman_environment.json",
-       "output": "~/postman_export",
-       "preserveOutput": false,
-       "formats": [
-           "http",
-           "curl",
-           "wget",
-           "v2.0",
-           "v2.1"
-       ],
-       "vars": {
-           "myvar": "some value"
-       }
-   }
-   ```
-
-   If settings file already exists then you will be asked what to do: overwrite it, back it up or exit.
-
-Once settings file saved in current you can just run `pm-convert`.
-Settings will be applied like if you pass them explicitly via arguments.
-
 ## How to implement a new format

 1. Create new namespace in `./src/Converters` and name it according to format of your choice.
--- a/composer.json
+++ b/composer.json
@ -14,8 +14,7 @@
    "require": {
        "php": "^8.1",
        "ext-json": "*",
-        "ext-mbstring": "*",
-        "ext-readline": "*"
+        "ext-mbstring": "*"
    },
    "bin": ["pm-convert"],
    "autoload": {
--- a/10
+++ b/10
@ -2,8 +2,6 @@
 <?php

 declare(strict_types=1);
-const EOL = PHP_EOL;
-const DS = DIRECTORY_SEPARATOR;

 use PmConverter\Processor;

@ -24,12 +22,12 @@ is_null($file) && throw new RuntimeException('Unable to locate autoload.php file

 $processor = new Processor($argv);
 try {
-    $processor->handle();
+    $processor->convert();
 } catch (InvalidArgumentException $e) {
-    fwrite(STDERR, sprintf('ERROR: %s%s', $e->getMessage(), EOL));
-    print(implode(EOL, Processor::usage()));
+    fwrite(STDERR, sprintf('ERROR: %s%s', $e->getMessage(), PHP_EOL));
+    print(implode(PHP_EOL, $processor->usage()));
    die(1);
 } catch (Exception $e) {
-    fwrite(STDERR, sprintf('ERROR: %s%s', $e->getMessage(), EOL));
+    fwrite(STDERR, sprintf('ERROR: %s%s', $e->getMessage(), PHP_EOL));
    die(1);
 }
--- a/src/Collection.php
+++ b/src/Collection.php
@ -4,8 +4,6 @@ declare(strict_types = 1);

 namespace PmConverter;

-use Exception;
-use Generator;
 use JsonException;
 use Stringable;

@ -18,8 +16,6 @@ use Stringable;
 */
 class Collection implements Stringable
 {
-    public readonly CollectionVersion $version;
-
    /**
     * Closed constructor so that we could use factory methods
     *
@ -28,11 +24,10 @@ class Collection implements Stringable
    private function __construct(protected object $json)
    {
        // specific case when collection has been exported via postman api
-        if (property_exists($json, 'collection')) {
+        if (isset($json->collection)) {
            $json = $json->collection;
        }
        $this->json = $json;
-        $this->version = $this->detectVersion();
    }

    /**
@ -93,7 +88,7 @@ class Collection implements Stringable
     *
     * @return CollectionVersion
     */
-    protected function detectVersion(): CollectionVersion
+    public function version(): CollectionVersion
    {
        return match (true) {
            str_contains($this->json->info->schema, '/v2.0.') => CollectionVersion::Version20,
@ -101,72 +96,4 @@ class Collection implements Stringable
            default => CollectionVersion::Unknown
        };
    }
-
-    /**
-     * Returns the collection version from raw file
-     *
-     * @param string $filepath
-     * @return CollectionVersion
-     * @throws Exception
-     */
-    public static function detectFileVersion(string $filepath): CollectionVersion
-    {
-        $handle = fopen($filepath, 'r');
-        if ($handle === false) {
-            throw new Exception("Cannot open file for reading: $filepath");
-        }
-        $content = '';
-        // Postman collection files may be HUGE and I don't need to parse
-        // them here to find value .info.schema field because normally it
-        // is stored at the beginning of a file, so if it's not then this
-        // is a user problem, not mine.
-        while (\mb_strlen($content) <= 2048) {
-            $content .= fgets($handle, 50);
-            if (str_contains($content, 'https://schema.getpostman.com/json/collection')) {
-                if (str_contains($content, '/v2.0.')) {
-                    return CollectionVersion::Version20;
-                }
-                if (str_contains($content, '/v2.1.')) {
-                    return CollectionVersion::Version21;
-                }
-            }
-        }
-        return CollectionVersion::Unknown;
-    }
-
-    /**
-     * Iterates over collection request items and returns item associated by its path in folder
-     *
-     * @param mixed|null $item
-     * @return Generator
-     */
-    public function iterate(mixed $item = null): Generator
-    {
-        $is_recursive = !is_null($item);
-        $folder = $is_recursive ? $item : $this->json;
-        static $dir_tree;
-        $path = DS . ($is_recursive ? implode(DS, $dir_tree ?? []) : '');
-        foreach ($folder->item as $subitem) {
-            if ($this->isItemFolder($subitem)) {
-                $dir_tree[] = $subitem->name;
-                yield from $this->iterate($subitem);
-                continue;
-            }
-            yield $path => $subitem;
-        }
-        $is_recursive && array_pop($dir_tree);
-    }
-
-    /**
-     * Checks whether item contains another items or not
-     *
-     * @param object $item
-     * @return bool
-     */
-    protected function isItemFolder(object $item): bool
-    {
-        return !empty($item->item)
-            && is_array($item->item)
-            && empty($item->request);
-    }
 }
--- a/src/Converters/Abstract/AbstractConverter.php
+++ b/src/Converters/Abstract/AbstractConverter.php
@ -5,19 +5,21 @@ declare(strict_types=1);
 namespace PmConverter\Converters\Abstract;

 use Exception;
-use Iterator;
 use PmConverter\Collection;
-use PmConverter\Converters\RequestContract;
+use PmConverter\Converters\{
+    ConverterContract,
+    RequestContract};
 use PmConverter\Environment;
-use PmConverter\Exceptions\CannotCreateDirectoryException;
-use PmConverter\Exceptions\DirectoryIsNotWriteableException;
-use PmConverter\Exceptions\InvalidHttpVersionException;
+use PmConverter\Exceptions\{
+    CannotCreateDirectoryException,
+    DirectoryIsNotWriteableException,
+    InvalidHttpVersionException};
 use PmConverter\FileSystem;

 /**
 *
 */
-abstract class AbstractConverter
+abstract class AbstractConverter implements ConverterContract
 {
    /**
     * @var Collection|null
@ -30,66 +32,53 @@ abstract class AbstractConverter
    protected string $outputPath;

    /**
-     * @var RequestContract[] Converted requests
+     * @var Environment|null
     */
-    protected array $requests = [];
+    protected ?Environment $env = null;

    /**
-     * Sets output path
+     * Sets an environment with vars
     *
-     * @param string $outputPath
+     * @param Environment $env
     * @return $this
     */
-    public function to(string $outputPath): self
+    public function withEnv(Environment $env): static
    {
-        $this->outputPath = sprintf('%s%s%s', $outputPath, DS, static::OUTPUT_DIR);
+        $this->env = $env;
        return $this;
    }

    /**
-     * Converts requests from collection
+     * Creates a new directory to save a converted collection into
+     *
+     * @param string $outputPath
+     * @return void
+     * @throws CannotCreateDirectoryException
+     * @throws DirectoryIsNotWriteableException
+     */
+    protected function prepareOutputDir(string $outputPath): void
+    {
+        $outputPath = sprintf('%s%s%s', $outputPath, DIRECTORY_SEPARATOR, static::OUTPUT_DIR);
+        $this->outputPath = FileSystem::makeDir($outputPath);
+    }
+
+    /**
+     * Converts collection requests
     *
     * @param Collection $collection
-     * @return static
+     * @param string $outputPath
+     * @return void
     * @throws CannotCreateDirectoryException
     * @throws DirectoryIsNotWriteableException
     * @throws Exception
     */
-    public function convert(Collection $collection): static
+    public function convert(Collection $collection, string $outputPath): void
    {
+        $this->prepareOutputDir($outputPath);
        $this->collection = $collection;
-        $this->outputPath = FileSystem::makeDir($this->outputPath);
-        $this->setCollectionVars();
-        foreach ($collection->iterate() as $path => $item) {
-            // $this->requests[$path][] = $this->makeRequest($item);
-            $this->writeRequest($this->makeRequest($item), $path);
-        }
-        return $this;
-    }
-
-    /**
-     * Returns converted requests
-     *
-     * @return Iterator<string, RequestContract>
-     */
-    public function converted(): Iterator
-    {
-        foreach ($this->requests as $path => $requests) {
-            foreach ($requests as $request) {
-                yield $path => $request;
-            }
-        }
-    }
-
-    /**
-     * Writes requests on disk
-     *
-     * @throws Exception
-     */
-    public function flush(): void
-    {
-        foreach ($this->converted() as $path => $request) {
-            $this->writeRequest($request, $path);
+        $this->setVariables();
+        foreach ($collection->item as $item) {
+            $this->convertItem($item);
        }
    }

@ -98,10 +87,13 @@ abstract class AbstractConverter
     *
     * @return $this
     */
-    protected function setCollectionVars(): static
+    protected function setVariables(): static
    {
-        foreach ($this->collection?->variable ?? [] as $var) {
-            Environment::instance()->setCustomVar($var->key, $var->value);
+        empty($this->env) && $this->env = new Environment($this->collection?->variable);
+        if (!empty($this->collection?->variable)) {
+            foreach ($this->collection->variable as $var) {
+                $this->env[$var->key] = $var->value;
+            }
        }
        return $this;
    }
@ -129,6 +121,30 @@ abstract class AbstractConverter
            && empty($item->request);
    }

+    /**
+     * Converts an item to request object and writes it into file
+     *
+     * @throws Exception
+     */
+    protected function convertItem(mixed $item): void
+    {
+        if ($this->isItemFolder($item)) {
+            static $dir_tree;
+            foreach ($item->item as $subitem) {
+                $dir_tree[] = $item->name;
+                $path = implode(DIRECTORY_SEPARATOR, $dir_tree);
+                if ($this->isItemFolder($subitem)) {
+                    $this->convertItem($subitem);
+                } else {
+                    $this->writeRequest($this->initRequest($subitem), $path);
+                }
+                array_pop($dir_tree);
+            }
+        } else {
+            $this->writeRequest($this->initRequest($item));
+        }
+    }
+
    /**
     * Initialiazes request object to be written in file
     *
@ -136,18 +152,17 @@ abstract class AbstractConverter
     * @return RequestContract
     * @throws InvalidHttpVersionException
     */
-    protected function makeRequest(object $item): RequestContract
+    protected function initRequest(object $item): RequestContract
    {
        $request_class = static::REQUEST_CLASS;

        /** @var RequestContract $request */
        $request = new $request_class();
        $request->setName($item->name);
-        $request->setVersion($this->collection->version);
        $request->setHttpVersion(1.1); //TODO http version?
        $request->setDescription($item->request?->description ?? null);
        $request->setVerb($item->request->method);
-        $request->setUrl($item->request->url);
+        $request->setUrl($item->request->url->raw);
        $request->setHeaders($item->request->header);
        $request->setAuth($item->request?->auth ?? $this->collection?->auth ?? null);
        if ($item->request->method !== 'GET' && !empty($item->request->body)) {
@ -166,9 +181,9 @@ abstract class AbstractConverter
     */
    protected function writeRequest(RequestContract $request, string $subpath = null): bool
    {
-        $filedir = sprintf('%s%s%s', $this->outputPath, DS, $subpath);
+        $filedir = sprintf('%s%s%s', $this->outputPath, DIRECTORY_SEPARATOR, $subpath);
        $filedir = FileSystem::makeDir($filedir);
-        $filepath = sprintf('%s%s%s.%s', $filedir, DS, $request->getName(), static::FILE_EXT);
+        $filepath = sprintf('%s%s%s.%s', $filedir, DIRECTORY_SEPARATOR, $request->getName(), static::FILE_EXT);
        $content = $this->interpolate((string)$request);
        return file_put_contents($filepath, $content) > 0;
    }
@ -181,9 +196,18 @@ abstract class AbstractConverter
     */
    protected function interpolate(string $content): string
    {
-        $replace = static fn ($a) => Environment::instance()->var($var = $a[0]) ?: $var;
-        return Environment::instance()->hasVars()
-            ? preg_replace_callback('/\{\{.*}}/m', $replace, $content)
-            : $content;
+        if (!$this->env?->hasVars()) {
+            return $content;
+        }
+        $matches = [];
+        if (preg_match_all('/\{\{.*}}/m', $content, $matches, PREG_PATTERN_ORDER) > 0) {
+            foreach ($matches[0] as $key => $var) {
+                if (str_contains($content, $var)) {
+                    $content = str_replace($var, $this->env[$var] ?: $var, $content);
+                    unset($matches[0][$key]);
+                }
+            }
+        }
+        return $content;
    }
 }
--- a/src/Converters/Abstract/AbstractRequest.php
+++ b/src/Converters/Abstract/AbstractRequest.php
@ -4,10 +4,10 @@ declare(strict_types=1);

 namespace PmConverter\Converters\Abstract;

-use PmConverter\CollectionVersion;
 use PmConverter\Converters\RequestContract;
-use PmConverter\Exceptions\EmptyHttpVerbException;
-use PmConverter\Exceptions\InvalidHttpVersionException;
+use PmConverter\Exceptions\{
+    EmptyHttpVerbException,
+    InvalidHttpVersionException};
 use PmConverter\HttpVersion;
 use Stringable;

@ -22,9 +22,9 @@ abstract class AbstractRequest implements Stringable, RequestContract
    protected string $verb;

    /**
-     * @var object|string URL where to send a request
+     * @var string URL where to send a request
     */
-    protected object|string $url;
+    protected string $url;

    /**
     * @var float HTTP protocol version
@ -56,15 +56,6 @@ abstract class AbstractRequest implements Stringable, RequestContract
     */
    protected string $bodymode = 'raw';

-
-    protected CollectionVersion $version;
-
-    public function setVersion(CollectionVersion $version): static
-    {
-        $this->version = $version;
-        return $this;
-    }
-
    /**
     * @inheritDoc
     */
@ -101,7 +92,7 @@ abstract class AbstractRequest implements Stringable, RequestContract
     */
    public function getName(): string
    {
-        return str_replace(DS, '_', $this->name);
+        return str_replace(DIRECTORY_SEPARATOR, '_', $this->name);
    }

    /**
@ -142,7 +133,7 @@ abstract class AbstractRequest implements Stringable, RequestContract
    /**
     * @inheritDoc
     */
-    public function setUrl(object|string $url): static
+    public function setUrl(string $url): static
    {
        $this->url = $url;
        return $this;
@ -151,9 +142,9 @@ abstract class AbstractRequest implements Stringable, RequestContract
    /**
     * @inheritDoc
     */
-    public function getRawUrl(): string
+    public function getUrl(): string
    {
-        return is_object($this->url) ? $this->url->raw : $this->url;
+        return $this->url ?: '<empty url>';
    }

    /**
@ -195,11 +186,7 @@ abstract class AbstractRequest implements Stringable, RequestContract
        if (!empty($auth)) {
            switch ($auth->type) {
                case 'bearer':
-                    $this->setHeader('Authorization', 'Bearer ' . match ($this->version) {
-                        CollectionVersion::Version20 => $auth->{$auth->type}->token,
-                        CollectionVersion::Version21 => $auth->{$auth->type}[0]->value,
-                        default => null
-                    });
+                    $this->setHeader('Authorization', 'Bearer ' . $auth->{$auth->type}[0]->value);
                    break;
                default:
                    break;
--- a/src/Converters/ConvertFormat.php
+++ b/src/Converters/ConvertFormat.php
@ -5,11 +5,12 @@ declare(strict_types=1);
 namespace PmConverter\Converters;


-use PmConverter\Converters\Curl\CurlConverter;
-use PmConverter\Converters\Http\HttpConverter;
-use PmConverter\Converters\Postman20\Postman20Converter;
-use PmConverter\Converters\Postman21\Postman21Converter;
-use PmConverter\Converters\Wget\WgetConverter;
+use PmConverter\Converters\{
+    Curl\CurlConverter,
+    Http\HttpConverter,
+    Postman20\Postman20Converter,
+    Postman21\Postman21Converter,
+    Wget\WgetConverter};

 enum ConvertFormat: string
 {
@ -18,26 +19,4 @@ enum ConvertFormat: string
    case Wget = WgetConverter::class;
    case Postman20 = Postman20Converter::class;
    case Postman21 = Postman21Converter::class;
-
-    public static function fromArg(string $arg): self
-    {
-        return match ($arg) {
-            'http' => ConvertFormat::Http,
-            'curl' => ConvertFormat::Curl,
-            'wget' => ConvertFormat::Wget,
-            'v2.0' => ConvertFormat::Postman20,
-            'v2.1' => ConvertFormat::Postman21,
-        };
-    }
-
-    public function toArg(): string
-    {
-        return match ($this) {
-            ConvertFormat::Http => 'http',
-            ConvertFormat::Curl => 'curl',
-            ConvertFormat::Wget => 'wget',
-            ConvertFormat::Postman20 => 'v2.0',
-            ConvertFormat::Postman21 => 'v2.1',
-        };
-    }
 }
--- a/src/Converters/Curl/CurlConverter.php
+++ b/src/Converters/Curl/CurlConverter.php
@ -4,9 +4,11 @@ declare(strict_types=1);

 namespace PmConverter\Converters\Curl;

-use PmConverter\Converters\Abstract\AbstractConverter;
+use PmConverter\Converters\{
+    Abstract\AbstractConverter,
+    ConverterContract};

-class CurlConverter extends AbstractConverter
+class CurlConverter extends AbstractConverter implements ConverterContract
 {
    protected const FILE_EXT = 'sh';

--- a/src/Converters/Curl/CurlRequest.php
+++ b/src/Converters/Curl/CurlRequest.php
@ -72,12 +72,12 @@ class CurlRequest extends AbstractRequest
                "curl \ ",
                "\t--http1.1 \ ", //TODO proto
                "\t--request $this->verb \ ",
-                "\t--location {$this->getRawUrl()} \ ",
+                "\t--location $this->url \ ",
            ],
            $this->prepareHeaders(),
            $this->prepareBody()
        );
        $output[] = rtrim(array_pop($output), '\ ');
-        return implode(EOL, array_merge($output, ['']));
+        return implode(PHP_EOL, array_merge($output, ['']));
    }
 }
--- a/src/Converters/Http/HttpConverter.php
+++ b/src/Converters/Http/HttpConverter.php
@ -4,9 +4,11 @@ declare(strict_types=1);

 namespace PmConverter\Converters\Http;

-use PmConverter\Converters\Abstract\AbstractConverter;
+use PmConverter\Converters\{
+    Abstract\AbstractConverter,
+    ConverterContract};

-class HttpConverter extends AbstractConverter
+class HttpConverter extends AbstractConverter implements ConverterContract
 {
    protected const FILE_EXT = 'http';

--- a/src/Converters/Http/HttpRequest.php
+++ b/src/Converters/Http/HttpRequest.php
@ -5,7 +5,8 @@ declare(strict_types=1);
 namespace PmConverter\Converters\Http;

 use PmConverter\Converters\Abstract\AbstractRequest;
-use PmConverter\Exceptions\EmptyHttpVerbException;
+use PmConverter\Exceptions\{
+    EmptyHttpVerbException};

 /**
 * Class to determine file content with http request format
@ -28,7 +29,7 @@ class HttpRequest extends AbstractRequest
     */
    protected function prepareHeaders(): array
    {
-        $output[] = sprintf('%s %s HTTP/%s', $this->getVerb(), $this->getRawUrl(), $this->getHttpVersion());
+        $output[] = sprintf('%s %s HTTP/%s', $this->getVerb(), $this->getUrl(), $this->getHttpVersion());
        foreach ($this->headers as $name => $data) {
            $output[] = sprintf('%s%s: %s', $data['disabled'] ? '# ' : '', $name, $data['value']);
        }
@ -68,6 +69,6 @@ class HttpRequest extends AbstractRequest
            $this->prepareHeaders(),
            $this->prepareBody()
        );
-        return implode(EOL, $output);
+        return implode(PHP_EOL, $output);
    }
 }
--- a/src/Converters/Postman20/Postman20Converter.php
+++ b/src/Converters/Postman20/Postman20Converter.php
@ -6,7 +6,9 @@ namespace PmConverter\Converters\Postman20;

 use PmConverter\Collection;
 use PmConverter\CollectionVersion;
-use PmConverter\Converters\Abstract\AbstractConverter;
+use PmConverter\Converters\{
+    Abstract\AbstractConverter,
+    ConverterContract};
 use PmConverter\Exceptions\CannotCreateDirectoryException;
 use PmConverter\Exceptions\DirectoryIsNotWriteableException;
 use PmConverter\FileSystem;
@ -14,7 +16,7 @@ use PmConverter\FileSystem;
 /**
 * Converts Postman Collection v2.1 to v2.0
 */
-class Postman20Converter extends AbstractConverter
+class Postman20Converter extends AbstractConverter implements ConverterContract
 {
    protected const FILE_EXT = 'v20.postman_collection.json';

@ -24,25 +26,25 @@ class Postman20Converter extends AbstractConverter
     * Converts collection requests
     *
     * @param Collection $collection
-     * @return static
+     * @param string $outputPath
+     * @return void
     * @throws CannotCreateDirectoryException
     * @throws DirectoryIsNotWriteableException
     */
-    public function convert(Collection $collection): static
+    public function convert(Collection $collection, string $outputPath): void
    {
        $this->collection = $collection;
        // if data was exported from API, here is already valid json to
        // just flush it in file, otherwise we need to convert it deeper
-        if ($this->collection->version === CollectionVersion::Version21) {
+        if ($this->collection->version() === CollectionVersion::Version21) {
            $this->collection->info->schema = str_replace('/v2.1.', '/v2.0.', $this->collection->info->schema);
            $this->convertAuth($this->collection->raw());
            foreach ($this->collection->item as $item) {
                $this->convertItem($item);
            }
        }
-        $this->outputPath = FileSystem::makeDir($this->outputPath);
+        $this->prepareOutputDir($outputPath);
        $this->writeCollection();
-        return $this;
    }

    /**
@ -55,7 +57,7 @@ class Postman20Converter extends AbstractConverter
    protected function writeCollection(): bool
    {
        $filedir = FileSystem::makeDir($this->outputPath);
-        $filepath = sprintf('%s%s%s.%s', $filedir, DS, $this->collection->name(), static::FILE_EXT);
+        $filepath = sprintf('%s%s%s.%s', $filedir, DIRECTORY_SEPARATOR, $this->collection->name(), static::FILE_EXT);
        return file_put_contents($filepath, $this->collection) > 0;
    }

@ -95,11 +97,11 @@ class Postman20Converter extends AbstractConverter
        if (empty($request->auth)) {
            return;
        }
-        $auth = ['type' => 'noauth'];
-        $type = strtolower($request->auth->type);
-        if ($type !== 'noauth') {
+        $type = $request->auth->type;
+        if ($type !== 'noauth' && is_array($request->auth->$type)) {
+            $auth = [];
            foreach ($request->auth->$type as $param) {
-                $auth[$param->key] = $param->value ?? '';
+                $auth[$param->key] = $param->value;
            }
            $request->auth->$type = (object)$auth;
        }
--- a/src/Converters/Postman21/Postman21Converter.php
+++ b/src/Converters/Postman21/Postman21Converter.php
@ -6,7 +6,9 @@ namespace PmConverter\Converters\Postman21;

 use PmConverter\Collection;
 use PmConverter\CollectionVersion;
-use PmConverter\Converters\Abstract\AbstractConverter;
+use PmConverter\Converters\{
+    Abstract\AbstractConverter,
+    ConverterContract};
 use PmConverter\Exceptions\CannotCreateDirectoryException;
 use PmConverter\Exceptions\DirectoryIsNotWriteableException;
 use PmConverter\FileSystem;
@ -14,7 +16,7 @@ use PmConverter\FileSystem;
 /**
 * Converts Postman Collection v2.0 to v2.1
 */
-class Postman21Converter extends AbstractConverter
+class Postman21Converter extends AbstractConverter implements ConverterContract
 {
    protected const FILE_EXT = 'v21.postman_collection.json';

@ -24,25 +26,25 @@ class Postman21Converter extends AbstractConverter
     * Converts collection requests
     *
     * @param Collection $collection
-     * @return static
+     * @param string $outputPath
+     * @return void
     * @throws CannotCreateDirectoryException
     * @throws DirectoryIsNotWriteableException
     */
-    public function convert(Collection $collection): static
+    public function convert(Collection $collection, string $outputPath): void
    {
        $this->collection = $collection;
        // if data was exported from API, here is already valid json to
        // just flush it in file, otherwise we need to convert it deeper
-        if ($this->collection->version === CollectionVersion::Version20) {
+        if ($this->collection->version() === CollectionVersion::Version20) {
            $this->collection->info->schema = str_replace('/v2.0.', '/v2.1.', $this->collection->info->schema);
            $this->convertAuth($this->collection->raw());
            foreach ($this->collection->item as $item) {
                $this->convertItem($item);
            }
        }
-        $this->outputPath = FileSystem::makeDir($this->outputPath);
+        $this->prepareOutputDir($outputPath);
        $this->writeCollection();
-        return $this;
    }

    /**
@ -55,7 +57,7 @@ class Postman21Converter extends AbstractConverter
    protected function writeCollection(): bool
    {
        $filedir = FileSystem::makeDir($this->outputPath);
-        $filepath = sprintf('%s%s%s.%s', $filedir, DS, $this->collection->name(), static::FILE_EXT);
+        $filepath = sprintf('%s%s%s.%s', $filedir, DIRECTORY_SEPARATOR, $this->collection->name(), static::FILE_EXT);
        return file_put_contents($filepath, $this->collection) > 0;
    }

--- a/src/Converters/RequestContract.php
+++ b/src/Converters/RequestContract.php
@ -86,7 +86,7 @@ interface RequestContract
     *
     * @return string
     */
-    public function getRawUrl(): string;
+    public function getUrl(): string;

    /**
     * Sets headers from collection item to request object
@ -116,7 +116,7 @@ interface RequestContract
    /**
     * Sets authorization headers
     *
-     * @param object $auth
+     * @param object|null $auth
     * @return $this
     */
    public function setAuth(object $auth): static;
--- a/src/Converters/Wget/WgetConverter.php
+++ b/src/Converters/Wget/WgetConverter.php
@ -4,9 +4,11 @@ declare(strict_types=1);

 namespace PmConverter\Converters\Wget;

-use PmConverter\Converters\Abstract\AbstractConverter;
+use PmConverter\Converters\{
+    Abstract\AbstractConverter,
+    ConverterContract};

-class WgetConverter extends AbstractConverter
+class WgetConverter extends AbstractConverter implements ConverterContract
 {
    protected const FILE_EXT = 'sh';

--- a/src/Converters/Wget/WgetRequest.php
+++ b/src/Converters/Wget/WgetRequest.php
@ -77,18 +77,18 @@ class WgetRequest extends AbstractRequest
        if ($this->getBodymode() === 'formdata') {
            if ($this->getBody()) {
                if ($this->getVerb() === 'GET') {
-                    $output[] = sprintf("\t%s?%s", $this->getRawUrl(), http_build_query($this->prepareBody()));
+                    $output[] = sprintf("\t%s?%s", $this->getUrl(), http_build_query($this->prepareBody()));
                } else {
                    $output[] = sprintf("\t--body-data '%s' \ ", http_build_query($this->prepareBody()));
-                    $output[] = sprintf("\t%s", $this->getRawUrl());
+                    $output[] = sprintf("\t%s", $this->getUrl());
                }
            }
        } else {
            if ($this->getVerb() !== 'GET') {
                $output[] = sprintf("\t--body-data '%s' \ ", implode("\n", $this->prepareBody()));
-                $output[] = sprintf("\t%s", $this->getRawUrl());
+                $output[] = sprintf("\t%s", $this->getUrl());
            }
        }
-        return implode(EOL, array_merge($output, ['']));
+        return implode(PHP_EOL, array_merge($output, ['']));
    }
 }
--- a/src/Environment.php
+++ b/src/Environment.php
@ -4,138 +4,23 @@ declare(strict_types=1);

 namespace PmConverter;

-use ArrayAccess;
-use JsonException;
-
-/**
- *
- */
-class Environment implements ArrayAccess
+class Environment implements \ArrayAccess
 {
-    /**
-     * @var string Path to env file
-     */
-    protected static string $filepath = '';
-
-    /**
-     * @var Environment
-     */
-    protected static Environment $instance;
-
    /**
     * @var array
     */
-    protected array $ownVars = [];
+    protected array $vars = [];

    /**
-     * @var array
+     * @param object|null $env
     */
-    protected array $customVars = [];
-
-    public static function instance(): static
+    public function __construct(protected ?object $env)
    {
-        return static::$instance ??= new static();
-    }
-
-    /**
-     * @param string $filepath
-     * @return $this
-     * @throws JsonException
-     */
-    public function readFromFile(string $filepath): static
-    {
-        $content = file_get_contents(static::$filepath = $filepath);
-        $content = json_decode($content, flags: JSON_THROW_ON_ERROR); //TODO try-catch
-        $content || throw new JsonException("not a valid environment: $filepath");
-        property_exists($content, 'environment') && $content = $content->environment;
-        if (!property_exists($content, 'id') && !property_exists($content, 'name')) {
-            throw new JsonException("not a valid environment: $filepath");
+        if (!empty($env->values)) {
+            foreach ($env->values as $var) {
+                $this->vars[static::formatKey($var->key)] = $var->value;
+            }
        }
-        return $this->setOwnVars($content->values);
-    }
-
-    /**
-     * @param array $vars
-     * @return $this
-     */
-    protected function setOwnVars(array $vars): static
-    {
-        foreach ($vars as $key => $value) {
-            is_object($value) && [$key, $value] = [$value->key, $value->value];
-            $this->setOwnVar($key, $value);
-        }
-        return $this;
-    }
-
-    /**
-     * Sets value to some environment own variable
-     *
-     * @param string $name
-     * @param string $value
-     * @return $this
-     */
-    protected function setOwnVar(string $name, string $value): static
-    {
-        $this->ownVars[static::formatKey($name)] = $value;
-        return $this;
-    }
-
-    /**
-     * @param array $vars
-     * @return $this
-     */
-    public function setCustomVars(array $vars): static
-    {
-        foreach ($vars as $key => $value) {
-            is_object($value) && [$key, $value] = [$value->key, $value->value];
-            $this->setCustomVar($key, $value);
-        }
-        return $this;
-    }
-
-    /**
-     * Sets value to some environment own variable
-     *
-     * @param string $name
-     * @param string $value
-     * @return $this
-     */
-    public function setCustomVar(string $name, string $value): static
-    {
-        $this->customVars[static::formatKey($name)] = $value;
-        return $this;
-    }
-
-    /**
-     * Returns value of specific variable
-     *
-     * @param string $name
-     * @return mixed
-     */
-    public function var(string $name): mixed
-    {
-        $format_key = static::formatKey($name);
-        return $this->ownVars[$format_key] ?? $this->customVars[$format_key] ?? null;
-    }
-
-    /**
-     * Returns array of own and custom variables
-     *
-     * @return string[]
-     */
-    public function vars(): array
-    {
-        return array_merge($this->ownVars, $this->customVars);
-    }
-
-    /**
-     * Returns array of custom variables
-     *
-     * @return string[]
-     */
-    public function customVars(): array
-    {
-        return $this->customVars;
    }

    /**
@ -145,35 +30,15 @@ class Environment implements ArrayAccess
     */
    public function hasVars(): bool
    {
-        return !empty($this->ownVars) && !empty($this->customVars);
+        return !empty($this->vars);
    }

-
-
-
-
-
-
-
-
-
-
-
-
-    /**
-     * Closed constructor
-     */
-    protected function __construct()
-    {
-    }
-
-
    /**
     * @inheritDoc
     */
    public function offsetExists(mixed $offset): bool
    {
-        return array_key_exists(static::formatKey($offset), $this->vars());
+        return array_key_exists(static::formatKey($offset), $this->vars);
    }

    /**
@ -181,7 +46,7 @@ class Environment implements ArrayAccess
     */
    public function offsetGet(mixed $offset): mixed
    {
-        return $this->var($offset);
+        return $this->vars[static::formatKey($offset)] ?? null;
    }

    /**
@ -189,7 +54,7 @@ class Environment implements ArrayAccess
     */
    public function offsetSet(mixed $offset, mixed $value): void
    {
-        $this->customVars[static::formatKey($offset)] = $value;
+        $this->vars[static::formatKey($offset)] = $value;
    }

    /**
@ -197,7 +62,7 @@ class Environment implements ArrayAccess
     */
    public function offsetUnset(mixed $offset): void
    {
-        unset($this->customVars[static::formatKey($offset)]);
+        unset($this->vars[static::formatKey($offset)]);
    }

    /**
--- a/src/Exceptions/IncorrectSettingsFileException.php
+++ b/src/Exceptions/IncorrectSettingsFileException.php
@ -1,11 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace PmConverter\Exceptions;
-
-use Exception;
-
-class IncorrectSettingsFileException extends Exception
-{
-}
--- a/src/FileSystem.php
+++ b/src/FileSystem.php
@ -4,12 +4,12 @@ declare(strict_types=1);

 namespace PmConverter;

-use Exception;
 use JsonException;
-use PmConverter\Exceptions\CannotCreateDirectoryException;
-use PmConverter\Exceptions\DirectoryIsNotReadableException;
-use PmConverter\Exceptions\DirectoryIsNotWriteableException;
-use PmConverter\Exceptions\DirectoryNotExistsException;
+use PmConverter\Exceptions\{
+    CannotCreateDirectoryException,
+    DirectoryIsNotReadableException,
+    DirectoryIsNotWriteableException,
+    DirectoryNotExistsException};

 /**
 * Helper class to work with files and directories
@ -24,8 +24,8 @@ class FileSystem
     */
    public static function normalizePath(string $path): string
    {
-        $path = str_replace('~/', "{$_SERVER['HOME']}/", $path);
-        return rtrim($path, DS);
+        $path = str_replace('~', $_SERVER['HOME'], $path);
+        return rtrim($path, DIRECTORY_SEPARATOR);
    }

    /**
@ -101,7 +101,7 @@ class FileSystem
        $path = static::normalizePath($path);
        $records = array_diff(@scandir($path) ?: [], ['.', '..']);
        foreach ($records as &$record) {
-            $record = sprintf('%s%s%s', $path, DS, $record);
+            $record = sprintf('%s%s%s', $path, DIRECTORY_SEPARATOR, $record);
        }
        return $records;
    }
@ -112,14 +112,13 @@ class FileSystem
     * @param string $path
     * @return bool
     * @throws JsonException
-     * @throws Exception
     */
    public static function isCollectionFile(string $path): bool
    {
-        return (!empty($path = static::normalizePath($path)))
+        return (!empty($path = trim(static::normalizePath($path))))
            && str_ends_with($path, '.postman_collection.json')
            && file_exists($path)
            && is_readable($path)
-            && Collection::detectFileVersion($path) !== CollectionVersion::Unknown;
+            && Collection::fromFile($path)->version() !== CollectionVersion::Unknown;
    }
 }
--- a/src/Processor.php
+++ b/src/Processor.php
@ -5,74 +5,88 @@ declare(strict_types=1);
 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;
-use PmConverter\Exceptions\DirectoryNotExistsException;
-use PmConverter\Exceptions\IncorrectSettingsFileException;
+use PmConverter\Converters\{
+    ConverterContract,
+    ConvertFormat};
+use PmConverter\Exceptions\{
+    CannotCreateDirectoryException,
+    DirectoryIsNotReadableException,
+    DirectoryIsNotWriteableException,
+    DirectoryNotExistsException};

-/**
- * Main class
- */
 class Processor
 {
    /**
     * Converter version
     */
-    public const VERSION = '1.6.0';
+    public const VERSION = '1.5.0';

    /**
-     * @var int Initial timestamp
+     * @var string[] Paths to collection files
     */
-    protected readonly int $initTime;
+    protected array $collectionPaths = [];

    /**
-     * @var int Initial RAM usage
+     * @var string Output path where to put results in
     */
-    protected readonly int $initRam;
+    protected string $outputPath;

    /**
-     * @var Settings Settings                               (lol)
+     * @var bool Flag to remove output directories or not before conversion started
     */
-    protected Settings $settings;
+    protected bool $preserveOutput = false;

    /**
-     * @var ConverterContract[] Converters will be used for conversion according to chosen formats
+     * @var string[] Additional variables
+     */
+    protected array $vars;
+
+    /**
+     * @var ConvertFormat[] Formats to convert a collections into
+     */
+    protected array $formats;
+
+    /**
+     * @var ConverterContract[] Converters will be used for conversion according to choosen formats
     */
    protected array $converters = [];

    /**
-     * @var bool Do we need to save settings file and exit or not?
+     * @var Collection[] Collections that will be converted into choosen formats
     */
-    protected bool $needDumpSettings = false;
+    protected array $collections = [];
+
+    /**
+     * @var int Initial timestamp
+     */
+    protected int $initTime;
+
+    /**
+     * @var int Initial RAM usage
+     */
+    protected int $initRam;
+
+    /**
+     * @var string Path to environment file
+     */
+    protected string $envFile;

    /**
     * @var Environment
     */
-    public Environment $env;
+    protected Environment $env;

    /**
     * Constructor
     *
     * @param array $argv Arguments came from cli
     */
-    public function __construct(protected readonly array $argv)
+    public function __construct(protected array $argv)
    {
        $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();
    }

    /**
@ -83,11 +97,21 @@ class Processor
     */
    protected function parseArgs(): void
    {
+        if (count($this->argv) < 2) {
+            die(implode(PHP_EOL, $this->usage()) . PHP_EOL);
+        }
        foreach ($this->argv as $idx => $arg) {
            switch ($arg) {
                case '-f':
                case '--file':
-                    $this->settings->addFilePath($this->argv[$idx + 1]);
+                    $rawpath = $this->argv[$idx + 1];
+                    $normpath = FileSystem::normalizePath($rawpath);
+                    if (!FileSystem::isCollectionFile($normpath)) {
+                        throw new InvalidArgumentException(
+                            sprintf("not a valid collection:%s\t%s %s", PHP_EOL, $arg, $rawpath)
+                        );
+                    }
+                    $this->collectionPaths[] = $this->argv[$idx + 1];
                    break;

                case '-o':
@ -95,7 +119,7 @@ class Processor
                    if (empty($this->argv[$idx + 1])) {
                        throw new InvalidArgumentException('-o is required');
                    }
-                    $this->settings->setOutputPath($this->argv[$idx + 1]);
+                    $this->outputPath = $this->argv[$idx + 1];
                    break;

                case '-d':
@ -103,123 +127,76 @@ class Processor
                    if (empty($this->argv[$idx + 1])) {
                        throw new InvalidArgumentException('a directory path is expected for -d (--dir)');
                    }
-                    $this->settings->addDirPath($this->argv[$idx + 1]);
+                    $rawpath = $this->argv[$idx + 1];
+                    $files = array_filter(
+                        FileSystem::dirContents($rawpath),
+                        static fn($filename) => FileSystem::isCollectionFile($filename)
+                    );
+                    $this->collectionPaths = array_unique(array_merge($this?->collectionPaths ?? [], $files));
                    break;

                case '-e':
                case '--env':
-                    $this->settings->setEnvFilepath($this->argv[$idx + 1]);
+                    $this->envFile = FileSystem::normalizePath($this->argv[$idx + 1]);
                    break;

                case '-p':
                case '--preserve':
-                    $this->settings->setPreserveOutput(true);
+                    $this->preserveOutput = true;
                    break;

                case '--http':
-                    $this->settings->addFormat(ConvertFormat::Http);
+                    $this->formats[ConvertFormat::Http->name] = ConvertFormat::Http;
                    break;

                case '--curl':
-                    $this->settings->addFormat(ConvertFormat::Curl);
+                    $this->formats[ConvertFormat::Curl->name] = ConvertFormat::Curl;
                    break;

                case '--wget':
-                    $this->settings->addFormat(ConvertFormat::Wget);
+                    $this->formats[ConvertFormat::Wget->name] = ConvertFormat::Wget;
                    break;

                case '--v2.0':
-                    $this->settings->addFormat(ConvertFormat::Postman20);
+                    $this->formats[ConvertFormat::Postman20->name] = ConvertFormat::Postman20;
                    break;

                case '--v2.1':
-                    $this->settings->addFormat(ConvertFormat::Postman21);
+                    $this->formats[ConvertFormat::Postman21->name] = ConvertFormat::Postman21;
                    break;

                case '-a':
                case '--all':
                    foreach (ConvertFormat::cases() as $format) {
-                        $this->settings->addFormat($format);
+                        $this->formats[$format->name] = $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;
+                    [$var, $value] = explode('=', trim($this->argv[$idx + 1]));
+                    $this->vars[$var] = $value;
                    break;

                case '-v':
                case '--version':
-                    die(implode(EOL, $this->version()) . EOL);
+                    die(implode(PHP_EOL, $this->version()) . PHP_EOL);

                case '-h':
                case '--help':
-                    die(implode(EOL, $this->usage()) . EOL);
+                    die(implode(PHP_EOL, $this->usage()) . PHP_EOL);
            }
        }
-        if (empty($this->settings->collectionPaths())) {
+        if (empty($this->collectionPaths)) {
            throw new InvalidArgumentException('there are no collections to convert');
        }
-        if (empty($this->settings->outputPath())) {
+        if (empty($this->outputPath)) {
            throw new InvalidArgumentException('-o is required');
        }
-        if (empty($this->settings->formats())) {
-            $this->settings->addFormat(ConvertFormat::Http);
+        if (empty($this->formats)) {
+            $this->formats = [ConvertFormat::Http->name => ConvertFormat::Http];
        }
    }

-    /**
-     * Handles input command
-     *
-     * @return void
-     * @throws CannotCreateDirectoryException
-     * @throws DirectoryIsNotReadableException
-     * @throws DirectoryIsNotWriteableException
-     * @throws DirectoryNotExistsException
-     * @throws JsonException
-     * @throws IncorrectSettingsFileException
-     */
-    public function handle(): 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
     *
@ -229,74 +206,96 @@ class Processor
     * @throws DirectoryNotExistsException
     * @throws DirectoryIsNotReadableException
     */
-    protected function prepareOutputDirectory(): void
+    protected function initOutputDirectory(): void
    {
-        if (!$this->settings->isPreserveOutput()) {
-            FileSystem::removeDir($this->settings->outputPath());
+        if (isset($this?->outputPath) && !$this->preserveOutput) {
+            FileSystem::removeDir($this->outputPath);
        }
-        FileSystem::makeDir($this->settings->outputPath());
+        FileSystem::makeDir($this->outputPath);
    }

    /**
-     * Initializes converters according to chosen formats
+     * Initializes converters according to choosen formats
     *
     * @return void
     */
    protected function initConverters(): void
    {
-        foreach ($this->settings->formats() as $type) {
-            $this->converters[$type->name] = new $type->value($this->settings->isPreserveOutput());
+        foreach ($this->formats as $type) {
+            $this->converters[$type->name] = new $type->value($this->preserveOutput);
        }
        unset($this->formats);
    }

    /**
-     * Generates collections from settings
+     * Initializes collection objects
     *
-     * @return Generator<Collection>
     * @throws JsonException
     */
-    protected function newCollection(): Generator
+    protected function initCollections(): void
    {
-        foreach ($this->settings->collectionPaths() as $collectionPath) {
-            yield Collection::fromFile($collectionPath);
+        foreach ($this->collectionPaths as $collectionPath) {
+            $collection = Collection::fromFile($collectionPath);
+            $this->collections[$collection->name()] = $collection;
        }
+        unset($this->collectionPaths, $content);
+    }
+
+    /**
+     * Initializes environment object
+     *
+     * @return void
+     * @throws JsonException
+     */
+    protected function initEnv(): void
+    {
+        if (!isset($this->envFile)) {
+            return;
+        }
+        $content = file_get_contents(FileSystem::normalizePath($this->envFile));
+        $content = json_decode($content, flags: JSON_THROW_ON_ERROR);
+        if (!property_exists($content, 'environment') || empty($content?->environment)) {
+            throw new JsonException("not a valid environment: $this->envFile");
+        }
+        $this->env = new Environment($content->environment);
+        foreach ($this->vars as $var => $value) {
+            $this->env[$var] = $value;
+        }
+        unset($this->vars, $this->envFile, $content, $var, $value);
    }

    /**
     * Begins a conversion
     *
-     * @throws JsonException
+     * @throws Exception
     */
    public function convert(): void
    {
-        $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) {
+        $this->parseArgs();
+        $this->initOutputDirectory();
+        $this->initConverters();
+        $this->initCollections();
+        $this->initEnv();
+        $count = count($this->collections);
+        $current = 0;
+        $success = 0;
+        print(implode(PHP_EOL, array_merge($this->version(), $this->copyright())) . PHP_EOL . PHP_EOL);
+        foreach ($this->collections as $collectionName => $collection) {
            ++$current;
-            printf("Converting '%s' (%d/%d):%s", $collection->name(), $current, $count, EOL);
-            foreach ($this->converters as $type => $converter) {
-                /** @var AbstractConverter $converter */
-                printf('> %s%s', strtolower($type), EOL);
-                $outputPath = sprintf('%s%s%s', $this->settings->outputPath(), DS, $collection->name());
-                try {
-                    $converter = $converter->to($outputPath);
-                    $converter = $converter->convert($collection);
-                    $converter->flush();
-                    printf('  OK: %s%s', $converter->getOutputPath(), EOL);
-                } 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());
-                    }
+            printf("Converting '%s' (%d/%d):%s", $collectionName, $current, $count, PHP_EOL);
+            foreach ($this->converters as $type => $exporter) {
+                printf('> %s%s', strtolower($type), PHP_EOL);
+                $outputPath = sprintf('%s%s%s', $this->outputPath, DIRECTORY_SEPARATOR, $collectionName);
+                if (!empty($this->env)) {
+                    $exporter->withEnv($this->env);
                }
+                $exporter->convert($collection, $outputPath);
+                printf('  OK: %s%s', $exporter->getOutputPath(), PHP_EOL);
            }
-            print(EOL);
+            print(PHP_EOL);
            ++$success;
        }
-        unset($this->converters, $type, $converter, $outputPath, $this->collections, $collectionName, $collection);
+        unset($this->converters, $type, $exporter, $outputPath, $this->collections, $collectionName, $collection);
        $this->printStats($success, $current);
    }

@ -316,25 +315,24 @@ class Processor
            $timeFmt = 'sec';
        }
        $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);
+        printf("Converted %d/%d in %.2f $timeFmt using up to %.2f MiB RAM%s", $success, $count, $time, $ram, PHP_EOL);
    }

    /**
     * @return string[]
     */
-    public static function version(): array
+    public function version(): array
    {
-        return ['Postman collection converter v' . self::VERSION];
+        return ["Postman collection converter v" . self::VERSION];
    }

    /**
     * @return string[]
     */
-    public static function copyright(): array
+    public function copyright(): array
    {
-        $years = ($year = (int)date('Y')) > 2023 ? "2023 - $year" : $year;
        return [
-            "Anthony Axenov (c) $years, MIT license",
+            'Anthony Axenov (c) ' . date('Y') . ", MIT license",
            'https://git.axenov.dev/anthony/pm-convert'
        ];
    }
@ -342,9 +340,9 @@ class Processor
    /**
     * @return array
     */
-    public static function usage(): array
+    public function usage(): array
    {
-        return array_merge(static::version(), [
+        return array_merge($this->version(), [
            'Usage:',
            "\t./pm-convert -f|-d PATH -o OUTPUT_PATH [ARGUMENTS] [FORMATS]",
            "\tphp pm-convert -f|-d PATH -o OUTPUT_PATH [ARGUMENTS] [FORMATS]",
@ -358,7 +356,6 @@ class Processor
            "\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",
            '',
@ -391,6 +388,6 @@ class Processor
            "        -o ~/postman_export \ ",
            "       --all",
            "",
-        ], static::copyright());
+        ], $this->copyright());
    }
 }
--- a/src/Settings.php
+++ b/src/Settings.php
@ -1,313 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace PmConverter;
-
-use InvalidArgumentException;
-use JsonException;
-use PmConverter\Converters\ConvertFormat;
-use PmConverter\Exceptions\IncorrectSettingsFileException;
-
-/**
- * Class responsible for settings storage and dumping
- */
-class Settings
-{
-    /**
-     * @var string Full path to settings file
-     */
-    protected static string $filepath;
-
-    /**
-     * @var bool Flag to output some debug-specific messages
-     */
-    protected bool $devMode = false;
-
-    /**
-     * @var string[] Paths to collection directories
-     */
-    protected array $directories = [];
-
-    /**
-     * @var string[] Paths to collection files
-     */
-    protected array $collectionPaths = [];
-
-    /**
-     * @var string Output path where to put results in
-     */
-    protected string $outputPath = '';
-
-    /**
-     * @var bool Flag to remove output directories or not before conversion started
-     */
-    protected bool $preserveOutput = false;
-
-    /**
-     * @var string[] Additional variables
-     */
-    protected array $vars = [];
-
-    /**
-     * @var ConvertFormat[] Formats to convert a collections into
-     */
-    protected array $formats = [];
-
-    /**
-     * @var string Path to environment file
-     */
-    protected string $envFilepath = '';
-
-    /**
-     * @return bool
-     */
-    public static function fileExists(): bool
-    {
-        return file_exists(self::$filepath);
-    }
-
-    /**
-     * @return self
-     * @throws IncorrectSettingsFileException
-     * @throws JsonException
-     */
-    public static function init(): self
-    {
-        $content = '{}';
-        self::$filepath = sprintf('%s%spm-convert-settings.json', $_SERVER['PWD'], DS);
-        if (self::fileExists()) {
-            $content = trim(file_get_contents(self::$filepath));
-        }
-        try {
-            $settings = json_decode($content ?: '{}', flags: JSON_THROW_ON_ERROR);
-        } catch (JsonException $e) {
-            throw new IncorrectSettingsFileException('Incorrect settings file: ' . $e->getMessage(), $e->getCode());
-        }
-        return new self($settings);
-    }
-
-    /**
-     * Returns full path to settings file
-     *
-     * @return string
-     */
-    public static 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;
-        }
-    }
-
-    /**
-     * @param string $path
-     * @return void
-     * @throws JsonException
-     */
-    public function addDirPath(string $path): void
-    {
-        $this->directories = array_unique(array_merge(
-            $this->directories ?? [],
-            [FileSystem::normalizePath($path)]
-        ));
-        $files = array_filter(
-            FileSystem::dirContents($path),
-            static fn ($filename) => FileSystem::isCollectionFile($filename)
-        );
-        $this->collectionPaths = array_unique(array_merge($this->collectionPaths ?? [], $files));
-    }
-
-    /**
-     * @param string $path
-     * @return void
-     * @throws JsonException
-     */
-    public function addFilePath(string $path): void
-    {
-        $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
-     * @return void
-     */
-    public function setOutputPath(string $outputPath): void
-    {
-        $this->outputPath = $outputPath;
-    }
-
-    /**
-     * @param bool $devMode
-     * @return void
-     */
-    public function setDevMode(bool $devMode): void
-    {
-        $this->devMode = $devMode;
-    }
-
-    /**
-     * @param ConvertFormat $format
-     * @return void
-     */
-    public function addFormat(ConvertFormat $format): void
-    {
-        $this->formats[$format->name] = $format;
-    }
-
-    /**
-     * Returns array of variables
-     *
-     * @return string[]
-     */
-    public function vars(): array
-    {
-        return $this->vars;
-    }
-
-    /**
-     * @param bool $preserveOutput
-     * @return void
-     */
-    public function setPreserveOutput(bool $preserveOutput): void
-    {
-        $this->preserveOutput = $preserveOutput;
-    }
-
-    /**
-     * @param string $filepath
-     * @return void
-     */
-    public function setEnvFilepath(string $filepath): void
-    {
-        $this->envFilepath = FileSystem::normalizePath($filepath);
-    }
-
-    /**
-     * @return bool
-     */
-    public function isDevMode(): bool
-    {
-        return $this->devMode;
-    }
-
-    /**
-     * @return string[]
-     */
-    public function collectionPaths(): array
-    {
-        return $this->collectionPaths;
-    }
-
-    /**
-     * @return string
-     */
-    public function outputPath(): string
-    {
-        return $this->outputPath;
-    }
-
-    /**
-     * @return bool
-     */
-    public function isPreserveOutput(): bool
-    {
-        return $this->preserveOutput;
-    }
-
-    /**
-     * @return ConvertFormat[]
-     */
-    public function formats(): array
-    {
-        return $this->formats;
-    }
-
-    /**
-     * @return string
-     */
-    public function envFilepath(): string
-    {
-        return $this->envFilepath;
-    }
-
-    /**
-     * Determines fieldset of settings JSON
-     *
-     * @return array
-     */
-    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(
-                static fn (ConvertFormat $format) => $format->toArg(),
-                $this->formats(),
-            )),
-            'vars' => $this->vars,
-        ];
-    }
-
-    /**
-     * Converts settings into JSON format
-     *
-     * @return string
-     */
-    public function __toString(): string
-    {
-        return json_encode($this->__serialize(), JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES);
-    }
-
-    /**
-     * Writes settings in JSON format into settings file
-     *
-     * @param array $vars
-     * @return bool
-     */
-    public function dump(array $vars = []): bool
-    {
-        count($vars) > 0 && $this->vars = $vars;
-        return file_put_contents(self::$filepath, (string)$this) > 0;
-    }
-
-    /**
-     * Makes a backup file of current settings file
-     *
-     * @return string
-     */
-    public function backup(): string
-    {
-        copy(self::$filepath, $newfilepath = self::$filepath . '.bak.' . time());
-        return $newfilepath;
-    }
-}
--- a/tests/AbstractRequestTest.php
+++ b/tests/AbstractRequestTest.php
@ -3,8 +3,9 @@
 declare(strict_types=1);

 use PHPUnit\Framework\TestCase;
-use PmConverter\Exceptions\EmptyHttpVerbException;
-use PmConverter\Exceptions\InvalidHttpVersionException;
+use PmConverter\Exceptions\{
+    EmptyHttpVerbException,
+    InvalidHttpVersionException};

 class AbstractRequestTest extends TestCase
 {
@ -70,7 +71,7 @@ class AbstractRequestTest extends TestCase
    /**
     * @covers PmConverter\Converters\Abstract\AbstractRequest
     * @covers PmConverter\Converters\Abstract\AbstractRequest::setUrl()
-     * @covers PmConverter\Converters\Abstract\AbstractRequest::getRawUrl()
+     * @covers PmConverter\Converters\Abstract\AbstractRequest::getUrl()
     * @return void
     */
    public function testUrl(): void
@ -78,7 +79,7 @@ class AbstractRequestTest extends TestCase
        $request = new \PmConverter\Converters\Http\HttpRequest();
        $request->setUrl('http://localhost');

-        $this->assertSame('http://localhost', $request->getRawUrl());
+        $this->assertSame('http://localhost', $request->getUrl());
    }

    /**
Author	SHA1	Message	Date
Anthony Axenov	593546e3ff	Merge pull request 'v1.5.1' (#14 ) from dev into master Reviewed-on: #14	2023-09-17 16:42:40 +00:00
Anthony Axenov	c6963e0574	Merge pull request 'v1.4.1' (#13 ) from dev into master Reviewed-on: #13	2023-09-10 07:59:00 +00:00
Anthony Axenov	83794a7464	Merge pull request 'v1.4.0' (#12 ) from dev into master Reviewed-on: #12	2023-09-10 07:32:27 +00:00