Stitcher::loadSite() - Code Metrics - Inspection of "Merge branch 'develop'" - pageon/stitcher-core - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( ad78b7...4e7b04 )

by Brent

created 2016-11-05 21:05 UTC

Stitcher::loadSite() B

↳ Parent: Stitcher

Complexity

Conditions	5
Paths	4

Size

Total Lines	25
Code Lines	15

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	5
eloc	15
c	0
b	0
f	0
nc	4
nop	0
dl	0
loc	25
rs	8.439

<?php

namespace brendt\stitcher;

use brendt\stitcher\element\Page;
use brendt\stitcher\exception\InvalidSiteException;
use brendt\stitcher\exception\TemplateNotFoundException;
use brendt\stitcher\factory\AdapterFactory;
use brendt\stitcher\factory\ProviderFactory;
use brendt\stitcher\factory\TemplateEngineFactory;
use Symfony\Component\Filesystem\Filesystem;
use Symfony\Component\Finder\Finder;
use Symfony\Component\Finder\SplFileInfo;
use Symfony\Component\Yaml\Exception\ParseException;
use Symfony\Component\Yaml\Yaml;
use brendt\stitcher\engine\TemplateEngine;
use brendt\stitcher\element\Site;

class Stitcher {

    /**
     * @var SplFileInfo[]
     */
    protected $templates;

    /**
     * @var ProviderFactory
     */
    protected $factory;

    /**
     * @var string
     */
    private $root;

    /**
     * @var string
     */
    private $compileDir;

    /**
     * @var string
     */
    private $publicDir;

    /**
     * @var ProviderFactory
     */
    private $providerFactory;

    /**
     * @var AdapterFactory
     */
    private $adapterFactory;

    /**
     * @var TemplateEngine
     */
    private $templateEngine;

    /**
     * Stitcher constructor.
     */
    public function __construct() {
        $this->root = Config::get('directories.src');
        $this->publicDir = Config::get('directories.public');
        $this->compileDir = Config::get('directories.cache');

        $this->providerFactory = Config::getDependency('factory.provider');
        $this->adapterFactory = Config::getDependency('factory.adapter');

        /** @var TemplateEngineFactory $templateEngineFactory */
        $templateEngineFactory = Config::getDependency('factory.template.engine');
        $this->templateEngine = $templateEngineFactory->getByType(Config::get('engine'));
    }

    /**
     * @return Site
     * @throws InvalidSiteException
     */
    public function loadSite() {
        $site = new Site();
        $finder = new Finder();
        $files = $finder->files()->in("{$this->root}/site")->name('*.yml');

        foreach ($files as $file) {
            try {
                $fileContents = Yaml::parse($file->getContents());
            } catch (ParseException $e) {
                throw new InvalidSiteException("{$file->getRelativePathname()}: {$e->getMessage()}");
            }

            if (!is_array($fileContents)) {
                continue;
            }

            foreach ($fileContents as $route => $data) {
                $page = new Page($route, $data);

                $site->addPage($page);
            }
        }

        return $site;
    }

    /**
     * @return SplFileInfo[]
     */
    public function loadTemplates() {
        $finder = new Finder();
        $templateExtension = $this->templateEngine->getTemplateExtension();
        $templateFolder = Config::get('directories.template') ? Config::get('directories.template') : Config::get('directories.src') . '/template';
        $files = $finder->files()->in($templateFolder)->name("*.{$templateExtension}");
        $templates = [];

        foreach ($files as $file) {
            $id = str_replace(".{$templateExtension}", '', $file->getRelativePathname());
            $templates[$id] = $file;
        }

        return $templates;
    }

    /**
     * @param string|array $routes
     * @param null         $filterValue
     *
     * @return array
     * @throws TemplateNotFoundException
     */
    public function stitch($routes = [], $filterValue = null) {
        $blanket = [];

        $site = $this->loadSite();
        $templates = $this->loadTemplates();

        if (is_string($routes)) {
            $routes = [$routes];
        }

        foreach ($site as $page) {
            $route = $page->getId();

            $skipRoute = count($routes) && !in_array($route, $routes);
            if ($skipRoute) {
                continue;
            }

            $templateIsset = isset($templates[$page->getTemplate()]);

            if (!$templateIsset) {
                if (isset($page['template'])) {
                    throw new TemplateNotFoundException("Template {$page['template']} not found.");
                } else {
                    throw new TemplateNotFoundException('No template was set.');
                }
            }

            $pages = $this->parseAdapters($page, $filterValue);

            $pageTemplate = $templates[$page->getTemplate()];
            foreach ($pages as $entryPage) {
                $entryPage = $this->parseVariables($entryPage);

                // Render each page
                $this->templateEngine->addTemplateVariables($entryPage->getVariables());
                $blanket[$entryPage->getId()] = $this->templateEngine->renderTemplate($pageTemplate);
                $this->templateEngine->clearTemplateVariables();
            }
        }

        return $blanket;
    }

