FolderContentCumulativeLoader::unserialize() - Code Metrics - orocrm/platform - Measure and Improve Code Quality continuously with Scrutinizer

FolderContentCumulativeLoader::unserialize() A
last analyzed 2016-05-19 07:51 UTC

↳ Parent: FolderContentCumulativeLoader

Complexity

Conditions	1
Paths	1

Size

Total Lines	9
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Metric	Value
dl	0
loc	9
rs	9.6666
cc	1
eloc	7
nc	1
nop	1

<?php

namespace Oro\Component\Config\Loader;

use Symfony\Component\PropertyAccess\PropertyAccess;
use Symfony\Component\PropertyAccess\PropertyAccessor;

use Oro\Component\Config\CumulativeResource;
use Oro\Component\Config\CumulativeResourceInfo;

/**
 * Loader that returns folder content as a list of found files, works recursively as deep
 * as it's configured by $maxNestingLevel param. There are two possible scenarios
 * how it organizes data loaded: plain and nested, this configured by $plainResultStructure param.
 * It should be used when need to trace directory structure/content updates
 * (including adding new file or removing previously found), but skip file modification.
 *
 * Examples:
 *   Plain mode
 *      Directory structure:
 *          relative path folder/
 *               file1.yml
 *               foo/
 *                  file2.yml
 *                  bar/
 *                      file3.yml
 *      Loaded result:
 *          [
 *              'relative path folder/file1.yml'
 *              'relative path folder/foo/file2.yml'
 *              'relative path folder/foo/bar/file2.yml'
 *          ]
 *  Nested mode
 *      Directory structure:
 *          relative path folder/
 *               file1.yml
 *               foo/
 *                  file2.yml
 *                  bar/
 *                      file3.yml
 *      Loaded result:
 *          [
 *              0     => 'relative path folder/file1.yml',
 *              'foo' => [
 *                   0     => 'relative path folder/foo/file2.yml',
 *                   'bar' => [
 *                      'relative path folder/foo/bar/file2.yml'
 *                   ]
 *              ]
 *          ]
 */
class FolderContentCumulativeLoader implements CumulativeResourceLoader
{
    /** @var string */
    protected $relativeFolderPath;

    /** @var string int */
    protected $maxNestingLevel;

    /** @var bool */
    protected $plainResultStructure;

    /** @var string[] */
    protected $fileExtensions;

    /** @var PropertyAccess */
    protected $propertyAccessor;

    /**
     * @param string   $relativeFolderPath
     * @param int      $maxNestingLevel      Pass -1 to unlimit, if you want to find files in exact path given pass 1
     * @param bool     $plainResultStructure Indicates whether result should be returned as flat array
     *                                       or should be nested tree depends on file position in directory hierarchy
     * @param string[] $fileExtensions       The extensions of files to be scanned
     */
    public function __construct(
        $relativeFolderPath,
        $maxNestingLevel = -1,
        $plainResultStructure = true,
        array $fileExtensions = []
    ) {
        $this->relativeFolderPath   = $relativeFolderPath;
        $this->maxNestingLevel      = $maxNestingLevel === -1 ? $maxNestingLevel : --$maxNestingLevel;
$answer = 42;

$correct = false;

$correct = (bool) $answer;
        $this->plainResultStructure = $plainResultStructure;
        $this->fileExtensions       = $fileExtensions;
        $this->resource             = 'Folder contents: ' . $relativeFolderPath;
class MyClass { }

$x = new MyClass();
$x->foo = true;
    }

    /**
     * {@inheritdoc}
     */
    public function serialize()
    {
        return serialize(
            [
                $this->relativeFolderPath,
                $this->maxNestingLevel,
                $this->plainResultStructure,
                $this->fileExtensions
            ]
        );
    }

    /**
     * {@inheritdoc}
     */
    public function unserialize($serialized)
    {
        list(
            $this->relativeFolderPath,
            $this->maxNestingLevel,
            $this->plainResultStructure,
            $this->fileExtensions
            ) = unserialize($serialized);
    }

    /**
     * {@inheritdoc}
     */
    public function getResource()
    {
        return $this->resource;
    }

