Merge pull request 'v1.6.0' (#17 ) from dev into master

Reviewed-on: #17
Fixed execution without params
2024-07-07 16:15:10 +00:00 · 2024-07-08 00:14:37 +08:00 · 2024-07-07 16:02:41 +00:00 · 2024-07-07 23:44:59 +08:00 · 2023-10-03 09:05:03 +08:00 · 2023-09-17 16:42:40 +00:00
25 changed files with 1453 additions and 365 deletions
--- a/README.md
+++ b/README.md
@@ -8,14 +8,17 @@ Without 3rd-party dependencies.

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

-> 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.
+> 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`.

 ## Supported features

-* [collection schema **v2.1**](https://schema.postman.com/json/collection/v2.1.0/collection.json);
-* `Bearer` auth;
+* 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);
 * 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);
@@ -24,10 +27,9 @@ These formats are supported for now: `http`, `curl`, `wget`.

 ## Planned features

- conversion between postman schema v2.1 <-> v2.0 (#11);
 - 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`_);
- documentation generation support (markdown) with responce examples (if present) (#6);
+- support as many as possible/necessary of body formats (_currently only `json` and `formdata` supported_);
+- documentation generation support (markdown) with response examples (if present) (#6);
 - maybe some another convert formats (like httpie or something...);
 - better logging;
 - 90%+ test coverage, phpcs, psalm, etc.;
@@ -65,8 +67,8 @@ Possible ARGUMENTS:
        -o, --output        - a directory OUTPUT_PATH to put results in
        -e, --env           - use environment file with variables to replace in requests
        --var "NAME=VALUE"  - force replace specified env variable called NAME with custom VALUE
-                              (see interpolation notes below)
        -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

@@ -78,32 +80,26 @@ 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:
-        --http   - generate raw *.http files (default)
-        --curl   - generate shell scripts with curl command
-        --wget   - generate shell scripts with wget command
+        --http     - generate raw *.http files (default)
+        --curl     - generate shell scripts with curl command
+        --wget     - generate shell scripts with wget command
+        --v2.0     - convert from Postman Collection Schema v2.1 into v2.0
+        --v2.1     - convert from Postman Collection Schema v2.0 into v2.1
+        -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.
-
-Notes about variable interpolation:
-        1. You can use -e to tell where to find variables to replace in requests.
-        2. You can use one or several --var to replace specific env variables to your own value.
-        3. Correct syntax is `--var "NAME=VALUE". NAME may be in curly braces like {{NAME}}.
-        4. Since -e is optional, a bunch of --var will emulate an environment. Also it does not
-           matter if there is --var in environment file you provided or not.
-        5. Even if you (not) provided -e and/or --var, any of variable may still be overridden
-           from collection (if any), so last ones has top priority.
+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 
-
+    ./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
 ```

 ### Notices
@@ -116,12 +112,95 @@ Example:
   If not, you can rename them in Postman or convert collections with similar names into different directories.
   Otherwise any generated file may be accidently overwritten by another one.

+## Notes about variable interpolation
+
+1. You can use -e to tell where to find variables to replace in requests.
+2. You can use one or several --var to replace specific env variables to your own value.
+3. Correct syntax is `--var "NAME=VALUE"`. `NAME` may be in curly braces like `{{NAME}}`.
+4. Since -e is optional, a bunch of `--var` will emulate an environment. Also it does not matter if there is `--var` in environment file you provided or not.
+5. Even if you (not) provided -e and/or `--var`, any of variable may still be overridden from collection (if any), so last ones has top priority.
+
+### Notes about conversion between Postman Schemas
+
+You can use `--v2.1` to convert v2.1 into v2.1 (and this is not a typo).
+Same applies to `--v2.0`.
+
+There is a case when a collection has been exported via Postman API.
+In such case collection itself places in single root object called `collection` like this:
+
+```
+{
+   "collection": {
+      // your actual collection here
+   }
+}
+```
+
+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
-2. Create two classes for converter and request object which extends `Converters\Abstract\Abstract{Converter, Request}` respectively
-3. Change constants values in your new request class according to format you want to implement
-4. Write your own logic in converter's `__toString()` method, write new methods and override abstract ones
+1. Create new namespace in `./src/Converters` and name it according to format of your choice.
+2. Create two classes for converter and request object which extends `Converters\Abstract\Abstract{Converter, Request}` respectively.
+3. Change constants values in your new request class according to format you want to implement.
+4. Add your converter class name in `Converters\ConvertFormat`.
+5. Write your own logic in converter, write new methods and override abstract ones.

 ## License

--- a/composer.json
+++ b/composer.json
@@ -13,7 +13,9 @@
    "keywords": ["postman", "collection", "converter", "http", "wget", "curl", "api", "convert"],
    "require": {
        "php": "^8.1",
-        "ext-json": "*"
+        "ext-json": "*",
+        "ext-mbstring": "*",
+        "ext-readline": "*"
    },
    "bin": ["pm-convert"],
    "autoload": {
--- a/10
+++ b/10
@@ -2,6 +2,8 @@
 <?php

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

 use PmConverter\Processor;

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

 $processor = new Processor($argv);
 try {
-    $processor->convert();
+    $processor->handle();
 } catch (InvalidArgumentException $e) {
-    fwrite(STDERR, sprintf('ERROR: %s%s', $e->getMessage(), PHP_EOL));
-    print(implode(PHP_EOL, $processor->usage()));
+    fwrite(STDERR, sprintf('ERROR: %s%s', $e->getMessage(), EOL));
+    print(implode(EOL, Processor::usage()));
    die(1);
 } catch (Exception $e) {
-    fwrite(STDERR, sprintf('ERROR: %s%s', $e->getMessage(), PHP_EOL));
+    fwrite(STDERR, sprintf('ERROR: %s%s', $e->getMessage(), EOL));
    die(1);
 }
--- a/src/Collection.php
+++ b/src/Collection.php
@@ -0,0 +1,172 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace PmConverter;
+
+use Exception;
+use Generator;
+use JsonException;
+use Stringable;
+
+/**
+ * Class that describes a request collection
+ *
+ * @property array|object $item
+ * @property object $info
+ * @property object|null $variable
+ */
+class Collection implements Stringable
+{
+    public readonly CollectionVersion $version;
+
+    /**
+     * Closed constructor so that we could use factory methods
+     *
+     * @param object $json
+     */
+    private function __construct(protected object $json)
+    {
+        // specific case when collection has been exported via postman api
+        if (property_exists($json, 'collection')) {
+            $json = $json->collection;
+        }
+        $this->json = $json;
+        $this->version = $this->detectVersion();
+    }
+
+    /**
+     * Factory that creates new Collection from content read from file path
+     *
+     * @param string $path
+     * @return static
+     * @throws JsonException
+     */
+    public static function fromFile(string $path): static
+    {
+        $content = file_get_contents(FileSystem::normalizePath($path));
+        $json = json_decode($content, flags: JSON_THROW_ON_ERROR);
+        return new static($json);
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function __toString(): string
+    {
+        return json_encode($this->json, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES);
+    }
+
+    /**
+     * Returns reference to the parsed json structure
+     *
+     * @return object
+     */
+    public function &raw(): object
+    {
+        return $this->json;
+    }
+
+    /**
+     * Returns reference to any part of the parsed json structure
+     *
+     * @param string $name
+     * @return mixed
+     */
+    public function &__get(string $name): mixed
+    {
+        return $this->json->$name;
+    }
+
+    /**
+     * Returns collection name
+     *
+     * @return string
+     */
+    public function name(): string
+    {
+        return $this->json->info->name;
+    }
+
+    /**
+     * Returns the collection version
+     *
+     * @return CollectionVersion
+     */
+    protected function detectVersion(): CollectionVersion
+    {
+        return match (true) {
+            str_contains($this->json->info->schema, '/v2.0.') => CollectionVersion::Version20,
+            str_contains($this->json->info->schema, '/v2.1.') => CollectionVersion::Version21,
+            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/CollectionVersion.php
+++ b/src/CollectionVersion.php
@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PmConverter;
+
+enum CollectionVersion: string
+{
+    case Version20 = 'v2.0';
+    case Version21 = 'v2.1';
+    case Unknown = 'unknown';
+}
--- a/src/Converters/Abstract/AbstractConverter.php
+++ b/src/Converters/Abstract/AbstractConverter.php
@@ -5,22 +5,24 @@ declare(strict_types=1);
 namespace PmConverter\Converters\Abstract;

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

 /**
 *
 */
-abstract class AbstractConverter implements ConverterContract
+abstract class AbstractConverter
 {
    /**
-     * @var object|null
+     * @var Collection|null
     */
-    protected ?object $collection = null;
+    protected ?Collection $collection = null;

    /**
     * @var string
@@ -28,35 +30,66 @@ abstract class AbstractConverter implements ConverterContract
    protected string $outputPath;

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

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

    /**
-     * Converts collection requests
+     * Converts requests from collection
+     *
+     * @param Collection $collection
+     * @return static
+     * @throws CannotCreateDirectoryException
+     * @throws DirectoryIsNotWriteableException
+     * @throws Exception
+     */
+    public function convert(Collection $collection): static
+    {
+        $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 convert(object $collection, string $outputPath): void
+    public function flush(): void
    {
-        $outputPath = sprintf('%s%s%s', $outputPath, DIRECTORY_SEPARATOR, static::OUTPUT_DIR);
-        $this->outputPath = FileSystem::makeDir($outputPath);
-        $this->collection = $collection;
-        $this->setVariables();
-        foreach ($collection->item as $item) {
-            $this->convertItem($item);
+        foreach ($this->converted() as $path => $request) {
+            $this->writeRequest($request, $path);
        }
    }

@@ -65,13 +98,10 @@ abstract class AbstractConverter implements ConverterContract
     *
     * @return $this
     */
-    protected function setVariables(): static
+    protected function setCollectionVars(): static
    {
-        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;
-            }
+        foreach ($this->collection?->variable ?? [] as $var) {
+            Environment::instance()->setCustomVar($var->key, $var->value);
        }
        return $this;
    }
@@ -94,31 +124,9 @@ abstract class AbstractConverter implements ConverterContract
     */
    protected function isItemFolder(object $item): bool
    {
-        return !empty($item->item) && 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));
-        }
+        return !empty($item->item)
+            && is_array($item->item)
+            && empty($item->request);
    }

    /**
@@ -128,23 +136,24 @@ abstract class AbstractConverter implements ConverterContract
     * @return RequestContract
     * @throws InvalidHttpVersionException
     */
-    protected function initRequest(object $item): RequestContract
+    protected function makeRequest(object $item): RequestContract
    {
        $request_class = static::REQUEST_CLASS;

-        /** @var RequestContract $result */
-        $result = new $request_class();
-        $result->setName($item->name);
-        $result->setHttpVersion(1.1); //TODO http version?
-        $result->setDescription($item->request?->description ?? null);
-        $result->setVerb($item->request->method);
-        $result->setUrl($item->request->url->raw);
-        $result->setHeaders($item->request->header);
-        $result->setAuth($item->request?->auth ?? $this->collection?->auth ?? null);
+        /** @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->setHeaders($item->request->header);
+        $request->setAuth($item->request?->auth ?? $this->collection?->auth ?? null);
        if ($item->request->method !== 'GET' && !empty($item->request->body)) {
-            $result->setBody($item->request->body);
+            $request->setBody($item->request->body);
        }
-        return $result;
+        return $request;
    }

    /**
@@ -157,9 +166,9 @@ abstract class AbstractConverter implements ConverterContract
     */
    protected function writeRequest(RequestContract $request, string $subpath = null): bool
    {
-        $filedir = sprintf('%s%s%s', $this->outputPath, DIRECTORY_SEPARATOR, $subpath);
+        $filedir = sprintf('%s%s%s', $this->outputPath, DS, $subpath);
        $filedir = FileSystem::makeDir($filedir);
-        $filepath = sprintf('%s%s%s.%s', $filedir, DIRECTORY_SEPARATOR, $request->getName(), static::FILE_EXT);
+        $filepath = sprintf('%s%s%s.%s', $filedir, DS, $request->getName(), static::FILE_EXT);
        $content = $this->interpolate((string)$request);
        return file_put_contents($filepath, $content) > 0;
    }
@@ -172,18 +181,9 @@ abstract class AbstractConverter implements ConverterContract
     */
    protected function interpolate(string $content): string
    {
-        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;
+        $replace = static fn ($a) => Environment::instance()->var($var = $a[0]) ?: $var;
+        return Environment::instance()->hasVars()
+            ? preg_replace_callback('/\{\{.*}}/m', $replace, $content)
+            : $content;
    }
 }
--- a/src/Converters/Abstract/AbstractRequest.php
+++ b/src/Converters/Abstract/AbstractRequest.php
@@ -4,11 +4,11 @@ declare(strict_types=1);

 namespace PmConverter\Converters\Abstract;

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

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

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

    /**
     * @var float HTTP protocol version
@@ -56,14 +56,23 @@ 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
     */
    public function setHttpVersion(float $version): static
    {
-        if (!in_array($version, HttpVersions::values())) {
+        if (!in_array($version, HttpVersion::values())) {
            throw new InvalidHttpVersionException(
-                'Only these HTTP versions are supported: ' . implode(', ', HttpVersions::values())
+                'Only these HTTP versions are supported: ' . implode(', ', HttpVersion::values())
            );
        }
        $this->httpVersion = $version;
@@ -92,7 +101,7 @@ abstract class AbstractRequest implements Stringable, RequestContract
     */
    public function getName(): string
    {
-        return str_replace(DIRECTORY_SEPARATOR, '_', $this->name);
+        return str_replace(DS, '_', $this->name);
    }

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

    /**
@@ -186,7 +195,11 @@ abstract class AbstractRequest implements Stringable, RequestContract
        if (!empty($auth)) {
            switch ($auth->type) {
                case 'bearer':
-                    $this->setHeader('Authorization', 'Bearer ' . $auth->{$auth->type}[0]->value);
+                    $this->setHeader('Authorization', 'Bearer ' . match ($this->version) {
+                        CollectionVersion::Version20 => $auth->{$auth->type}->token,
+                        CollectionVersion::Version21 => $auth->{$auth->type}[0]->value,
+                        default => null
+                    });
                    break;
                default:
                    break;
@@ -219,11 +232,12 @@ abstract class AbstractRequest implements Stringable, RequestContract
    {
        $this->setBodymode($body->mode);
        if ($body->mode === 'formdata') {
-            $this->setHeader('Content-Type', 'multipart/form-data')
-                ->setFormdataBody($body);
-        } elseif (!empty($body->options) && $body->options->{$this->bodymode}->language === 'json') {
-            $this->setHeader('Content-Type', 'application/json')
-                ->setJsonBody($body);
+            $this->setHeader('Content-Type', 'multipart/form-data')->setFormdataBody($body);
+        } elseif ($body->mode === 'raw') {
+            $this->setBodyAsIs($body);
+            if (!empty($body->options) && $body->options->{$this->bodymode}->language === 'json') {
+                $this->setHeader('Content-Type', 'application/json');
+            }
        }
        return $this;
    }
@@ -251,7 +265,7 @@ abstract class AbstractRequest implements Stringable, RequestContract
     * @param object $body
     * @return $this
     */
-    protected function setJsonBody(object $body): static
+    protected function setBodyAsIs(object $body): static
    {
        $this->body = $body->{$this->getBodymode()};
        return $this;
--- a/src/Converters/ConvertFormat.php
+++ b/src/Converters/ConvertFormat.php
@@ -5,14 +5,39 @@ declare(strict_types=1);
 namespace PmConverter\Converters;


-use PmConverter\Converters\{
-    Curl\CurlConverter,
-    Http\HttpConverter,
-    Wget\WgetConverter};
+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;

 enum ConvertFormat: string
 {
    case Http = HttpConverter::class;
    case Curl = CurlConverter::class;
    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/ConverterContract.php
+++ b/src/Converters/ConverterContract.php
@@ -4,8 +4,10 @@ declare(strict_types=1);

 namespace PmConverter\Converters;

+use PmConverter\Collection;
+
 interface ConverterContract
 {
-    public function convert(object $collection, string $outputPath): void;
+    public function convert(Collection $collection, string $outputPath): void;
    public function getOutputPath(): string;
 }
--- a/src/Converters/Curl/CurlConverter.php
+++ b/src/Converters/Curl/CurlConverter.php
@@ -4,11 +4,9 @@ declare(strict_types=1);

 namespace PmConverter\Converters\Curl;

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

-class CurlConverter extends AbstractConverter implements ConverterContract
+class CurlConverter extends AbstractConverter
 {
    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->url \ ",
+                "\t--location {$this->getRawUrl()} \ ",
            ],
            $this->prepareHeaders(),
            $this->prepareBody()
        );
        $output[] = rtrim(array_pop($output), '\ ');
-        return implode(PHP_EOL, array_merge($output, ['']));
+        return implode(EOL, array_merge($output, ['']));
    }
 }
--- a/src/Converters/Http/HttpConverter.php
+++ b/src/Converters/Http/HttpConverter.php
@@ -4,11 +4,9 @@ declare(strict_types=1);

 namespace PmConverter\Converters\Http;

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

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

--- a/src/Converters/Http/HttpRequest.php
+++ b/src/Converters/Http/HttpRequest.php
@@ -5,8 +5,7 @@ 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
@@ -29,7 +28,7 @@ class HttpRequest extends AbstractRequest
     */
    protected function prepareHeaders(): array
    {
-        $output[] = sprintf('%s %s HTTP/%s', $this->getVerb(), $this->getUrl(), $this->getHttpVersion());
+        $output[] = sprintf('%s %s HTTP/%s', $this->getVerb(), $this->getRawUrl(), $this->getHttpVersion());
        foreach ($this->headers as $name => $data) {
            $output[] = sprintf('%s%s: %s', $data['disabled'] ? '# ' : '', $name, $data['value']);
        }
@@ -69,6 +68,6 @@ class HttpRequest extends AbstractRequest
            $this->prepareHeaders(),
            $this->prepareBody()
        );
-        return implode(PHP_EOL, $output);
+        return implode(EOL, $output);
    }
 }
--- a/src/Converters/Postman20/Postman20Converter.php
+++ b/src/Converters/Postman20/Postman20Converter.php
@@ -0,0 +1,135 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PmConverter\Converters\Postman20;
+
+use PmConverter\Collection;
+use PmConverter\CollectionVersion;
+use PmConverter\Converters\Abstract\AbstractConverter;
+use PmConverter\Exceptions\CannotCreateDirectoryException;
+use PmConverter\Exceptions\DirectoryIsNotWriteableException;
+use PmConverter\FileSystem;
+
+/**
+ * Converts Postman Collection v2.1 to v2.0
+ */
+class Postman20Converter extends AbstractConverter
+{
+    protected const FILE_EXT = 'v20.postman_collection.json';
+
+    protected const OUTPUT_DIR = 'pm-v2.0';
+
+    /**
+     * Converts collection requests
+     *
+     * @param Collection $collection
+     * @return static
+     * @throws CannotCreateDirectoryException
+     * @throws DirectoryIsNotWriteableException
+     */
+    public function convert(Collection $collection): static
+    {
+        $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) {
+            $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->writeCollection();
+        return $this;
+    }
+
+    /**
+     * Writes converted collection into file
+     *
+     * @return bool
+     * @throws CannotCreateDirectoryException
+     * @throws DirectoryIsNotWriteableException
+     */
+    protected function writeCollection(): bool
+    {
+        $filedir = FileSystem::makeDir($this->outputPath);
+        $filepath = sprintf('%s%s%s.%s', $filedir, DS, $this->collection->name(), static::FILE_EXT);
+        return file_put_contents($filepath, $this->collection) > 0;
+    }
+
+    /**
+     * Changes some requests fields in place
+     *
+     * @param mixed $item
+     * @return void
+     */
+    protected function convertItem(mixed $item): void
+    {
+        if ($this->isItemFolder($item)) {
+            foreach ($item->item as $subitem) {
+                if ($this->isItemFolder($subitem)) {
+                    $this->convertItem($subitem);
+                } else {
+                    $this->convertAuth($subitem->request);
+                    $this->convertRequestUrl($subitem->request);
+                    $this->convertResponseUrls($subitem->response);
+                }
+            }
+        } else {
+            $this->convertAuth($item->request);
+            $this->convertRequestUrl($item->request);
+            $this->convertResponseUrls($item->response);
+        }
+    }
+
+    /**
+     * Converts auth object from v2.1 to v2.0
+     *
+     * @param object $request
+     * @return void
+     */
+    protected function convertAuth(object $request): void
+    {
+        if (empty($request->auth)) {
+            return;
+        }
+        $auth = ['type' => 'noauth'];
+        $type = strtolower($request->auth->type);
+        if ($type !== 'noauth') {
+            foreach ($request->auth->$type as $param) {
+                $auth[$param->key] = $param->value ?? '';
+            }
+            $request->auth->$type = (object)$auth;
+        }
+    }
+
+    /**
+     * Converts requests URLs from object v2.1 to string v2.0
+     *
+     * @param object $request
+     * @return void
+     */
+    protected function convertRequestUrl(object $request): void
+    {
+        if (is_object($request->url)) {
+            $request->url = $request->url->raw;
+        }
+    }
+
+    /**
+     * Converts URLs response examples from object v2.1 to string v2.0
+     *
+     * @param array $responses
+     * @return void
+     */
+    protected function convertResponseUrls(array $responses): void
+    {
+        foreach ($responses as $response) {
+            if (is_object($response->originalRequest->url)) {
+                $response->originalRequest->url = $response->originalRequest->url->raw;
+            }
+        }
+    }
+}
--- a/src/Converters/Postman21/Postman21Converter.php
+++ b/src/Converters/Postman21/Postman21Converter.php
@@ -0,0 +1,167 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PmConverter\Converters\Postman21;
+
+use PmConverter\Collection;
+use PmConverter\CollectionVersion;
+use PmConverter\Converters\Abstract\AbstractConverter;
+use PmConverter\Exceptions\CannotCreateDirectoryException;
+use PmConverter\Exceptions\DirectoryIsNotWriteableException;
+use PmConverter\FileSystem;
+
+/**
+ * Converts Postman Collection v2.0 to v2.1
+ */
+class Postman21Converter extends AbstractConverter
+{
+    protected const FILE_EXT = 'v21.postman_collection.json';
+
+    protected const OUTPUT_DIR = 'pm-v2.1';
+
+    /**
+     * Converts collection requests
+     *
+     * @param Collection $collection
+     * @return static
+     * @throws CannotCreateDirectoryException
+     * @throws DirectoryIsNotWriteableException
+     */
+    public function convert(Collection $collection): static
+    {
+        $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) {
+            $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->writeCollection();
+        return $this;
+    }
+
+    /**
+     * Writes converted collection into file
+     *
+     * @return bool
+     * @throws CannotCreateDirectoryException
+     * @throws DirectoryIsNotWriteableException
+     */
+    protected function writeCollection(): bool
+    {
+        $filedir = FileSystem::makeDir($this->outputPath);
+        $filepath = sprintf('%s%s%s.%s', $filedir, DS, $this->collection->name(), static::FILE_EXT);
+        return file_put_contents($filepath, $this->collection) > 0;
+    }
+
+    /**
+     * Changes some requests fields in place
+     *
+     * @param mixed $item
+     * @return void
+     */
+    protected function convertItem(mixed $item): void
+    {
+        if ($this->isItemFolder($item)) {
+            foreach ($item->item as $subitem) {
+                if ($this->isItemFolder($subitem)) {
+                    $this->convertItem($subitem);
+                } else {
+                    $this->convertAuth($subitem->request);
+                    $this->convertRequestUrl($subitem->request);
+                    $this->convertResponseUrls($subitem->response);
+                }
+            }
+        } else {
+            $this->convertAuth($item->request);
+            $this->convertRequestUrl($item->request);
+            $this->convertResponseUrls($item->response);
+        }
+    }
+
+    /**
+     * Converts auth object from v2.0 to v2.1
+     *
+     * @param object $request
+     * @return void
+     */
+    protected function convertAuth(object $request): void
+    {
+        if (empty($request->auth)) {
+            return;
+        }
+        $type = $request->auth->type;
+        if ($type !== 'noauth' && isset($request->auth->$type)) {
+            $auth = [];
+            foreach ($request->auth->$type as $key => $value) {
+                $auth[] = (object)[
+                    'key' => $key,
+                    'value' => $value,
+                    'type' => 'string',
+                ];
+            }
+            $request->auth->$type = $auth;
+        }
+    }
+
+    /**
+     * Converts requests URLs from string v2.0 to object v2.1
+     *
+     * @param object $request
+     * @return void
+     */
+    protected function convertRequestUrl(object $request): void
+    {
+        if (is_string($request->url) && mb_strlen($request->url) > 0) {
+            $data = array_values(array_filter(explode('/', $request->url))); //TODO URL parsing
+            if (count($data) === 1) {
+                $url = [
+                    'raw' => $request->url,
+                    'host' => [$data[0] ?? $request->url],
+                ];
+            } else {
+                $url = [
+                    'raw' => $request->url,
+                    'protocol' => str_replace(':', '', $data[0]),
+                    'host' => [$data[1] ?? $request->url],
+                    'path' => array_slice($data, 2),
+                ];
+            }
+            $request->url = (object)$url;
+        }
+    }
+
+    /**
+     * Converts URLs response examples from string v2.0 to object v2.1
+     *
+     * @param array $responses
+     * @return void
+     */
+    protected function convertResponseUrls(array $responses): void
+    {
+        foreach ($responses as $response) {
+            if (is_string($response->originalRequest->url)) {
+                $data = array_values(array_filter(explode('/', $response->originalRequest->url))); //TODO URL parsing
+                if (count($data) === 1) {
+                    $url = [
+                        'raw' => $response->originalRequest->url,
+                        'host' => [$data[0] ?? $response->originalRequest->url],
+                    ];
+                } else {
+                    $url = [
+                        'raw' => $response->originalRequest->url,
+                        'protocol' => str_replace(':', '', $data[0]),
+                        'host' => [$data[1] ?? $response->originalRequest->url],
+                        'path' => array_slice($data, 2),
+                    ];
+                }
+                $response->originalRequest->url = (object)$url;
+            }
+        }
+    }
+}
--- a/src/Converters/RequestContract.php
+++ b/src/Converters/RequestContract.php
@@ -86,7 +86,7 @@ interface RequestContract
     *
     * @return string
     */
-    public function getUrl(): string;
+    public function getRawUrl(): string;

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

 namespace PmConverter\Converters\Wget;

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

-class WgetConverter extends AbstractConverter implements ConverterContract
+class WgetConverter extends AbstractConverter
 {
    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->getUrl(), http_build_query($this->prepareBody()));
+                    $output[] = sprintf("\t%s?%s", $this->getRawUrl(), http_build_query($this->prepareBody()));
                } else {
                    $output[] = sprintf("\t--body-data '%s' \ ", http_build_query($this->prepareBody()));
-                    $output[] = sprintf("\t%s", $this->getUrl());
+                    $output[] = sprintf("\t%s", $this->getRawUrl());
                }
            }
        } else {
            if ($this->getVerb() !== 'GET') {
                $output[] = sprintf("\t--body-data '%s' \ ", implode("\n", $this->prepareBody()));
-                $output[] = sprintf("\t%s", $this->getUrl());
+                $output[] = sprintf("\t%s", $this->getRawUrl());
            }
        }
-        return implode(PHP_EOL, array_merge($output, ['']));
+        return implode(EOL, array_merge($output, ['']));
    }
 }