    /**
     * @param Page $page
     * @param null $entryId
     *
     * @return Page[]
     */
    public function parseAdapters(Page $page, $entryId = null) {
        $pages = [];

        // TODO: this will bug with multiple adapters
        if (count($page->getAdapters())) {
            foreach ($page->getAdapters() as $type => $adapterConfig) {
                $adapter = $this->adapterFactory->getByType($type);

                if ($entryId) {
                    $pages = $adapter->transform($page, $entryId);
                } else {
                    $pages = $adapter->transform($page);
                }
            }
        } else {
            $pages = [$page->getId() => $page];
        }

        return $pages;
    }

    /**
     * @param Page $page
     *
     * @return Page
     */
    public function parseVariables(Page $page) {
        foreach ($page->getVariables() as $name => $value) {
            if ($page->isParsedField($name)) {
                continue;
            }

            $page
                ->setVariable($name, $this->getData($value))
                ->setParsedField($name);
        }

        return $page;
    }

    /**
     * @param array $blanket
     */
    public function save(array $blanket) {
        $fs = new Filesystem();

        if (!$fs->exists($this->publicDir)) {
            $fs->mkdir($this->publicDir);
        }

        foreach ($blanket as $path => $page) {
            if ($path === '/') {
                $path = 'index';
            }

            $fs->dumpFile($this->publicDir . "/{$path}.html", $page);
        }
    }

    private function getData($src) {
        $provider = $this->providerFactory->getProvider($src);

        if (!$provider) {
            return $src;
        }

        return $provider->parse($src);
    }

}




