Jolicht\MarkdownCms\ContainerConfig

Complexity

Total Complexity

4

Size/Duplication

Total Lines	146
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes	1
Bugs	0	Features	1

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getConfig()	0	4	1
B	define()	0	102	1
A	modify()	0	3	1

<?php
/**
 * Lichtenwallner  (https://lichtenwallner.at)
 *
 * @see https://github.com/jolicht/markdown-cms for the canonical source repository
 * @license https://github.com/jolicht/markdown-cms/blob/master/LICENSE MIT
 * @copyright Copyright (c) Johannes Lichtenwallner
 */
declare(strict_types = 1);
namespace Jolicht\MarkdownCms;

use Aura\Di\ContainerConfigInterface;
use Aura\Di\Container;
use Jolicht\MarkdownCms\Action\BlogOverviewAction;
use Zend\Expressive\Template\TemplateRendererInterface;
use Jolicht\MarkdownCms\ContentType\ContentCreator;
use Jolicht\MarkdownCms\Markdown\MarkdownDocumentParser;
use Jolicht\MarkdownCms\Action\SingleBlogEntryAction;
use Mni\FrontYAML\Parser;
use Jolicht\MarkdownCms\Parser\ContentParser;
use Jolicht\MarkdownCms\Iterator\MarkdownFileIterator;
use Mni\FrontYAML\Bridge\CommonMark\CommonMarkParser;
use League\CommonMark\CommonMarkConverter;
use Jolicht\MarkdownCms\Command\ParseContentCommand;
use Jolicht\MarkdownCms\Parser\ParseContentExecutor;
use Jolicht\MarkdownCms\Parser\Observer\SaveContentConfigObserver;
use Zend\Config\Writer\PhpArray;
use Jolicht\MarkdownCms\Parser\Observer\SitemapObserver;
use Jolicht\MarkdownCms\Action\TagArchiveAction;
use Jolicht\MarkdownCms\ContentType\EntryParser;
use League\CommonMark\Environment;
use Jolicht\MarkdownCms\CommonMark\EnvironmentFactory;
use Jolicht\MarkdownCms\Markdown\Renderer\ImageRenderer;
use Jolicht\MarkdownCms\Middleware\RendererDefaultsMiddleware;
use Jolicht\MarkdownCms\Markdown\Renderer\ImageCaptionRenderer;

class ContainerConfig implements ContainerConfigInterface
{
    /**
     * Config
     *
     * @var array
     */
    private $config;

    /**
     * Constructor
     *
     * @param array $config
     */
    public function __construct(array $config)
    {
        $this->config = $config;
    }

    /**
     * Get config
     *
     * @return array
     */
    public function getConfig() : array
    {
        return $this->config;
    }

