RayAspectKernel::aspectConfiguration() - Code Metrics - ytake/Laravel-Aspect - Measure and Improve Code Quality continuously with Scrutinizer

RayAspectKernel::aspectConfiguration() B
last analyzed 2021-04-26 12:17 UTC

↳ Parent: RayAspectKernel

Complexity

Conditions	7
Paths	14

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	26
rs	8.5706
c	0
b	0
f	0
cc	7
nc	14
nop	0

<?php
declare(strict_types=1);

/**
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 *
 * This software consists of voluntary contributions made by many individuals
 * and is licensed under the MIT license.
 *
 * Copyright (c) 2015-2020 Yuuki Takezawa
 *
 */

namespace Ytake\LaravelAspect;

use Illuminate\Contracts\Container\Container;
use Illuminate\Filesystem\Filesystem;
use Ray\Aop\Compiler;
use Ray\Aop\Weaver;
use Ytake\LaravelAspect\Exception\ClassNotFoundException;
use Ytake\LaravelAspect\Modules\AspectModule;

use function class_exists;
use function count;
use function strval;
use function serialize;
use function unserialize;

/**
 * Class RayAspectKernel
 */
class RayAspectKernel implements AspectDriverInterface
{
    /** @var Container|\Illuminate\Container\Container */
    protected $app;

    /** @var array */
    protected $configure;

    /** @var Compiler */
    protected $compiler;

    /** @var Filesystem */
    protected $filesystem;

    /** @var bool */
    protected $cacheable = false;

    /** @var bool */
    protected $forceCompile = false;

    /** @var AspectModule[] */
    protected $modules = [];

    /** @var string */
    private $mapFile = 'aspect.map.serialize';

    /**
     * RayAspectKernel constructor.
     *
     * @param Container  $app
     * @param Filesystem $filesystem
     * @param array      $configure
     *
     * @throws ClassNotFoundException
     */
    public function __construct(Container $app, Filesystem $filesystem, array $configure)
    {
        $this->app = $app;
        $this->filesystem = $filesystem;
        $this->configure = $configure;
        $this->makeCompileDir();
        $this->makeCacheableDir();
        $this->registerAspectModule();
    }

    /**
     * @param string $module
     *
     * @throws ClassNotFoundException
     */
    public function register(string $module = null): void
    {
        if (!class_exists($module)) {
            throw new ClassNotFoundException($module);
        }
        $this->modules[] = new $module;
    }

    /**
     * weaving
     *
     * @throws \Doctrine\Common\Annotations\AnnotationException
     * @throws \Illuminate\Contracts\Filesystem\FileNotFoundException
     * @throws \ReflectionException
     */
    public function weave(): void
    {
        if (!count($this->modules)) {
            return;
        }
        $compiler = $this->getCompiler();
        $container = $this->containerAdaptor($this->app);
        foreach ($this->aspectConfiguration() as $class => $pointcuts) {
            $bind = (new AspectBind($this->filesystem, strval($this->configure['cache_dir']), $this->cacheable))
                ->bind($class, $pointcuts);
            $weaved = $this->forceCompile
                ? $compiler->compile($class, $bind)
                : (new Weaver($bind, (string)$this->configure['compile_dir']))->weave($class);
            $container->intercept($class, $bind, $weaved);
        }
    }

    /**
     * @param Container $container
     *
     * @return ContainerInterceptor
     */
    protected function containerAdaptor(Container $container): ContainerInterceptor
    {
        return new ContainerInterceptor($container, new AnnotateClass());
    }

    /**
     * @return Compiler
     * @throws \Doctrine\Common\Annotations\AnnotationException
     */
    protected function getCompiler(): Compiler
    {
        return new Compiler((string)$this->configure['compile_dir']);
    }

    /**
     * make source compile file directory
     */
    protected function makeCompileDir()
    {
        $this->makeDirectories(strval($this->configure['compile_dir']), 0775);
        $this->forceCompile = (bool)($this->configure['force_compile'] ?? false);
    }