1			<?php
2
3			namespace brendt\stitcher;
4
5			use brendt\stitcher\element\Page;
6			use brendt\stitcher\exception\InvalidSiteException;
7			use brendt\stitcher\exception\TemplateNotFoundException;
8			use brendt\stitcher\factory\AdapterFactory;
9			use brendt\stitcher\factory\ProviderFactory;
10			use brendt\stitcher\factory\TemplateEngineFactory;
11			use Symfony\Component\Filesystem\Filesystem;
12			use Symfony\Component\Finder\Finder;
13			use Symfony\Component\Finder\SplFileInfo;
14			use Symfony\Component\Yaml\Exception\ParseException;
15			use Symfony\Component\Yaml\Yaml;
16			use brendt\stitcher\engine\TemplateEngine;
17			use brendt\stitcher\element\Site;
18
19			class Stitcher {
20
21			/**
22			* @var SplFileInfo[]
23			*/
24			protected $templates;
25
26			/**
27			* @var ProviderFactory
28			*/
29			protected $factory;
30
31			/**
32			* @var string
33			*/
34			private $root;
35
36			/**
37			* @var string
38			*/
39			private $compileDir;
40
41			/**
42			* @var string
43			*/
44			private $publicDir;
45
46			/**
47			* @var ProviderFactory
48			*/
49			private $providerFactory;
50
51			/**
52			* @var AdapterFactory
53			*/
54			private $adapterFactory;
55
56			/**
57			* @var TemplateEngine
58			*/
59			private $templateEngine;
60
61			/**
62			* Stitcher constructor.
63			*/
64			public function __construct() {
65			$this->root = Config::get('directories.src');
66			$this->publicDir = Config::get('directories.public');
67			$this->compileDir = Config::get('directories.cache');
68
69			$this->providerFactory = Config::getDependency('factory.provider');
70			$this->adapterFactory = Config::getDependency('factory.adapter');
71
72			/** @var TemplateEngineFactory $templateEngineFactory */
73			$templateEngineFactory = Config::getDependency('factory.template.engine');
74			$this->templateEngine = $templateEngineFactory->getByType(Config::get('engine'));
75			}
76
77			/**
78			* @return Site
79			* @throws InvalidSiteException
80			*/
81			public function loadSite() {
82			$site = new Site();
83			$finder = new Finder();
84			$files = $finder->files()->in("{$this->root}/site")->name('*.yml');
85
86			foreach ($files as $file) {
87			try {
88			$fileContents = Yaml::parse($file->getContents());
89			} catch (ParseException $e) {
90			throw new InvalidSiteException("{$file->getRelativePathname()}: {$e->getMessage()}");
91			}
92
93			if (!is_array($fileContents)) {
94			continue;
95			}
96
97			foreach ($fileContents as $route => $data) {
98			$page = new Page($route, $data);
99
100			$site->addPage($page);
101			}
102			}
103
104			return $site;
105			}
106
107			/**
108			* @return SplFileInfo[]
109			*/
110			public function loadTemplates() {
111			$finder = new Finder();
112			$templateExtension = $this->templateEngine->getTemplateExtension();
113			$templateFolder = Config::get('directories.template') ? Config::get('directories.template') : Config::get('directories.src') . '/template';
114			$files = $finder->files()->in($templateFolder)->name("*.{$templateExtension}");
115			$templates = [];
116
117			foreach ($files as $file) {
118			$id = str_replace(".{$templateExtension}", '', $file->getRelativePathname());
119			$templates[$id] = $file;
120			}
121
122			return $templates;
123			}
124
125			/**
126			* @param string\|array $routes
127			* @param null $filterValue
128			*
129			* @return array
130			* @throws TemplateNotFoundException
131			*/
132			public function stitch($routes = [], $filterValue = null) {
133			$blanket = [];
134
135			$site = $this->loadSite();
136			$templates = $this->loadTemplates();
137
138			if (is_string($routes)) {
139			$routes = [$routes];
140			}
141
142			foreach ($site as $page) {
143			$route = $page->getId();
144
145			$skipRoute = count($routes) && !in_array($route, $routes);
146			if ($skipRoute) {
147			continue;
148			}
149
150			$templateIsset = isset($templates[$page->getTemplate()]);
151
152			if (!$templateIsset) {
153			if (isset($page['template'])) {
154			throw new TemplateNotFoundException("Template {$page['template']} not found.");
155			} else {
156			throw new TemplateNotFoundException('No template was set.');
157			}
158			}
159
160			$pages = $this->parseAdapters($page, $filterValue);
161
162			$pageTemplate = $templates[$page->getTemplate()];
163			foreach ($pages as $entryPage) {
164			$entryPage = $this->parseVariables($entryPage);
165
166			// Render each page
167			$this->templateEngine->addTemplateVariables($entryPage->getVariables());
168			$blanket[$entryPage->getId()] = $this->templateEngine->renderTemplate($pageTemplate);
169			$this->templateEngine->clearTemplateVariables();
170			}
171			}
172
173			return $blanket;
174			}
175
176			/**
177			* @param Page $page
178			* @param null $entryId
179			*
180			* @return Page[]
181			*/
182			public function parseAdapters(Page $page, $entryId = null) {
183			$pages = [];
184
185			// TODO: this will bug with multiple adapters
186			if (count($page->getAdapters())) {
187			foreach ($page->getAdapters() as $type => $adapterConfig) {
188			$adapter = $this->adapterFactory->getByType($type);
189
190			if ($entryId) {
191			$pages = $adapter->transform($page, $entryId);
192			} else {
193			$pages = $adapter->transform($page);
194			}
195			}
196			} else {
197			$pages = [$page->getId() => $page];
198			}
199
200			return $pages;
201			}
202
203			/**
204			* @param Page $page
205			*
206			* @return Page
207			*/
208			public function parseVariables(Page $page) {
209			foreach ($page->getVariables() as $name => $value) {
210			if ($page->isParsedField($name)) {
211			continue;
212			}
213
214			$page
215			->setVariable($name, $this->getData($value))
216			->setParsedField($name);
217			}
218
219			return $page;
220			}
221
222			/**
223			* @param array $blanket
224			*/
225			public function save(array $blanket) {
226			$fs = new Filesystem();
227
228			if (!$fs->exists($this->publicDir)) {
229			$fs->mkdir($this->publicDir);
230			}
231
232			foreach ($blanket as $path => $page) {
233			if ($path === '/') {
234			$path = 'index';
235			}
236
237			$fs->dumpFile($this->publicDir . "/{$path}.html", $page);
238			}
239			}
240
241			private function getData($src) {
242			$provider = $this->providerFactory->getProvider($src);
243
244			if (!$provider) {
245			return $src;
246			}
247
248			return $provider->parse($src);
249			}
250
251			}
252
253
254

pageon / stitcher-core

Push — master ( ad78b7...4e7b04 )

Stitcher::loadSite() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like