--- a/src/Environment.php
+++ b/src/Environment.php
@@ -4,21 +4,141 @@ declare(strict_types=1);

 namespace PmConverter;

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

    /**
-     * @param object $env
+     * @var array
     */
-    public function __construct(protected object $env)
+    protected array $customVars = [];
+
+    public static function instance(): static
    {
-        foreach ($env->values as $var) {
-            $this->vars[static::formatKey($var->key)] = $var->value;
+        return static::$instance ??= new static();
+    }
+
+    /**
+     * @param string $filepath
+     * @return $this
+     * @throws JsonException
+     */
+    public function readFromFile(string $filepath): static
+    {
+        if (empty($filepath)) {
+            return $this;
        }
+        $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");
+        }
+        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;
    }

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

+
+
+
+
+
+
+
+
+
+
+
+
+    /**
+     * 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());
    }

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

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

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

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

 namespace PmConverter;

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

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

    /**
@@ -100,7 +101,7 @@ class FileSystem
        $path = static::normalizePath($path);
        $records = array_diff(@scandir($path) ?: [], ['.', '..']);
        foreach ($records as &$record) {
-            $record = sprintf('%s%s%s', $path, DIRECTORY_SEPARATOR, $record);
+            $record = sprintf('%s%s%s', $path, DS, $record);
        }
        return $records;
    }
@@ -110,16 +111,15 @@ class FileSystem
     *
     * @param string $path
     * @return bool
+     * @throws JsonException
+     * @throws Exception
     */
    public static function isCollectionFile(string $path): bool
    {
-        $path = static::normalizePath($path);
-        return !empty($path = trim($path))
+        return (!empty($path = static::normalizePath($path)))
            && str_ends_with($path, '.postman_collection.json')
            && file_exists($path)
            && is_readable($path)
-            && ($json = json_decode(file_get_contents($path), true))
-            && json_last_error() === JSON_ERROR_NONE
-            && isset($json['collection']['info']['name']);
+            && Collection::detectFileVersion($path) !== CollectionVersion::Unknown;
    }
 }
