phpDocumentor / phpDocumentor

src/phpDocumentor/Plugin/Scrybe/Converter/Factory.php

<?php
declare(strict_types=1);

/**
 * This file is part of phpDocumentor.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * @author    Mike van Riel <mike.vanriel@naenius.com>
 * @copyright 2010-2018 Mike van Riel / Naenius (http://www.naenius.com)
 * @license   http://www.opensource.org/licenses/mit-license.php MIT
 * @link      http://phpdoc.org
 */

namespace phpDocumentor\Plugin\Scrybe\Converter;

use Monolog\Logger;
use phpDocumentor\Plugin\Scrybe\Converter\Exception\ConverterNotFoundException;

/**
 * This factory attempts to create a converter given an input and output format and return that.
 *
 * <code>
 *     use phpDocumentor\Plugin\Scrybe\Converter\ConverterFactory;
 *     use phpDocumentor\Plugin\Scrybe\Converter\Format\Format;
 *
 *     $converter_factory = new ConverterFactory();
 *     $converter = $converter_factory->get(
 *         Format::MARKDOWN, Format::HTML
 *     );
 * <code>
 *
 * @author Mike van Riel <mike.vanriel@naenius.com>
 */
class Factory
{
    /** @var Definition\Factory */
    protected $definition_factory = null;

    /** @var ConverterInterface[] */
    protected $converters = [];

    /** @var Logger */
    protected $logger;

    /**
     * Constructs a new factory.
     *
     * A Definition\Factory may optionally be passed to provide an alternate method of creating Definitions or to
     * construct the Definition\Factory with a different Format\Collection to influence the possible options.
     *
     * @param string[] $converters
     */
    public function __construct(array $converters, Definition\Factory $definition_factory, Logger $logger)
    {
        if ($definition_factory === null) {
            $definition_factory = $this->getDefaultDefinitionFactory();
        }

        $this->converters = $converters;

It seems like $converters of type array<integer,string> is incompatible with the declared type array<integer,object<phpDocumentor\Plugin\Scrybe\Converter\ConverterInterface>> of property $converters.

        $this->setDefinitionFactory($definition_factory);
        $this->logger = $logger;
    }

    /**
     * Retrieves a new instance of the converter necessary to convert the give input format to the given output format.
     *
     * @throws ConverterNotFoundException
     */
    public function get(string $input_format, string $output_format): ConverterInterface
    {
        $definition = $this->definition_factory->get($input_format, $output_format);

        foreach ($this->converters as $class => $formats) {
            if ([$input_format, $output_format] === $formats) {
                $assets = new Metadata\Assets();
                $assets->setLogger($this->logger);

                $toc = new Metadata\TableOfContents();
                $glossary = new Metadata\Glossary();

                /** @var ConverterInterface $converter */
                $converter = new $class($definition, $assets, $toc, $glossary);
                $converter->setLogger($this->logger);

                return $converter;
            }
        }

        throw new ConverterNotFoundException(
            'No converter could be found to convert from ' . $input_format . ' to ' . $output_format
        );
    }

    /**
     * Returns a list of supported input formats for the given output format.
     *
     * @param string $given_output_format A format definition per the constants in the Format class.
     *
     * @return string[] An array of format definitions per the constantst in the Format class.
     */
    public function getSupportedInputFormats(string $given_output_format): array
    {
        $result = [];
        foreach ($this->converters as $formats) {
            list($input_format, $output_format) = $formats;
            if ($given_output_format === $output_format) {
                $result[] = $input_format;
            }
        }

        return $result;
    }

    /**
     * Sets the converters for this Factory.
     *
     * @param ConverterInterface[] $converters
     */
    public function setConverters(array $converters): void
    {
        $this->converters = $converters;
    }

    /**
     * Method used to retrieve the default Definition Factory.
     *
     * This is used when the user has not provided their own definition factory in the constructor.
     *
     * @see __construct() where this method is used.
     */
    protected function getDefaultDefinitionFactory(): Definition\Factory
    {
        return new Definition\Factory(new Format\Collection());
    }

    /**
     * Sets the Definition Factory used to retrieve definitions from.
     */
    protected function setDefinitionFactory(Definition\Factory $definition_factory): void
    {
        $this->definition_factory = $definition_factory;
    }
}