    /**
     * make aspect cache directory
     *
     * @codeCoverageIgnore
     */
    protected function makeCacheableDir()
    {
        if ($this->configure['cache']) {
            $this->makeDirectories(strval($this->configure['cache_dir']), 0775);
            $this->cacheable = true;
        }
    }

    /**
     * @param string $dir
     * @param int    $mode
     */
    private function makeDirectories(string $dir, int $mode = 0777)
    {
        // @codeCoverageIgnoreStart
        if (!$this->filesystem->exists($dir)) {
            $this->filesystem->makeDirectory($dir, $mode, true);
        }
        // @codeCoverageIgnoreEnd
    }

    /**
     * register Aspect Module
     *
     * @throws ClassNotFoundException
     */
    protected function registerAspectModule()
    {
        if (isset($this->configure['modules'])) {
            foreach ($this->configure['modules'] as $module) {
                $this->register($module);
            }
        }
    }

    /**
     * @return array
     * @codeCoverageIgnore
     *
     * @throws \Illuminate\Contracts\Filesystem\FileNotFoundException
     */
    protected function aspectConfiguration(): array
    {
        $map = [];
        $file = $this->configure['cache_dir'] . "/{$this->mapFile}";
        if ($this->configure['cache']) {
            if ($this->filesystem->exists($file)) {
                foreach ($this->modules as $module) {
                    $module->registerPointCut()->configure($this->app);
                }

                return unserialize($this->filesystem->get($file));
            }
        }
        foreach ($this->modules as $module) {
            $pointcut = $module->registerPointCut()->configure($this->app);
            foreach ($module->target() as $class) {
                $map[$class][] = $pointcut;
            }
        }

        if ($this->configure['cache']) {
            $this->filesystem->put($file, serialize($map));
        }

        return $map;
    }
}