    /**
     * Define
     * {@inheritDoc}
     * @see \Aura\Di\ContainerConfigInterface::define()
     */
    public function define(Container $di)
    {
        $di->set(\Sabre\Xml\Writer::class, $di->lazyNew(\Sabre\Xml\Writer::class));

        $di->set(BlogOverviewAction::class, $di->lazyNew(BlogOverviewAction::class, [
            'templateRenderer' => $di->lazyGet(TemplateRendererInterface::class),
            'entryParser' => $di->lazyGet(EntryParser::class),
            'markdownCmsConfig' => $this->config['markdown_cms'],
        ]));

        $di->set(SingleBlogEntryAction::class, $di->lazyNew(SingleBlogEntryAction::class, [
            'templateRenderer' => $di->lazyGet(TemplateRendererInterface::class),
            'entryParser' => $di->lazyGet(EntryParser::class),
            'markdownCmsConfig' => $this->config['markdown_cms'],
        ]));

        $di->set(TagArchiveAction::class, $di->lazyNew(TagArchiveAction::class, [
            'templateRenderer' => $di->lazyGet(TemplateRendererInterface::class),
            'entryParser' => $di->lazyGet(EntryParser::class),
            'markdownCmsConfig' => $this->config['markdown_cms'],
        ]));

        $di->set(ContentCreator::class, $di->lazyNew(ContentCreator::class, [
            'options' => $this->config['markdown_cms']['options']
        ]));

        $di->set(ContentParser::class, $di->lazyNew(ContentParser::class, [
            'markdownFileIterator' => $di->lazyGet(MarkdownFileIterator::class),
            'contentCreator' => $di->lazyGet(ContentCreator::class),
            'mdDocumentParser' => $di->lazyGet(MarkdownDocumentParser::class),
            'markdownOptions' => $this->config['markdown_cms']['options'],
        ]));

        $di->set(MarkdownDocumentParser::class, $di->lazyNew(MarkdownDocumentParser::class, [
            'frontYamlParser' => $di->lazyGet(Parser::class)
        ]));

        $di->set(MarkdownFileIterator::class, $di->lazyNew(MarkdownFileIterator::class, [
            'iterator' => $di->lazyNew(\RecursiveIteratorIterator::class, [
                'iterator' => $di->lazyNew(\RecursiveDirectoryIterator::class, [
                    'path' => $this->config['markdown_cms']['options']['content_dir'],
                    'flags' => null
                ]),
                'mode' => null,
                'flags' => null,
            ]),
            'regex' => '/^.+\.md$/i',
            'mode' => \RecursiveRegexIterator::MATCH,
            'flags' => null,
            'preg_flags'=> null
        ]));

        $di->set(ImageRenderer::class, $di->lazyNew(ImageRenderer::class, [
            'captionRenderer' => $di->lazyGet(ImageCaptionRenderer::class),
            'urlTranslation' => $this->config['markdown_cms']['options']['url_translation'],
            'imagesBaseUrl' => $this->config['markdown_cms']['options']['images_base_url'],
            'imagesConfig' => $this->config['markdown_cms']['content']['images'],
        ]));


        $di->set(EnvironmentFactory::class, $di->lazyNew(EnvironmentFactory::class));
        $di->set(Environment::class, $di->lazyGetCall(EnvironmentFactory::class, '__invoke', $di));

        $di->set(Parser::class, $di->lazyNew(Parser::class, [
            'yamlParser' => null,
            'markdownParser' => $di->lazyNew(CommonMarkParser::class, [
                'commonMarkConverter' => $di->lazyNew(CommonMarkConverter::class, [
                    'environment' => $di->lazyGet(Environment::class)
                ])
            ])
        ]));

        $di->set(ParseContentCommand::class, $di->lazyNew(ParseContentCommand::class));
        $di->setters[ParseContentCommand::class] = [
            'setParseContentExecutor' => $di->lazyGet(ParseContentExecutor::class)
        ];

        $di->set(SaveContentConfigObserver::class, $di->lazyNew(SaveContentConfigObserver::class, [
            'configWriter' => $di->lazyNew(PhpArray::class),
            'targetPath' => $this->config['markdown_cms']['options']['content_config_path']
        ]));

        $di->set(SitemapObserver::class, $di->lazyNew(SitemapObserver::class, [
            'xmlWriter' => $di->lazyNew(\Sabre\Xml\Writer::class),
            'sitemapPath' => $this->config['markdown_cms']['options']['sitemap_path'],
            'baseUrl' => $this->config['markdown_cms']['options']['base_url']
        ]));

        $di->set(EntryParser::class, $di->lazyNew(EntryParser::class, [
            'contentCreator' => $di->lazyGet(ContentCreator::class),
            'mdDocumentParser' => $di->lazyGet(MarkdownDocumentParser::class),
            'config' => $this->config['markdown_cms']['content']['all'],
            'contentDir' => $this->config['markdown_cms']['options']['content_dir']
        ]));

        $di->set(RendererDefaultsMiddleware::class, $di->lazyNew(RendererDefaultsMiddleware::class, [
            'templateRenderer' => $di->lazyGet(TemplateRendererInterface::class),
            'baseUri' => $this->config['markdown_cms']['options']['base_url']
        ]));

        $di->set(ImageCaptionRenderer::class, $di->lazyNew(ImageCaptionRenderer::class));
    }

    /**
     * Modify
     * {@inheritDoc}
     * @see \Aura\Di\ContainerConfigInterface::modify()
     */
    public function modify(Container $di)
    {
    }
}