    /**
     * {@inheritdoc}
     */
    public function load($bundleClass, $bundleDir, $bundleAppDir = '')
    {
        $dir           = $this->getDirectoryAbsolutePath($bundleDir);
        $bundleAppData = [];

        if (is_dir($bundleAppDir)) {
            $appDir        = $this->getResourcesDirectoryAbsolutePath($bundleAppDir);
            $bundleAppData = $this->getData($appDir);
        }

        $data = $this->mergeArray($bundleAppData, $this->getData($dir), $bundleAppDir, $bundleDir);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        if (empty($data)) {
            return null;
        }

        return new CumulativeResourceInfo($bundleClass, $this->getResource(), realpath($dir), $data);
    }

    /**
     * Recursively merges two arrays into one. If files have the same location,
     * the priority remains for the array $a
     *
     * @param array  $a            Array to merge
     * @param array  $b            Array, which merges with the previous one
     * @param string $bundleAppDir The bundle directory inside the application resources directory
     * @param string $bundleDir    The bundle root directory
     *
     * @return array              Merged array
     */
    protected function mergeArray(array $a, array $b, $bundleAppDir, $bundleDir)
    {
        foreach ($b as $k => $v) {
            if (is_int($k)) {
                foreach ($a as $val) {
                    if ($this->isFilePathEquals($val, $v, $bundleAppDir, $bundleDir)) {
                        continue 2;
                    }
                }
                $a[] = $v;
            } else {
                if (is_array($v) && isset($a[$k]) && is_array($a[$k])) {
                    $a[$k] = $this->mergeArray($a[$k], $v, $bundleAppDir, $bundleDir);
                } else {
                    $a[$k] = $v;
                }
            }
        }

        return $a;
    }

    /**
     * Equals end of files names from $bundleAppDir and $bundleDir
     *
     * @param string $bundleAppPath Path to the resource file from $resourceDir
     * @param string $bundlePath    Path to the resource file from $bundlePath
     * @param string $bundleAppDir  Directory to the priority resource
     * @param string $bundleDir     The bundle root directory
     *
     * @return bool
     */
    protected function isFilePathEquals($bundleAppPath, $bundlePath, $bundleAppDir, $bundleDir)
    {
        $a = str_replace($bundleDir . DIRECTORY_SEPARATOR . 'Resources', '', $bundlePath);
        $b = DIRECTORY_SEPARATOR !== '/'
            ? str_replace(str_replace('/', DIRECTORY_SEPARATOR, $bundleAppDir), '', $bundleAppPath)
            : str_replace($bundleAppDir, '', $bundleAppPath);

        return $a === $b;
    }

    /**
     * Get all data from the directory $dir
     *
     * @param $dir
     *
     * @return array
     */
    protected function getData($dir)
    {
        $realPath = realpath($dir);
        if (!is_dir($realPath)) {
            return [];
        }

        $data = [];
        if ($this->plainResultStructure) {
            $data = $this->getDirectoryContentsArray($realPath);
        } else {
            $iterator           = $this->getDirectoryContents($realPath);
            $absolutePathLength = strlen($realPath);

            foreach ($iterator as $file) {
                $pathName     = $file->getPathname();
                $relativePath = substr($pathName, $absolutePathLength + 1);
                $split        = explode(DIRECTORY_SEPARATOR, $relativePath);
                array_pop($split);

                if (!empty($split)) {
                    $path      = sprintf('[%s]', implode('][', $split));
                    $currValue = $this->getPropertyAccessor()->getValue($data, $path) ?: [];
                    $this->getPropertyAccessor()->setValue($data, $path, array_merge($currValue, [$pathName]));
                } else {
                    $data[] = $pathName;
                }
            }
        }

        return $data;
    }