1			<?php
2			declare(strict_types=1);
3
4			/**
5			* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
6			* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
7			* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
8			* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
9			* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
10			* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
11			* THE SOFTWARE.
12			*
13			* This software consists of voluntary contributions made by many individuals
14			* and is licensed under the MIT license.
15			*
16			* Copyright (c) 2015-2020 Yuuki Takezawa
17			*
18			*/
19
20			namespace Ytake\LaravelAspect;
21
22			use Illuminate\Contracts\Container\Container;
23			use Illuminate\Filesystem\Filesystem;
24			use Ray\Aop\Compiler;
25			use Ray\Aop\Weaver;
26			use Ytake\LaravelAspect\Exception\ClassNotFoundException;
27			use Ytake\LaravelAspect\Modules\AspectModule;
28
29			use function class_exists;
30			use function count;
31			use function strval;
32			use function serialize;
33			use function unserialize;
34
35			/**
36			* Class RayAspectKernel
37			*/
38			class RayAspectKernel implements AspectDriverInterface
39			{
40			/** @var Container\|\Illuminate\Container\Container */
41			protected $app;
42
43			/** @var array */
44			protected $configure;
45
46			/** @var Compiler */
47			protected $compiler;
48
49			/** @var Filesystem */
50			protected $filesystem;
51
52			/** @var bool */
53			protected $cacheable = false;
54
55			/** @var bool */
56			protected $forceCompile = false;
57
58			/** @var AspectModule[] */
59			protected $modules = [];
60
61			/** @var string */
62			private $mapFile = 'aspect.map.serialize';
63
64			/**
65			* RayAspectKernel constructor.
66			*
67			* @param Container $app
68			* @param Filesystem $filesystem
69			* @param array $configure
70			*
71			* @throws ClassNotFoundException
72			*/
73			public function __construct(Container $app, Filesystem $filesystem, array $configure)
74			{
75			$this->app = $app;
76			$this->filesystem = $filesystem;
77			$this->configure = $configure;
78			$this->makeCompileDir();
79			$this->makeCacheableDir();
80			$this->registerAspectModule();
81			}
82
83			/**
84			* @param string $module
85			*
86			* @throws ClassNotFoundException
87			*/
88			public function register(string $module = null): void
89			{
90			if (!class_exists($module)) {
91			throw new ClassNotFoundException($module);
92			}
93			$this->modules[] = new $module;
94			}
95
96			/**
97			* weaving
98			*
99			* @throws \Doctrine\Common\Annotations\AnnotationException
100			* @throws \Illuminate\Contracts\Filesystem\FileNotFoundException
101			* @throws \ReflectionException
102			*/
103			public function weave(): void
104			{
105			if (!count($this->modules)) {
106			return;
107			}
108			$compiler = $this->getCompiler();
109			$container = $this->containerAdaptor($this->app);
110			foreach ($this->aspectConfiguration() as $class => $pointcuts) {
111			$bind = (new AspectBind($this->filesystem, strval($this->configure['cache_dir']), $this->cacheable))
112			->bind($class, $pointcuts);
113			$weaved = $this->forceCompile
114			? $compiler->compile($class, $bind)
115			: (new Weaver($bind, (string)$this->configure['compile_dir']))->weave($class);
116			$container->intercept($class, $bind, $weaved);
117			}
118			}
119
120			/**
121			* @param Container $container
122			*
123			* @return ContainerInterceptor
124			*/
125			protected function containerAdaptor(Container $container): ContainerInterceptor
126			{
127			return new ContainerInterceptor($container, new AnnotateClass());
128			}
129
130			/**
131			* @return Compiler
132			* @throws \Doctrine\Common\Annotations\AnnotationException
133			*/
134			protected function getCompiler(): Compiler
135			{
136			return new Compiler((string)$this->configure['compile_dir']);
137			}
138
139			/**
140			* make source compile file directory
141			*/
142			protected function makeCompileDir()
143			{
144			$this->makeDirectories(strval($this->configure['compile_dir']), 0775);
145			$this->forceCompile = (bool)($this->configure['force_compile'] ?? false);
146			}
147
148			/**
149			* make aspect cache directory
150			*
151			* @codeCoverageIgnore
152			*/
153			protected function makeCacheableDir()
154			{
155			if ($this->configure['cache']) {
156			$this->makeDirectories(strval($this->configure['cache_dir']), 0775);
157			$this->cacheable = true;
158			}
159			}
160
161			/**
162			* @param string $dir
163			* @param int $mode
164			*/
165			private function makeDirectories(string $dir, int $mode = 0777)
166			{
167			// @codeCoverageIgnoreStart
168			if (!$this->filesystem->exists($dir)) {
169			$this->filesystem->makeDirectory($dir, $mode, true);
170			}
171			// @codeCoverageIgnoreEnd
172			}
173
174			/**
175			* register Aspect Module
176			*
177			* @throws ClassNotFoundException
178			*/
179			protected function registerAspectModule()
180			{
181			if (isset($this->configure['modules'])) {
182			foreach ($this->configure['modules'] as $module) {
183			$this->register($module);
184			}
185			}
186			}
187
188			/**
189			* @return array
190			* @codeCoverageIgnore
191			*
192			* @throws \Illuminate\Contracts\Filesystem\FileNotFoundException
193			*/
194			protected function aspectConfiguration(): array
195			{
196			$map = [];
197			$file = $this->configure['cache_dir'] . "/{$this->mapFile}";
198			if ($this->configure['cache']) {
199			if ($this->filesystem->exists($file)) {
200			foreach ($this->modules as $module) {
201			$module->registerPointCut()->configure($this->app);
202			}
203
204			return unserialize($this->filesystem->get($file));
205			}
206			}
207			foreach ($this->modules as $module) {
208			$pointcut = $module->registerPointCut()->configure($this->app);
209			foreach ($module->target() as $class) {
210			$map[$class][] = $pointcut;
211			}
212			}
213
214			if ($this->configure['cache']) {
215			$this->filesystem->put($file, serialize($map));
216			}
217
218			return $map;
219			}
220			}
221

ytake / Laravel-Aspect

RayAspectKernel::aspectConfiguration() B last analyzed 2021-04-26 12:17 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

RayAspectKernel::aspectConfiguration() B
last analyzed 2021-04-26 12:17 UTC