--- a/src/HttpVersions.php
+++ b/src/HttpVersions.php
@@ -4,7 +4,7 @@ declare(strict_types=1);

 namespace PmConverter;

-enum HttpVersions: string
+enum HttpVersion: string
 {
    case Version10 = '1.0';
    case Version11 = '1.1';
--- a/src/Processor.php
+++ b/src/Processor.php
@@ -5,112 +5,93 @@ declare(strict_types=1);
 namespace PmConverter;

 use Exception;
+use Generator;
 use InvalidArgumentException;
+use JetBrains\PhpStorm\NoReturn;
 use JsonException;
-use PmConverter\Converters\{
-    ConverterContract,
-    ConvertFormat};
-use PmConverter\Exceptions\{
-    CannotCreateDirectoryException,
-    DirectoryIsNotReadableException,
-    DirectoryIsNotWriteableException,
-    DirectoryNotExistsException};
+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;

+/**
+ * Main class
+ */
 class Processor
 {
    /**
     * Converter version
     */
-    public const VERSION = '1.4.0';
-
-    /**
-     * @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 ConverterContract[] Converters will be used for conversion according to choosen formats
-     */
-    protected array $converters = [];
-
-    /**
-     * @var object[] Collections that will be converted into choosen formats
-     */
-    protected array $collections = [];
+    public const VERSION = '1.6.1';

    /**
     * @var int Initial timestamp
     */
-    protected int $initTime;
+    protected readonly int $initTime;

    /**
     * @var int Initial RAM usage
     */
-    protected int $initRam;
+    protected readonly int $initRam;

    /**
-     * @var string Path to environment file
+     * @var Settings Settings                               (lol)
     */
-    protected string $envFile;
+    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
     */
-    protected Environment $env;
+    public Environment $env;

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

    /**
     * Parses an array of arguments came from cli
     *
     * @return void
+     * @throws JsonException
     */
    protected function parseArgs(): void
    {
-        if (count($this->argv) < 2) {
-            die(implode(PHP_EOL, $this->usage()) . PHP_EOL);
-        }
-        foreach ($this->argv as $idx => $arg) {
+        $arguments = array_slice($this->argv, 1);
+        $needHelp = count($arguments) === 0 && !$this->settings::fileExists();
+        foreach ($arguments as $idx => $arg) {
            switch ($arg) {
                case '-f':
                case '--file':
-                    $rawpath = $this->argv[$idx + 1];
-                    $normpath = FileSystem::normalizePath($rawpath);
-                    if (!FileSystem::isCollectionFile($normpath)) {
-                        throw new InvalidArgumentException(
-                            sprintf("this is not a valid collection file:%s\t%s %s", PHP_EOL, $arg, $rawpath)
-                        );
-                    }
-                    $this->collectionPaths[] = $this->argv[$idx + 1];
+                    $this->settings->addFilePath($this->argv[$idx + 1]);
                    break;

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

                case '-d':
@@ -126,61 +107,127 @@ class Processor
                    if (empty($this->argv[$idx + 1])) {
                        throw new InvalidArgumentException('a directory path is expected for -d (--dir)');
                    }
-                    $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));
+                    $this->settings->addDirPath($this->argv[$idx + 1]);
                    break;

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

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

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

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

                case '--wget':
-                    $this->formats[ConvertFormat::Wget->name] = ConvertFormat::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':
-                    [$var, $value] = explode('=', trim($this->argv[$idx + 1]));
-                    $this->vars[$var] = $value;
+                    //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(PHP_EOL, $this->version()) . PHP_EOL);
+                    die(implode(EOL, $this->version()) . EOL);

                case '-h':
                case '--help':
-                    die(implode(PHP_EOL, $this->usage()) . PHP_EOL);
+                    $needHelp = true;
+                    break;
            }
        }
-        if (empty($this->collectionPaths)) {
+        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->outputPath)) {
+        if (empty($this->settings->outputPath())) {
            throw new InvalidArgumentException('-o is required');
        }
-        if (empty($this->formats)) {
-            $this->formats = [ConvertFormat::Http->name => ConvertFormat::Http];
+        if (empty($this->settings->formats())) {
+            $this->settings->addFormat(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
     *
@@ -190,100 +237,74 @@ class Processor
     * @throws DirectoryNotExistsException
     * @throws DirectoryIsNotReadableException
     */
-    protected function initOutputDirectory(): void
+    protected function prepareOutputDirectory(): void
    {
-        if (isset($this?->outputPath) && !$this->preserveOutput) {
-            FileSystem::removeDir($this->outputPath);
+        if (!$this->settings->isPreserveOutput()) {
+            FileSystem::removeDir($this->settings->outputPath());
        }
-        FileSystem::makeDir($this->outputPath);
+        FileSystem::makeDir($this->settings->outputPath());
    }

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

    /**
-     * Initializes collection objects
+     * Generates collections from settings
     *
+     * @return Generator<Collection>
     * @throws JsonException
     */
-    protected function initCollections(): void
+    protected function newCollection(): Generator
    {
-        foreach ($this->collectionPaths as $collectionPath) {
-            $content = file_get_contents(FileSystem::normalizePath($collectionPath));
-            $content = json_decode($content, flags: JSON_THROW_ON_ERROR);
-            if (!property_exists($content, 'collection') || empty($content?->collection)) {
-                throw new JsonException("not a valid collection: $collectionPath");
-            }
-            $this->collections[$content->collection->info->name] = $content->collection;
+        foreach ($this->settings->collectionPaths() as $collectionPath) {
+            yield Collection::fromFile($collectionPath);
        }
-        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 Exception
+     * @throws JsonException
     */
    public function convert(): void
    {
-        $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) {
+        $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) {
            ++$current;
-            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);
+            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());
+                    }
                }
-                $exporter->convert($collection, $outputPath);
-                printf('  OK: %s%s', $exporter->getOutputPath(), PHP_EOL);
            }
-            print(PHP_EOL);
+            print(EOL);
            ++$success;
        }
-        unset($this->converters, $type, $exporter, $outputPath, $this->collections, $collectionName, $collection);
+        unset($this->converters, $type, $converter, $outputPath, $this->collections, $collectionName, $collection);
        $this->printStats($success, $current);
    }

@@ -297,25 +318,31 @@ class Processor
    protected function printStats(int $success, int $count): void
    {
        $time = (hrtime(true) - $this->initTime) / 1_000_000;
+        $timeFmt = 'ms';
+        if ($time > 1000) {
+            $time /= 1000;
+            $timeFmt = 'sec';
+        }
        $ram = (memory_get_peak_usage(true) - $this->initRam) / 1024 / 1024;
-        printf('Converted %d of %d in %.3f ms using up to %.3f MiB RAM%s', $success, $count, $time, $ram, PHP_EOL);
+        printf("Converted %d/%d in %.2f $timeFmt using up to %.2f MiB RAM%s", $success, $count, $time, $ram, EOL);
    }

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

    /**
     * @return string[]
     */
-    public function copyright(): array
+    public static function copyright(): array
    {
+        $years = ($year = (int)date('Y')) > 2023 ? "2023 - $year" : $year;
        return [
-            'Anthony Axenov (c) ' . date('Y') . ", MIT license",
+            "Anthony Axenov (c) $years, MIT license",
            'https://git.axenov.dev/anthony/pm-convert'
        ];
    }
@@ -323,9 +350,9 @@ class Processor
    /**
     * @return array
     */
-    public function usage(): array
+    public static function usage(): array
    {
-        return array_merge($this->version(), [
+        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]",
@@ -338,8 +365,8 @@ class Processor
            "\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                      (see interpolation notes below)",
            "\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",
            '',
@@ -351,21 +378,15 @@ class Processor
            '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--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.',
-            '',
-            'Notes about variable interpolation:',
-            "\t1. You can use -e to tell where to find variables to replace in requests.",
-            "\t2. You can use one or several --var to replace specific env variables to your own value.",
-            "\t3. Correct syntax is `--var \"NAME=VALUE\". NAME may be in curly braces like {{NAME}}.",
-            "\t4. Since -e is optional, a bunch of --var will emulate an environment. Also it does not",
-            "\t   matter if there is --var in environment file you provided or not.",
-            "\t5. Even if you (not) provided -e and/or --var, any of variable may still be overridden",
-            "\t   from collection (if any), so last ones has top priority.",
+            'Any of FORMATS can be specified at the same time or replaced by --all.',
            '',
            'Example:',
            "    ./pm-convert \ ",
@@ -375,8 +396,9 @@ class Processor
            "        --env ~/localhost.postman_environment.json \ ",
            "        -d ~/personal \ ",
            "        --var \"myvar=some value\" \ ",
-            "        -o ~/postman_export ",
+            "        -o ~/postman_export \ ",
+            "       --all",
            "",
-        ], $this->copyright());
+        ], static::copyright());
    }
 }