    /**
     * {@inheritdoc}
     */
    public function registerFoundResource($bundleClass, $bundleDir, $bundleAppDir, CumulativeResource $resource)
    {
        $dir           = $this->getResourcesDirectoryAbsolutePath($bundleAppDir);
        $realPath      = realpath($dir);
        $bundleAppData = [];
        if (is_dir($realPath)) {
            $bundleAppData = $this->getDirectoryContentsArray($realPath);
        }

        $dir        = $this->getDirectoryAbsolutePath($bundleDir);
        $realPath   = realpath($dir);
        $bundleData = [];
        if (is_dir($realPath)) {
            $bundleData = $this->getDirectoryContentsArray($realPath);
        }

        foreach ($this->mergeArray($bundleAppData, $bundleData, $bundleAppDir, $bundleDir) as $filename) {
            $resource->addFound($bundleClass, $filename);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function isResourceFresh($bundleClass, $bundleDir, $bundleAppDir, CumulativeResource $resource, $timestamp)
    {
        $registeredFiles = $resource->getFound($bundleClass);
        $registeredFiles = array_flip($registeredFiles);

        // Check and remove data from $bundleAppDir resources directory
        if (is_dir($bundleAppDir)) {
            $dir      = $this->getResourcesDirectoryAbsolutePath($bundleAppDir);
            $realPath = realpath($dir);
            if (is_dir($realPath)) {
                $currentContents = $this->getDirectoryContentsArray($realPath);

                foreach ($currentContents as $filename) {
                    if (!$resource->isFound($bundleClass, $filename)) {
                        return false;
                    }

                    unset($registeredFiles[$filename]);
                }
            }
        }

        // Check and remove data from $bundleDir resources directory
        $dir      = $this->getDirectoryAbsolutePath($bundleDir);
        $realPath = realpath($dir);
        if (is_dir($realPath)) {
            $currentContents = $this->getDirectoryContentsArray($realPath);

            foreach ($currentContents as $filename) {
                if (!$resource->isFound($bundleClass, $filename)) {
                    return false;
                }

                unset($registeredFiles[$filename]);
            }
        }

        // case when entire dir was removed or some file was removed
        if (!empty($registeredFiles)) {
            return false;
        }

        return true;
    }

    /**
     * @param string $dir
     *
     * @return \SplFileInfo[]|\Iterator
     */
    protected function getDirectoryContents($dir)
    {
        $recursiveIterator = new \RecursiveIteratorIterator(
            new \RecursiveDirectoryIterator($dir, \FilesystemIterator::SKIP_DOTS),
            \RecursiveIteratorIterator::LEAVES_ONLY
        );
        $recursiveIterator->setMaxDepth($this->maxNestingLevel);
        $iterator = new \CallbackFilterIterator(
            $recursiveIterator,
            function (\SplFileInfo $file) {
                return empty($this->fileExtensions)
                    ? true
                    : in_array($file->getExtension(), $this->fileExtensions, true);
            }
        );

        return $iterator;
    }

    /**
     * @param string $dir
     *
     * @return array
     */
    protected function getDirectoryContentsArray($dir)
    {
        $result = [];

        $files = $this->getDirectoryContents($dir);
        foreach ($files as $file) {
            $result[] = $file->getPathname();
        }

        return $result;
    }

    /**
     * @param string $bundleDir
     *
     * @return string
     */
    protected function getDirectoryAbsolutePath($bundleDir)
    {
        return rtrim($bundleDir, DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR . $this->relativeFolderPath;
    }

    /**
     * @param string $bundleAppDir
     *
     * @return string
     */
    protected function getResourcesDirectoryAbsolutePath($bundleAppDir)
    {
        return
            rtrim($bundleAppDir, DIRECTORY_SEPARATOR) .
            DIRECTORY_SEPARATOR .
            preg_replace('/Resources\//', '', $this->relativeFolderPath, 1);
    }

    /**
     * Get PropertyAccessor
     *
     * @return PropertyAccessor
     */
    protected function getPropertyAccessor()
    {
        if (null === $this->propertyAccessor) {
            $this->propertyAccessor = PropertyAccess::createPropertyAccessor();

        }

        return $this->propertyAccessor;

    }
}


1		<?php
2
3		namespace Oro\Component\Config\Loader;
4
5		use Symfony\Component\PropertyAccess\PropertyAccess;
6		use Symfony\Component\PropertyAccess\PropertyAccessor;
7
8		use Oro\Component\Config\CumulativeResource;
9		use Oro\Component\Config\CumulativeResourceInfo;
10
11		/**
12		* Loader that returns folder content as a list of found files, works recursively as deep
13		* as it's configured by $maxNestingLevel param. There are two possible scenarios
14		* how it organizes data loaded: plain and nested, this configured by $plainResultStructure param.
15		* It should be used when need to trace directory structure/content updates
16		* (including adding new file or removing previously found), but skip file modification.
17		*
18		* Examples:
19		* Plain mode
20		* Directory structure:
21		* relative path folder/
22		* file1.yml
23		* foo/
24		* file2.yml
25		* bar/
26		* file3.yml
27		* Loaded result:
28		* [
29		* 'relative path folder/file1.yml'
30		* 'relative path folder/foo/file2.yml'
31		* 'relative path folder/foo/bar/file2.yml'
32		* ]
33		* Nested mode
34		* Directory structure:
35		* relative path folder/
36		* file1.yml
37		* foo/
38		* file2.yml
39		* bar/
40		* file3.yml
41		* Loaded result:
42		* [
43		* 0 => 'relative path folder/file1.yml',
44		* 'foo' => [
45		* 0 => 'relative path folder/foo/file2.yml',
46		* 'bar' => [
47		* 'relative path folder/foo/bar/file2.yml'
48		* ]
49		* ]
50		* ]
51		*/
52		class FolderContentCumulativeLoader implements CumulativeResourceLoader
53		{
54		/** @var string */
55		protected $relativeFolderPath;
56
57		/** @var string int */
58		protected $maxNestingLevel;
59
60		/** @var bool */
61		protected $plainResultStructure;
62
63		/** @var string[] */
64		protected $fileExtensions;
65
66		/** @var PropertyAccess */
67		protected $propertyAccessor;
68
69		/**
70		* @param string $relativeFolderPath
71		* @param int $maxNestingLevel Pass -1 to unlimit, if you want to find files in exact path given pass 1
72		* @param bool $plainResultStructure Indicates whether result should be returned as flat array
73		* or should be nested tree depends on file position in directory hierarchy
74		* @param string[] $fileExtensions The extensions of files to be scanned
75		*/
76		public function __construct(
77		$relativeFolderPath,
78		$maxNestingLevel = -1,
79		$plainResultStructure = true,
80		array $fileExtensions = []
81		) {
82		$this->relativeFolderPath = $relativeFolderPath;
83		$this->maxNestingLevel = $maxNestingLevel === -1 ? $maxNestingLevel : --$maxNestingLevel;
		0 ignored issues – show Documentation Bug introduced 2015-11-22 01:09 UTC by Report Bug Copy Issue Report The property `$maxNestingLevel` was declared of type `string`, but `$maxNestingLevel === -1 ...el : --$maxNestingLevel` is of type `integer`. Maybe add a type cast? This check looks for assignments to scalar types that may be of the wrong type. To ensure the code behaves as expected, it may be a good idea to add an explicit type cast. $answer = 42; $correct = false; $correct = (bool) $answer; Loading history...
84		$this->plainResultStructure = $plainResultStructure;
85		$this->fileExtensions = $fileExtensions;
86		$this->resource = 'Folder contents: ' . $relativeFolderPath;
		0 ignored issues – show Bug introduced 2015-11-22 01:09 UTC by Report Bug Copy Issue Report The property `resource` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
87		}
88
89		/**
90		* {@inheritdoc}
91		*/
92		public function serialize()
93		{
94		return serialize(
95		[
96		$this->relativeFolderPath,
97		$this->maxNestingLevel,
98		$this->plainResultStructure,
99		$this->fileExtensions
100		]
101		);
102		}
103
104		/**
105		* {@inheritdoc}
106		*/
107		public function unserialize($serialized)
108		{
109		list(
110		$this->relativeFolderPath,
111		$this->maxNestingLevel,
112		$this->plainResultStructure,
113		$this->fileExtensions
114		) = unserialize($serialized);
115		}
116
117		/**
118		* {@inheritdoc}
119		*/
120		public function getResource()
121		{
122		return $this->resource;
123		}
124
125		/**
126		* {@inheritdoc}
127		*/
128		public function load($bundleClass, $bundleDir, $bundleAppDir = '')
129		{
130		$dir = $this->getDirectoryAbsolutePath($bundleDir);
131		$bundleAppData = [];
132
133		if (is_dir($bundleAppDir)) {
134		$appDir = $this->getResourcesDirectoryAbsolutePath($bundleAppDir);
135		$bundleAppData = $this->getData($appDir);
136		}
137
138		$data = $this->mergeArray($bundleAppData, $this->getData($dir), $bundleAppDir, $bundleDir);
		0 ignored issues – show Bug introduced 2016-03-02 07:39 UTC by Report Bug Copy Issue Report It seems like `$bundleAppData` defined by `$this->getData($appDir)` on line `135` can also be of type `object`; however, `Oro\Component\Config\Loa...iveLoader::mergeArray()` does only seem to accept `array`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
139		if (empty($data)) {
140		return null;
141		}
142
143		return new CumulativeResourceInfo($bundleClass, $this->getResource(), realpath($dir), $data);
144		}
145
146		/**
147		* Recursively merges two arrays into one. If files have the same location,
148		* the priority remains for the array $a
149		*
150		* @param array $a Array to merge
151		* @param array $b Array, which merges with the previous one
152		* @param string $bundleAppDir The bundle directory inside the application resources directory
153		* @param string $bundleDir The bundle root directory
154		*
155		* @return array Merged array
156		*/
157		protected function mergeArray(array $a, array $b, $bundleAppDir, $bundleDir)
158		{
159		foreach ($b as $k => $v) {
160		if (is_int($k)) {
161		foreach ($a as $val) {
162		if ($this->isFilePathEquals($val, $v, $bundleAppDir, $bundleDir)) {
163		continue 2;
164		}
165		}
166		$a[] = $v;
167		} else {
168		if (is_array($v) && isset($a[$k]) && is_array($a[$k])) {
169		$a[$k] = $this->mergeArray($a[$k], $v, $bundleAppDir, $bundleDir);
170		} else {
171		$a[$k] = $v;
172		}
173		}
174		}
175
176		return $a;
177		}
178
179		/**
180		* Equals end of files names from $bundleAppDir and $bundleDir
181		*
182		* @param string $bundleAppPath Path to the resource file from $resourceDir
183		* @param string $bundlePath Path to the resource file from $bundlePath
184		* @param string $bundleAppDir Directory to the priority resource
185		* @param string $bundleDir The bundle root directory
186		*
187		* @return bool
188		*/
189		protected function isFilePathEquals($bundleAppPath, $bundlePath, $bundleAppDir, $bundleDir)
190		{
191		$a = str_replace($bundleDir . DIRECTORY_SEPARATOR . 'Resources', '', $bundlePath);
192		$b = DIRECTORY_SEPARATOR !== '/'
193		? str_replace(str_replace('/', DIRECTORY_SEPARATOR, $bundleAppDir), '', $bundleAppPath)
194		: str_replace($bundleAppDir, '', $bundleAppPath);
195
196		return $a === $b;
197		}
198
199		/**
200		* Get all data from the directory $dir
201		*
202		* @param $dir
203		*
204		* @return array
205		*/
206		protected function getData($dir)
207		{
208		$realPath = realpath($dir);
209		if (!is_dir($realPath)) {
210		return [];
211		}
212
213		$data = [];
214		if ($this->plainResultStructure) {
215		$data = $this->getDirectoryContentsArray($realPath);
216		} else {
217		$iterator = $this->getDirectoryContents($realPath);
218		$absolutePathLength = strlen($realPath);
219
220		foreach ($iterator as $file) {
221		$pathName = $file->getPathname();
222		$relativePath = substr($pathName, $absolutePathLength + 1);
223		$split = explode(DIRECTORY_SEPARATOR, $relativePath);
224		array_pop($split);
225
226		if (!empty($split)) {
227		$path = sprintf('[%s]', implode('][', $split));
228		$currValue = $this->getPropertyAccessor()->getValue($data, $path) ?: [];
229		$this->getPropertyAccessor()->setValue($data, $path, array_merge($currValue, [$pathName]));
230		} else {
231		$data[] = $pathName;
232		}
233		}
234		}
235
236		return $data;
237		}
238
239		/**
240		* {@inheritdoc}
241		*/
242		public function registerFoundResource($bundleClass, $bundleDir, $bundleAppDir, CumulativeResource $resource)
243		{
244		$dir = $this->getResourcesDirectoryAbsolutePath($bundleAppDir);
245		$realPath = realpath($dir);
246		$bundleAppData = [];
247		if (is_dir($realPath)) {
248		$bundleAppData = $this->getDirectoryContentsArray($realPath);
249		}
250
251		$dir = $this->getDirectoryAbsolutePath($bundleDir);
252		$realPath = realpath($dir);
253		$bundleData = [];
254		if (is_dir($realPath)) {
255		$bundleData = $this->getDirectoryContentsArray($realPath);
256		}
257
258		foreach ($this->mergeArray($bundleAppData, $bundleData, $bundleAppDir, $bundleDir) as $filename) {
259		$resource->addFound($bundleClass, $filename);
260		}
261		}
262
263		/**
264		* {@inheritdoc}
265		*/
266		public function isResourceFresh($bundleClass, $bundleDir, $bundleAppDir, CumulativeResource $resource, $timestamp)
267		{
268		$registeredFiles = $resource->getFound($bundleClass);
269		$registeredFiles = array_flip($registeredFiles);
270
271		// Check and remove data from $bundleAppDir resources directory
272		if (is_dir($bundleAppDir)) {
273		$dir = $this->getResourcesDirectoryAbsolutePath($bundleAppDir);
274		$realPath = realpath($dir);
275	View Code Duplication	if (is_dir($realPath)) {
276		$currentContents = $this->getDirectoryContentsArray($realPath);
277
278		foreach ($currentContents as $filename) {
279		if (!$resource->isFound($bundleClass, $filename)) {
280		return false;
281		}
282
283		unset($registeredFiles[$filename]);
284		}
285		}
286		}
287
288		// Check and remove data from $bundleDir resources directory
289		$dir = $this->getDirectoryAbsolutePath($bundleDir);
290		$realPath = realpath($dir);
291	View Code Duplication	if (is_dir($realPath)) {
292		$currentContents = $this->getDirectoryContentsArray($realPath);
293
294		foreach ($currentContents as $filename) {
295		if (!$resource->isFound($bundleClass, $filename)) {
296		return false;
297		}
298
299		unset($registeredFiles[$filename]);
300		}
301		}
302
303		// case when entire dir was removed or some file was removed
304		if (!empty($registeredFiles)) {
305		return false;
306		}
307
308		return true;
309		}
310
311		/**
312		* @param string $dir
313		*
314		* @return \SplFileInfo[]\|\Iterator
315		*/
316		protected function getDirectoryContents($dir)
317		{
318		$recursiveIterator = new \RecursiveIteratorIterator(
319		new \RecursiveDirectoryIterator($dir, \FilesystemIterator::SKIP_DOTS),
320		\RecursiveIteratorIterator::LEAVES_ONLY
321		);
322		$recursiveIterator->setMaxDepth($this->maxNestingLevel);
323		$iterator = new \CallbackFilterIterator(
324		$recursiveIterator,
325		function (\SplFileInfo $file) {
326		return empty($this->fileExtensions)
327		? true
328		: in_array($file->getExtension(), $this->fileExtensions, true);
329		}
330		);
331
332		return $iterator;
333		}
334
335		/**
336		* @param string $dir
337		*
338		* @return array
339		*/
340		protected function getDirectoryContentsArray($dir)
341		{
342		$result = [];
343
344		$files = $this->getDirectoryContents($dir);
345		foreach ($files as $file) {
346		$result[] = $file->getPathname();
347		}
348
349		return $result;
350		}
351
352		/**
353		* @param string $bundleDir
354		*
355		* @return string
356		*/
357		protected function getDirectoryAbsolutePath($bundleDir)
358		{
359		return rtrim($bundleDir, DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR . $this->relativeFolderPath;
360		}
361
362		/**
363		* @param string $bundleAppDir
364		*
365		* @return string
366		*/
367		protected function getResourcesDirectoryAbsolutePath($bundleAppDir)
368		{
369		return
370		rtrim($bundleAppDir, DIRECTORY_SEPARATOR) .
371		DIRECTORY_SEPARATOR .
372		preg_replace('/Resources\//', '', $this->relativeFolderPath, 1);
373		}
374
375		/**
376		* Get PropertyAccessor
377		*
378		* @return PropertyAccessor
379		*/
380		protected function getPropertyAccessor()
381		{
382		if (null === $this->propertyAccessor) {
383		$this->propertyAccessor = PropertyAccess::createPropertyAccessor();
		0 ignored issues – show Documentation Bug introduced 2015-11-22 01:09 UTC by Report Bug Copy Issue Report It seems like `\Symfony\Component\Prope...reatePropertyAccessor()` of type `object<Symfony\Component...ccess\PropertyAccessor>` is incompatible with the declared type `object<Symfony\Component...yAccess\PropertyAccess>` of property `$propertyAccessor`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
384		}
385
386		return $this->propertyAccessor;
		0 ignored issues – show Bug Compatibility introduced 2016-03-02 07:39 UTC by Report Bug Copy Issue Report The expression `$this->propertyAccessor;` of type `Symfony\Component\Proper...tyAccess\PropertyAccess` adds the type `Symfony\Component\PropertyAccess\PropertyAccess` to the return on line 386 which is incompatible with the return type documented by `Oro\Component\Config\Loa...er::getPropertyAccessor` of type `Symfony\Component\PropertyAccess\PropertyAccessor`. Loading history...
387		}
388		}
389

orocrm / platform

FolderContentCumulativeLoader::unserialize() A last analyzed 2016-05-19 07:51 UTC

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like

FolderContentCumulativeLoader::unserialize() A
last analyzed 2016-05-19 07:51 UTC