IPFS\Api\ApiParser

Complexity

Total Complexity

19

Size/Duplication

Total Lines	134
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

97.1%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	build()	0	10	1
B	buildMethods()	0	33	5
B	parseArguments()	0	36	5
A	parseDefaultValue()	0	11	2
A	parseDescription()	0	8	3
A	parseTypeHint()	0	8	2

<?php

declare(strict_types=1);

/*
 * This file is part of the "php-ipfs" package.
 *
 * (c) Robert Schönthal <robert.schoenthal@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace IPFS\Api;

use Http\Client\HttpAsyncClient;
use Http\Message\MessageFactory;
use IPFS\Utils\CaseFormatter;
use Psr\Http\Message\ResponseInterface;
use Symfony\Component\DomCrawler\Crawler;

class ApiParser
{
    /**
     * @var HttpAsyncClient
     */
    private $client;
    /**
     * @var MessageFactory
     */
    private $messageFactory;
    /**
     * @var Crawler
     */
    private $crawler;

    public function __construct(HttpAsyncClient $client, MessageFactory $messageFactory, Crawler $crawler)
    {
        $this->client = $client;
        $this->messageFactory = $messageFactory;
        $this->crawler = $crawler;
    }

    public function build(string $url = 'https://ipfs.io/docs/api/', string $prefix = '#apiv0'): array
    {
        return $this->client
            ->sendAsyncRequest($this->messageFactory->createRequest('GET', $url))
            ->then(function (ResponseInterface $response) use ($prefix) {
                return $this->buildMethods($response, $prefix);
            })
            ->wait()
        ;
    }

    private function buildMethods(ResponseInterface $response, $prefix): array
    {
        $this->crawler->addHtmlContent($response->getBody()->getContents());
        $links = $this->crawler->filter('li a[href^="' . $prefix . '"]')->each(function (Crawler $node) {
            return $node->attr('href');
        });

        $config = [];
        foreach ($links as $link) {
            $anchor = $this->crawler->filter($link)->first();
            $description = $anchor->nextAll()->first()->getNode(0)->nodeName === 'p' ? $anchor->nextAll()->first()->text() : null;

            $methodConfig = [
                'parts'       => str_replace('/', ':', str_replace('/api/v0/', '', $anchor->text())),
                'description' => $description,
                'arguments'   => $this->parseArguments($anchor, $description ? 2 : 1),
            ];

            $nameParts = explode(':', $methodConfig['parts']);
            if (count($nameParts) > 1) {
                $class = array_shift($nameParts);
                $methodConfig['class'] = ucfirst(CaseFormatter::dashToCamel($class));
                $methodConfig['method'] = CaseFormatter::dashToCamel(implode('-', $nameParts));
            } else {
                $methodConfig['class'] = 'Basics';
                $methodConfig['method'] = CaseFormatter::dashToCamel($methodConfig['parts']);
            }

            $config[$methodConfig['class']][] = $methodConfig;
        }

        return $config;
    }

    private function parseArguments(Crawler $anchor, int $index): array
    {
        $argumentsRootNode = $anchor->nextAll()->eq($index)->first();

        if ($argumentsRootNode->getNode(0)->nodeName === 'ul') {
            $names = [];

            return $argumentsRootNode->filter('li')->each(function (Crawler $argument) use (&$names) {
                $description = $argument->filter('code')->first()->getNode(0)->nextSibling->textContent;
                $name = CaseFormatter::dashToCamel($argument->filter('code')->first()->text());
                if (!isset($names[$name])) {
                    $names[$name] = 0;
                } else {
                    ++$names[$name];
                }

                $config = [
                    'name'        => $names[$name] === 0 ? $name : $name . $names[$name],
                    'required'    => $argument->filter('strong')->count() > 0,
                    'description' => $this->parseDescription($description),
                    'default'     => $this->parseDefaultValue($description),
                    'type'        => $this->parseTypeHint($description),
                ];

                //fixup files
                if ('file' === $config['type']) {
                    $config['type'] = 'string';
                    $config['name'] = 'file';
                }

                return $config;
            });
        }

        return [];
    }

    private function parseDefaultValue(string $description)
    {
        preg_match('/Default\: \"(.+)\"/', $description, $default);

        if (count($default) === 2) {
            $default = $default[1];
            $default = CaseFormatter::stringToBool($default);

            return $default;
        }
    }

    private function parseDescription($description): string
    {
        preg_match('/\]\: (.+)/', $description, $default);

        if (count($default) > 1) {
            return substr($default[1], 0, strpos($default[1], '.') ?: strlen($default[1])) . '.';
        }
    }

    private function parseTypeHint(string $description): string
    {
        preg_match('/\[(.+)\]/', $description, $default);

        if (count($default) > 1) {
            return $default[1];
        }
    }
}