FilesManager::getFilesystem() - Code Metrics - Inspection of "Patch 1" - slawomirkania/class-generator-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#14)

unknown

created 2017-04-24 11:35 UTC

FilesManager::getFilesystem() A

↳ Parent: FilesManager

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	0

<?php

namespace SimpleEntityGeneratorBundle\Lib;

use SimpleEntityGeneratorBundle\Lib\Exceptions\FilesManagerException;
use SimpleEntityGeneratorBundle\Lib\Interfaces\DumpableInterface;
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
     * @throws FilesManagerException
     */
    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
     * @return DumpableInterface
     * @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)
    {
        if(!class_exists($item->getNamespace()) && !interface_exists($item->getNamespace())){
            throw new FilesManagerException(sprintf("Item source file does not exist: %s", $item->getNamespace()));
        }
        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
     * @return DumpableInterface
     * @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 SimpleEntityGeneratorBundle\Lib;
4
5			use SimpleEntityGeneratorBundle\Lib\Exceptions\FilesManagerException;
6			use SimpleEntityGeneratorBundle\Lib\Interfaces\DumpableInterface;
7			use ReflectionClass;
8			use Symfony\Component\Filesystem\Exception\IOExceptionInterface;
9			use Symfony\Component\Filesystem\Filesystem;
10			use Symfony\Component\HttpKernel\KernelInterface;
11
12			/**
13			* Files Manager
14			* - load structure from yaml
15			* - create directory if do not exist
16			* - update exisiting sources
17			*
18			* @author Sławomir Kania <[email protected]>
19			*/
20			class FilesManager
21			{
22
23			/**
24			* @var KernelInterface
25			*/
26			private $kernel = null;
27
28			/**
29			* CONSTR
30			*
31			* @param KernelInterface $kernel
32			*/
33			public function __construct(KernelInterface $kernel)
34			{
35			$this->kernel = $kernel;
36			}
37
38			/**
39			* Load class structure from yaml file to array array('{"data":"data"}', '{"data":"data"}')
40			* File has to be placed in to the directory src/{bundleName}/Resources/config/{fileName}
41			*
42			* @param string $bundleName
43			* @param string $fileName
44			* @return string
45			* @throws FilesManagerException
46			*/
47			public function loadFileContent($bundleName, $fileName)
48			{
49			$fileDirectory = sprintf('%s/../src/%s/Resources/config/%s', $this->getKernel()->getRootDir(), $bundleName, $fileName);
50			$result = file_get_contents($fileDirectory);
51			if (is_bool($result) && false === $result) {
52			throw new FilesManagerException(sprintf("Can not load file from: %s", $fileDirectory));
53			}
54
55			return $result;
56			}
57
58			/**
59			* Create or update item file
60			*
61			* @param DumpableInterface $item
62			* @return DumpableInterface
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			if(!class_exists($item->getNamespace()) && !interface_exists($item->getNamespace())){
111			throw new FilesManagerException(sprintf("Item source file does not exist: %s", $item->getNamespace()));
112			}
113			return new ReflectionClass($item->getNamespace());
114			}
115
116			/**
117			* @param DumpableInterface $item
118			* @return string
119			* @throws FilesManagerException
120			*/
121			public function getContentFromItemFile(DumpableInterface $item)
122			{
123			$this->checkItemFileExists($item);
124			$fullFileDirectory = $this->getItemDirectoryWithClassNameAndExtension($item);
125			return file_get_contents($fullFileDirectory);
126			}
127
128			/**
129			* @param string $path
130			* @return string
131			* @throws FilesManagerException
132			*/
133			public function loadContentFromFile($path)
134			{
135			$fs = $this->getFilesystem();
136			if (false === $fs->exists($path)) {
137			throw new FilesManagerException(sprintf("Template file %s does not exist", $path));
138			}
139
140			return file_get_contents($path);
141			}
142
143			/**
144			* @param DumpableInterface $item
145			* @return DumpableInterface
146			* @throws FilesManagerException
147			*/
148			protected function updateExistingFile(DumpableInterface $item)
149			{
150			$fs = $this->getFilesystem();
151			$content = $this->getContentFromItemFile($item);
152			$reflectionClass = $this->getReflectionClassForItem($item);
153			$updatedContent = $this->getStructureResolver()->getUpdatedItemSourceContent($content, $item, $reflectionClass);
154			if (false === empty($updatedContent)) {
155			$fs->dumpFile($this->getItemDirectoryWithClassNameAndExtension($item), $updatedContent);
156			}
157
158			return $item;
159			}
160
161			/**
162			* @param DumpableInterface $item
163			* @throws FilesManagerException
164			*/
165			protected function createDirectoryIfNeedAndFileAndDumpContent(DumpableInterface $item)
166			{
167			$fs = $this->getFilesystem();
168			$fullFileDirectory = $this->getItemDirectoryWithClassNameAndExtension($item);
169			$directory = $this->getItemDirectory($item);
170			if (false === $fs->exists($directory)) {
171			$fs->mkdir($directory);
172			}
173
174			$fs->touch($fullFileDirectory);
175			if (false === $fs->exists($fullFileDirectory)) {
176			throw new FilesManagerException("Structure file can not be created");
177			}
178
179			$content = $this->getRenderer()->render($item);
			0 ignored issues – show Documentation introduced 2017-04-24 11:43 UTC by Report Bug Copy Issue Report `$item` is of type `object<SimpleEntityGener...aces\DumpableInterface>`, but the function expects a `object<SimpleEntityGener...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...
180			if (false === empty($content)) {
181			$fs->dumpFile($fullFileDirectory, $content);
182			}
183			}
184
185			/**
186			* @return KernelInterface
187			*/
188			protected function getKernel()
189			{
190			return $this->kernel;
191			}
192
193			/**
194			* @return Filesystem
195			*/
196			protected function getFilesystem()
197			{
198			return new Filesystem();
199			}
200
201			/**
202			* @param DumpableInterface $item
203			* @return string
204			*/
205			protected function getItemDirectory(DumpableInterface $item)
206			{
207			return sprintf('%s/../src%s', $this->getKernel()->getRootDir(), $item->getDirectory());
208			}
209
210			/**
211			* @param DumpableInterface $item
212			* @return string
213			*/
214			protected function getItemDirectoryWithClassNameAndExtension(DumpableInterface $item)
215			{
216			return sprintf("%s/%s.php", $this->getItemDirectory($item), $item->getName());
217			}
218
219			/**
220			* @return StructureResolver
221			*/
222			protected function getStructureResolver()
223			{
224			return $this->getKernel()->getContainer()->get("seg.structure_resolver");
225			}
226
227			/**
228			* @return Renderer
229			*/
230			protected function getRenderer()
231			{
232			return $this->getKernel()->getContainer()->get("seg.renderer");
233			}
234			}
235

slawomirkania / class-generator-bundle

Pull Request — master (#14)

FilesManager::getFilesystem() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like