AbstractFilesystemResolver::remove() - Code Metrics - liip/LiipImagineBundle - Measure and Improve Code Quality continuously with Scrutinizer

AbstractFilesystemResolver::remove() B
last analyzed 2021-01-05 12:31 UTC

↳ Parent: AbstractFilesystemResolver

Complexity

Conditions	8
Paths	7

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	29
rs	8.2114
cc	8
nc	7
nop	2

<?php

/*
 * This file is part of the `liip/LiipImagineBundle` project.
 *
 * (c) https://github.com/liip/LiipImagineBundle/graphs/contributors
 *
 * For the full copyright and license information, please view the LICENSE.md
 * file that was distributed with this source code.
 */

namespace Liip\ImagineBundle\Imagine\Cache\Resolver;

use Liip\ImagineBundle\Binary\BinaryInterface;
use Liip\ImagineBundle\Imagine\Cache\CacheManager;
use Liip\ImagineBundle\Imagine\Cache\CacheManagerAwareInterface;
use Symfony\Component\Filesystem\Exception\IOException;
use Symfony\Component\Filesystem\Filesystem;
use Symfony\Component\HttpFoundation\Request;

abstract class AbstractFilesystemResolver implements ResolverInterface, CacheManagerAwareInterface
{
    /**
     * @var Filesystem
     */
    protected $filesystem;

    /**
     * @var string
     */
    protected $basePath = '';

    /**
     * @var CacheManager
     */
    protected $cacheManager;

    /**
     * @var int
     */
    protected $folderPermissions = 0777;
    /**
     * @var Request
     */
    private $request;

    /**
     * Constructs a filesystem based cache resolver.
     */
    public function __construct(Filesystem $filesystem)
    {
        $this->filesystem = $filesystem;
    }

    /**
     * @param Request $request
     */
    public function setRequest(Request $request = null)
    {
        $this->request = $request;
    }

    public function setCacheManager(CacheManager $cacheManager)
    {
        $this->cacheManager = $cacheManager;
    }

    /**
     * Set the base path to.
     *
     * @param $basePath
     */
    public function setBasePath($basePath)
    {
        $this->basePath = $basePath;
    }

    /**
     * @param int $folderPermissions
     */
    public function setFolderPermissions($folderPermissions)
    {
        $this->folderPermissions = $folderPermissions;
    }

    /**
     * {@inheritdoc}
     */
    public function isStored($path, $filter)
    {
        return file_exists($this->getFilePath($path, $filter));
    }

    /**
     * {@inheritdoc}
     */
    public function store(BinaryInterface $binary, $path, $filter)
    {
        $filePath = $this->getFilePath($path, $filter);

        $dir = pathinfo($filePath, PATHINFO_DIRNAME);

        $this->makeFolder($dir);

        file_put_contents($filePath, $binary->getContent());
    }

    /**
     * {@inheritdoc}
     */
    public function remove(array $paths, array $filters)
    {
        if (empty($paths) && empty($filters)) {
            return;
        }

        // TODO: this logic has to be refactored.
        [$rootCachePath] = explode(current($filters), $this->getFilePath('whateverpath', current($filters)));


        if (empty($paths)) {
            $filtersCachePaths = [];
            foreach ($filters as $filter) {
                $filterCachePath = $rootCachePath.$filter;
                if (is_dir($filterCachePath)) {
                    $filtersCachePaths[] = $filterCachePath;
                }
            }

            $this->filesystem->remove($filtersCachePaths);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

            return;
        }

        foreach ($paths as $path) {
            foreach ($filters as $filter) {
                $this->filesystem->remove($this->getFilePath($path, $filter));
            }
        }
    }

    /**
     * @throws \LogicException
     *
     * @return Request
     */
    protected function getRequest()
    {
        if (false === $this->request) {
            throw new \LogicException('The request was not injected, inject it before using resolver.');
        }

        return $this->request;
    }

    /**
     * @param string $dir
     *
     * @throws \RuntimeException
     */
    protected function makeFolder($dir)
    {
        if (!is_dir($dir)) {
            $parent = \dirname($dir);
            try {
                $this->makeFolder($parent);
                $this->filesystem->mkdir($dir);
                $this->filesystem->chmod($dir, $this->folderPermissions);
            } catch (IOException $e) {
                throw new \RuntimeException(sprintf('Could not create directory %s', $dir), 0, $e);
            }
        }
    }

    /**
     * Return the local filepath.
     *
     * @param string $path   The resource path to convert
     * @param string $filter The name of the imagine filter
     *
     * @throws \Symfony\Component\HttpKernel\Exception\NotFoundHttpException
     *
     * @return string
     */
    abstract protected function getFilePath($path, $filter);
}


