FilesManager::loadContentFromFile() - Code Metrics - Inspection of "default templates - code completion in PhpStorm fo..." - slawomirkania/class-generator-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#8)

unknown

created 2017-02-08 13:35 UTC

FilesManager::loadContentFromFile() A

↳ Parent: Project

Complexity

Conditions	2
Paths	2

Size

Total Lines	9
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	9
rs	9.6666
c	0
b	0
f	0
cc	2
eloc	5
nc	2
nop	1

<?php

namespace HelloWordPl\SimpleEntityGeneratorBundle\Lib;

use HelloWordPl\SimpleEntityGeneratorBundle\Lib\Exceptions\FilesManagerException;
use HelloWordPl\SimpleEntityGeneratorBundle\Lib\Interfaces\DumpableInterface;
use HelloWordPl\SimpleEntityGeneratorBundle\Lib\Renderer;
use HelloWordPl\SimpleEntityGeneratorBundle\Lib\StructureResolver;
use ReflectionClass;
use Symfony\Component\Filesystem\Exception\IOExceptionInterface;
use Symfony\Component\Filesystem\Filesystem;
use Symfony\Component\HttpKernel\KernelInterface;

/**
 * Files Manager
 * - load structure from yaml
 * - create directory if do not exist
 * - update exisiting sources
 *
 * @author Sławomir Kania <[email protected]>
 */
class FilesManager
{

    /**
     * @var KernelInterface
     */
    private $kernel = null;

    /**
     * CONSTR
     *
     * @param KernelInterface $kernel
     */
    public function __construct(KernelInterface $kernel)
    {
        $this->kernel = $kernel;
    }

    /**
     * Load class structure from yaml file to array array('{"data":"data"}', '{"data":"data"}')
     * File has to be placed in to the directory src/{bundleName}/Resources/config/{fileName}
     *
     * @param string $bundleName
     * @param string $fileName
     * @return string
     */
    public function loadFileContent($bundleName, $fileName)
    {
        $fileDirectory = sprintf('%s/../src/%s/Resources/config/%s', $this->getKernel()->getRootDir(), $bundleName, $fileName);
        $result = file_get_contents($fileDirectory);
        if (is_bool($result) && false === $result) {
            throw new FilesManagerException(sprintf("Can not load file from: %s", $fileDirectory));
        }

        return $result;
    }

    /**
     * Create or update item file
     *
     * @param DumpableInterface $item
     * @throws FilesManagerException
     */
    public function dump(DumpableInterface $item)
    {
        try {
            if ($this->isItemFileExists($item)) {
                $this->updateExistingFile($item); // working on reference
            } else {
                $this->createDirectoryIfNeedAndFileAndDumpContent($item);
            }

            return $item;
        } catch (IOExceptionInterface $e) {
            throw new FilesManagerException("An error occurred while creating your directory at ".$e->getPath());
        }
    }

    /**
     * @param DumpableInterface $item
     * @return boolean
     */
    public function isItemFileExists(DumpableInterface $item)
    {
        $fs = $this->getFilesystem();
        $fullFileDirectory = $this->getItemDirectoryWithClassNameAndExtension($item);

        return $fs->exists($fullFileDirectory);
    }

    /**
     * @param DumpableInterface $item
     * @throws FilesManagerException
     */
    public function checkItemFileExists(DumpableInterface $item)
    {
        if (false === $this->isItemFileExists($item)) {
            throw new FilesManagerException(sprintf("Item source file does not exist: %s", $item->getNamespace()));
        }
    }

    /**
     * @param DumpableInterface $item
     * @return ReflectionClass
     * @throws FilesManagerException
     */
    public function getReflectionClassForItem(DumpableInterface $item)
    {
        $this->checkItemFileExists($item);
        return new ReflectionClass($item->getNamespace());
    }

    /**
     * @param DumpableInterface $item
     * @return string
     * @throws FilesManagerException
     */
    public function getContentFromItemFile(DumpableInterface $item)
    {
        $this->checkItemFileExists($item);
        $fullFileDirectory = $this->getItemDirectoryWithClassNameAndExtension($item);
        return file_get_contents($fullFileDirectory);
    }

    /**
     * @param string $path
     * @return string
     * @throws FilesManagerException
     */
    public function loadContentFromFile($path)
    {
        $fs = $this->getFilesystem();
        if (false === $fs->exists($path)) {
            throw new FilesManagerException(sprintf("Template file %s does not exist", $path));
        }

        return file_get_contents($path);
    }

    /**
     * @param DumpableInterface $item
     * @throws FilesManagerException
     */
    protected function updateExistingFile(DumpableInterface $item)
    {
        $fs = $this->getFilesystem();
        $content = $this->getContentFromItemFile($item);
        $reflectionClass = $this->getReflectionClassForItem($item);
        $updatedContent = $this->getStructureResolver()->getUpdatedItemSourceContent($content, $item, $reflectionClass);
        if (false === empty($updatedContent)) {
            $fs->dumpFile($this->getItemDirectoryWithClassNameAndExtension($item), $updatedContent);
        }

        return $item;
    }