--- a/src/Settings.php
+++ b/src/Settings.php
@@ -0,0 +1,313 @@
+<?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,15 +3,14 @@
 declare(strict_types=1);

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

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

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

    /**
@@ -215,7 +214,7 @@ class AbstractRequestTest extends TestCase
     * @covers PmConverter\Converters\Abstract\AbstractRequest::setBodymode()
     * @covers PmConverter\Converters\Abstract\AbstractRequest::setHeader()
     * @covers PmConverter\Converters\Abstract\AbstractRequest::setBody()
-     * @covers PmConverter\Converters\Abstract\AbstractRequest::setJsonBody()
+     * @covers PmConverter\Converters\Abstract\AbstractRequest::setBodyAsIs()
     * @covers PmConverter\Converters\Abstract\AbstractRequest::getBody()
     * @return void
     */
Author	SHA1	Message	Date
Anthony Axenov	4694134405	Merge pull request 'v1.6.0' (#17 ) from dev into master Reviewed-on: #17	2024-07-07 16:15:10 +00:00
Anthony Axenov	e5dad3f2d6	Fixed execution without params	2024-07-08 00:14:37 +08:00
Anthony Axenov	8c1e874b03	Merge pull request 'v1.6.0' (#16 ) from dev into master Reviewed-on: #16	2024-07-07 16:02:41 +00:00
Anthony Axenov	47930b010f	Introducing settings file, some refactorings and stabilization	2024-07-07 23:44:59 +08:00
Anthony Axenov	5666702ccc	Error stacktrace with --dev enabled while conversion is in progress Also shorter constants.	2023-10-03 09:05:03 +08:00
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	771fe4931a	Bump version	2023-09-18 00:40:23 +08:00
Anthony Axenov	c6bdcfe7cc	New flag --all, corrections in --help and README	2023-09-18 00:39:33 +08:00
Anthony Axenov	60cad4b501	Skip postman schema conversion if it is already same as specified (#10 )	2023-09-18 00:33:37 +08:00
Anthony Axenov	01d29ee023	Initial and very naive conversion v2.0 => v2.1 (#10 )	2023-09-17 23:59:37 +08:00
Anthony Axenov	3c1871ce1f	Conversion to 2.0 (--v2.0), improvements and fixes (#10 ) First of all, now you can convert a collection manually exported from Postman UI. Until this commit, any collection json had to be inside of root 'collection' object. Postman API returns collections in a such way and that was my case. So any collection exported using UI was mistakenly not detected as correct one. The second thing that it is now possible to convert collections from v2.1 to v2.0 using --v2.0 flag. Even if they are exported via Postman API, of course. Also some important refactorings are here.	2023-09-17 23:09:19 +08: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	5c85f23514	Bump version	2023-09-10 15:58:31 +08:00
Anthony Axenov	35e1984326	JSON body & header was fixed	2023-09-10 15:57:39 +08:00