1			<?php
2
3			/*
4			* This file is part of the `liip/LiipImagineBundle` project.
5			*
6			* (c) https://github.com/liip/LiipImagineBundle/graphs/contributors
7			*
8			* For the full copyright and license information, please view the LICENSE.md
9			* file that was distributed with this source code.
10			*/
11
12			namespace Liip\ImagineBundle\Imagine\Cache\Resolver;
13
14			use Liip\ImagineBundle\Binary\BinaryInterface;
15			use Liip\ImagineBundle\Imagine\Cache\CacheManager;
16			use Liip\ImagineBundle\Imagine\Cache\CacheManagerAwareInterface;
17			use Symfony\Component\Filesystem\Exception\IOException;
18			use Symfony\Component\Filesystem\Filesystem;
19			use Symfony\Component\HttpFoundation\Request;
20
21			abstract class AbstractFilesystemResolver implements ResolverInterface, CacheManagerAwareInterface
22			{
23			/**
24			* @var Filesystem
25			*/
26			protected $filesystem;
27
28			/**
29			* @var string
30			*/
31			protected $basePath = '';
32
33			/**
34			* @var CacheManager
35			*/
36			protected $cacheManager;
37
38			/**
39			* @var int
40			*/
41			protected $folderPermissions = 0777;
42			/**
43			* @var Request
44			*/
45			private $request;
46
47			/**
48			* Constructs a filesystem based cache resolver.
49			*/
50			public function __construct(Filesystem $filesystem)
51			{
52			$this->filesystem = $filesystem;
53			}
54
55			/**
56			* @param Request $request
57			*/
58			public function setRequest(Request $request = null)
59			{
60			$this->request = $request;
61			}
62
63			public function setCacheManager(CacheManager $cacheManager)
64			{
65			$this->cacheManager = $cacheManager;
66			}
67
68			/**
69			* Set the base path to.
70			*
71			* @param $basePath
72			*/
73			public function setBasePath($basePath)
74			{
75			$this->basePath = $basePath;
76			}
77
78			/**
79			* @param int $folderPermissions
80			*/
81			public function setFolderPermissions($folderPermissions)
82			{
83			$this->folderPermissions = $folderPermissions;
84			}
85
86			/**
87			* {@inheritdoc}
88			*/
89			public function isStored($path, $filter)
90			{
91			return file_exists($this->getFilePath($path, $filter));
92			}
93
94			/**
95			* {@inheritdoc}
96			*/
97			public function store(BinaryInterface $binary, $path, $filter)
98			{
99			$filePath = $this->getFilePath($path, $filter);
100
101			$dir = pathinfo($filePath, PATHINFO_DIRNAME);
102
103			$this->makeFolder($dir);
104
105			file_put_contents($filePath, $binary->getContent());
106			}
107
108			/**
109			* {@inheritdoc}
110			*/
111			public function remove(array $paths, array $filters)
112			{
113			if (empty($paths) && empty($filters)) {
114			return;
115			}
116
117			// TODO: this logic has to be refactored.
118			[$rootCachePath] = explode(current($filters), $this->getFilePath('whateverpath', current($filters)));
			0 ignored issues – show Bug introduced 2018-02-18 09:49 UTC by Report Bug Copy Issue Report The variable `$rootCachePath` does not exist. Did you forget to declare it? This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug. Loading history...
119
120			if (empty($paths)) {
121			$filtersCachePaths = [];
122			foreach ($filters as $filter) {
123			$filterCachePath = $rootCachePath.$filter;
124			if (is_dir($filterCachePath)) {
125			$filtersCachePaths[] = $filterCachePath;
126			}
127			}
128
129			$this->filesystem->remove($filtersCachePaths);
			0 ignored issues – show Documentation introduced 2017-11-24 14:23 UTC by Report Bug Copy Issue Report `$filtersCachePaths` is of type `array`, but the function expects a `string\|object<Symfony\Co...nt\Filesystem\iterable>`. 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...
130
131			return;
132			}
133
134			foreach ($paths as $path) {
135			foreach ($filters as $filter) {
136			$this->filesystem->remove($this->getFilePath($path, $filter));
137			}
138			}
139			}
140
141			/**
142			* @throws \LogicException
143			*
144			* @return Request
145			*/
146			protected function getRequest()
147			{
148			if (false === $this->request) {
149			throw new \LogicException('The request was not injected, inject it before using resolver.');
150			}
151
152			return $this->request;
153			}
154
155			/**
156			* @param string $dir
157			*
158			* @throws \RuntimeException
159			*/
160			protected function makeFolder($dir)
161			{
162			if (!is_dir($dir)) {
163			$parent = \dirname($dir);
164			try {
165			$this->makeFolder($parent);
166			$this->filesystem->mkdir($dir);
167			$this->filesystem->chmod($dir, $this->folderPermissions);
168			} catch (IOException $e) {
169			throw new \RuntimeException(sprintf('Could not create directory %s', $dir), 0, $e);
170			}
171			}
172			}
173
174			/**
175			* Return the local filepath.
176			*
177			* @param string $path The resource path to convert
178			* @param string $filter The name of the imagine filter
179			*
180			* @throws \Symfony\Component\HttpKernel\Exception\NotFoundHttpException
181			*
182			* @return string
183			*/
184			abstract protected function getFilePath($path, $filter);
185			}
186

liip / LiipImagineBundle

AbstractFilesystemResolver::remove() B last analyzed 2021-01-05 12:31 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

AbstractFilesystemResolver::remove() B
last analyzed 2021-01-05 12:31 UTC