    /**
     * @param DumpableInterface $item
     * @throws FilesManagerException
     */
    protected function createDirectoryIfNeedAndFileAndDumpContent(DumpableInterface $item)
    {
        $fs = $this->getFilesystem();
        $fullFileDirectory = $this->getItemDirectoryWithClassNameAndExtension($item);
        $directory = $this->getItemDirectory($item);
        if (false === $fs->exists($directory)) {
            $fs->mkdir($directory);
        }

        $fs->touch($fullFileDirectory);
        if (false === $fs->exists($fullFileDirectory)) {
            throw new FilesManagerException("Structure file can not be created");
        }

        $content = $this->getRenderer()->render($item);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        if (false === empty($content)) {
            $fs->dumpFile($fullFileDirectory, $content);
        }
    }

    /**
     * @return KernelInterface
     */
    protected function getKernel()
    {
        return $this->kernel;
    }

    /**
     * @return Filesystem
     */
    protected function getFilesystem()
    {
        return new Filesystem();
    }

    /**
     * @param DumpableInterface $item
     * @return string
     */
    protected function getItemDirectory(DumpableInterface $item)
    {
        return sprintf('%s/../src%s', $this->getKernel()->getRootDir(), $item->getDirectory());
    }

    /**
     * @param DumpableInterface $item
     * @return string
     */
    protected function getItemDirectoryWithClassNameAndExtension(DumpableInterface $item)
    {
        return sprintf("%s/%s.php", $this->getItemDirectory($item), $item->getName());
    }

    /**
     * @return StructureResolver
     */
    protected function getStructureResolver()
    {
        return $this->getKernel()->getContainer()->get("seg.structure_resolver");
    }

    /**
     * @return Renderer
     */
    protected function getRenderer()
    {
        return $this->getKernel()->getContainer()->get("seg.renderer");
    }
}


1			<?php
2
3			namespace HelloWordPl\SimpleEntityGeneratorBundle\Lib;
4
5			use HelloWordPl\SimpleEntityGeneratorBundle\Lib\Exceptions\FilesManagerException;
6			use HelloWordPl\SimpleEntityGeneratorBundle\Lib\Interfaces\DumpableInterface;
7			use HelloWordPl\SimpleEntityGeneratorBundle\Lib\Renderer;
8			use HelloWordPl\SimpleEntityGeneratorBundle\Lib\StructureResolver;
9			use ReflectionClass;
10			use Symfony\Component\Filesystem\Exception\IOExceptionInterface;
11			use Symfony\Component\Filesystem\Filesystem;
12			use Symfony\Component\HttpKernel\KernelInterface;
13
14			/**
15			* Files Manager
16			* - load structure from yaml
17			* - create directory if do not exist
18			* - update exisiting sources
19			*
20			* @author Sławomir Kania <[email protected]>
21			*/
22			class FilesManager
23			{
24
25			/**
26			* @var KernelInterface
27			*/
28			private $kernel = null;
29
30			/**
31			* CONSTR
32			*
33			* @param KernelInterface $kernel
34			*/
35			public function __construct(KernelInterface $kernel)
36			{
37			$this->kernel = $kernel;
38			}
39
40			/**
41			* Load class structure from yaml file to array array('{"data":"data"}', '{"data":"data"}')
42			* File has to be placed in to the directory src/{bundleName}/Resources/config/{fileName}
43			*
44			* @param string $bundleName
45			* @param string $fileName
46			* @return string
47			*/
48			public function loadFileContent($bundleName, $fileName)
49			{
50			$fileDirectory = sprintf('%s/../src/%s/Resources/config/%s', $this->getKernel()->getRootDir(), $bundleName, $fileName);
51			$result = file_get_contents($fileDirectory);
52			if (is_bool($result) && false === $result) {
53			throw new FilesManagerException(sprintf("Can not load file from: %s", $fileDirectory));
54			}
55
56			return $result;
57			}
58
59			/**
60			* Create or update item file
61			*
62			* @param DumpableInterface $item
63			* @throws FilesManagerException
64			*/
65			public function dump(DumpableInterface $item)
66			{
67			try {
68			if ($this->isItemFileExists($item)) {
69			$this->updateExistingFile($item); // working on reference
70			} else {
71			$this->createDirectoryIfNeedAndFileAndDumpContent($item);
72			}
73
74			return $item;
75			} catch (IOExceptionInterface $e) {
76			throw new FilesManagerException("An error occurred while creating your directory at ".$e->getPath());
77			}
78			}
79
80			/**
81			* @param DumpableInterface $item
82			* @return boolean
83			*/
84			public function isItemFileExists(DumpableInterface $item)
85			{
86			$fs = $this->getFilesystem();
87			$fullFileDirectory = $this->getItemDirectoryWithClassNameAndExtension($item);
88
89			return $fs->exists($fullFileDirectory);
90			}
91
92			/**
93			* @param DumpableInterface $item
94			* @throws FilesManagerException
95			*/
96			public function checkItemFileExists(DumpableInterface $item)
97			{
98			if (false === $this->isItemFileExists($item)) {
99			throw new FilesManagerException(sprintf("Item source file does not exist: %s", $item->getNamespace()));
100			}
101			}
102
103			/**
104			* @param DumpableInterface $item
105			* @return ReflectionClass
106			* @throws FilesManagerException
107			*/
108			public function getReflectionClassForItem(DumpableInterface $item)
109			{
110			$this->checkItemFileExists($item);
111			return new ReflectionClass($item->getNamespace());
112			}
113
114			/**
115			* @param DumpableInterface $item
116			* @return string
117			* @throws FilesManagerException
118			*/
119			public function getContentFromItemFile(DumpableInterface $item)
120			{
121			$this->checkItemFileExists($item);
122			$fullFileDirectory = $this->getItemDirectoryWithClassNameAndExtension($item);
123			return file_get_contents($fullFileDirectory);
124			}
125
126			/**
127			* @param string $path
128			* @return string
129			* @throws FilesManagerException
130			*/
131			public function loadContentFromFile($path)
132			{
133			$fs = $this->getFilesystem();
134			if (false === $fs->exists($path)) {
135			throw new FilesManagerException(sprintf("Template file %s does not exist", $path));
136			}
137
138			return file_get_contents($path);
139			}
140
141			/**
142			* @param DumpableInterface $item
143			* @throws FilesManagerException
144			*/
145			protected function updateExistingFile(DumpableInterface $item)
146			{
147			$fs = $this->getFilesystem();
148			$content = $this->getContentFromItemFile($item);
149			$reflectionClass = $this->getReflectionClassForItem($item);
150			$updatedContent = $this->getStructureResolver()->getUpdatedItemSourceContent($content, $item, $reflectionClass);
151			if (false === empty($updatedContent)) {
152			$fs->dumpFile($this->getItemDirectoryWithClassNameAndExtension($item), $updatedContent);
153			}
154
155			return $item;
156			}
157
158			/**
159			* @param DumpableInterface $item
160			* @throws FilesManagerException
161			*/
162			protected function createDirectoryIfNeedAndFileAndDumpContent(DumpableInterface $item)
163			{
164			$fs = $this->getFilesystem();
165			$fullFileDirectory = $this->getItemDirectoryWithClassNameAndExtension($item);
166			$directory = $this->getItemDirectory($item);
167			if (false === $fs->exists($directory)) {
168			$fs->mkdir($directory);
169			}
170
171			$fs->touch($fullFileDirectory);
172			if (false === $fs->exists($fullFileDirectory)) {
173			throw new FilesManagerException("Structure file can not be created");
174			}
175
176			$content = $this->getRenderer()->render($item);
			0 ignored issues – show Documentation introduced 2016-12-23 15:06 UTC by Report Bug Copy Issue Report `$item` is of type `object<HelloWordPl\Simpl...aces\DumpableInterface>`, but the function expects a `object<HelloWordPl\Simpl...es\RenderableInterface>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
177			if (false === empty($content)) {
178			$fs->dumpFile($fullFileDirectory, $content);
179			}
180			}
181
182			/**
183			* @return KernelInterface
184			*/
185			protected function getKernel()
186			{
187			return $this->kernel;
188			}
189
190			/**
191			* @return Filesystem
192			*/
193			protected function getFilesystem()
194			{
195			return new Filesystem();
196			}
197
198			/**
199			* @param DumpableInterface $item
200			* @return string
201			*/
202			protected function getItemDirectory(DumpableInterface $item)
203			{
204			return sprintf('%s/../src%s', $this->getKernel()->getRootDir(), $item->getDirectory());
205			}
206
207			/**
208			* @param DumpableInterface $item
209			* @return string
210			*/
211			protected function getItemDirectoryWithClassNameAndExtension(DumpableInterface $item)
212			{
213			return sprintf("%s/%s.php", $this->getItemDirectory($item), $item->getName());
214			}
215
216			/**
217			* @return StructureResolver
218			*/
219			protected function getStructureResolver()
220			{
221			return $this->getKernel()->getContainer()->get("seg.structure_resolver");
222			}
223
224			/**
225			* @return Renderer
226			*/
227			protected function getRenderer()
228			{
229			return $this->getKernel()->getContainer()->get("seg.renderer");
230			}
231			}
232

slawomirkania / class-generator-bundle

Pull Request — master (#8)

FilesManager::loadContentFromFile() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like