Theme::exists() - Code Metrics - Inspection of "php scrutinzer 2" - maestriam/samurai - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Branch — feature/refactoring-samurai (8cc7c1)

by Giuliano

created 2021-07-10 20:41 UTC

Theme::exists() A

↳ Parent: Theme

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

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

<?php

namespace Maestriam\Samurai\Entities;

use Illuminate\Support\Facades\File;
use Maestriam\Samurai\Entities\Foundation;
use Maestriam\Samurai\Foundation\DirectiveFinder;
use Maestriam\Samurai\Exceptions\ThemeExistsException;
use Maestriam\Samurai\Exceptions\ThemeNotFoundException;
use Maestriam\Samurai\Contracts\Entities\ThemeContract;

class Theme extends Foundation implements ThemeContract
{
    /**
     * Nome do distribuidor do tema/nome do tema
     * Ex: vendor/theme
     *
     * @var Vendor
     */
    protected Vendor $vendorInstance;

    /**
     * Informações do autor do tema
     *
     * @var Author
     */
    protected Author $authorInstance;

    /**
     * Controle de caminhos de tema
     * 
     * @var Structure
     */    
    protected Structure $structureInstance;

    /**
     * Controle do arquivo composer.json do tema
     * 
     * @var Composer
     */
    protected Composer $composerInstance;

    /**
     * Regras de negócio sobre busca de diretivas dentro do tema.  
     *
     * @var DirectiveFinder
     */
    protected DirectiveFinder $finderInstance;

    /**
     * Regras de negócio do tema
     *
     * @param string $package
     */
    public function __construct(string $package)
    {
        $this->init($package);
    }
    
    /**
     * {@inheritDoc}
     */
    public function vendor() : Vendor
    {
        return $this->vendorInstance;
    }

    /**
     * {@inheritDoc}
     */
    public function author(string $author = null) : Author|Theme
    {
        if (! $author) {
            return $this->getAuthor();
        }

        return $this->setAuthor($author);
    }

    /**
     * {@inheritDoc}
     */
    public function name() : string
    {
        return $this->vendor()->name();
    }

    /**
     * {@inheritDoc}
     */
    public function namespace() : string
    {
        return $this->vendor()->namespace();
    }

    /**
     * {@inheritDoc}
     */
    public function paths() : Structure
    {
        return $this->structureInstance;
    }

    /**
     * {@inheritDoc}
     */
    public function package() : string
    {
        return $this->vendor()->package();
    }

    /**
     * {@inheritDoc}
     */
    public function exists() : bool
    {
        return $this->composer()->exists();
    }

    /**
     * {@inheritDoc}
     */
    public function preview() : string 
    {
        return $this->composer()->preview();
    }

    /**
     * {@inheritDoc}
     */
    public function find() : ?Theme
    {
        if (! $this->exists()) {
            return null;
        }

        return $this->import();
    }
    
    /**
     * {@inheritDoc}
     */
    public function description(string $description = null) : Theme|string
    {
        if (! $description) {
            return $this->composer()->description();
        }
        
        $this->composer()->description($description);

        return $this;
    }    

    /**
     * {@inheritDoc}
     */
    public function make() : Theme
    {
        if ($this->exists()) {
            throw new ThemeExistsException($this->package());
        }

        $this->structure()->init();
        
        $this->composer()->create()->load();

        return $this;
    }

    /**
     * {@inheritDoc}
     */
    public function findOrCreate() : Theme
    {
        if (! $this->exists()) {
            return $this->make();
        }

        return $this->import();
    }

    /**
     * {@inheritDoc}
     */
    public function use() : Theme
    {
        $this->guard();

        $this->register();

        return $this;
    }

    /**
     * {@inheritDoc}
     */
    public function include(string $sentence) : Includer
    {
        return $this->finder()->include($sentence);
    }

    /**
     * {@inheritDoc}
     */
    public function component(string $sentence) : Component
    {
        return $this->finder()->component($sentence);
    }

    /**
     * {@inheritDoc}
     */
    public function directives() : array
    {        
        return $this->finder()->all();
    }

    /**
     * {@inheritDoc}
     */
    public function load() : Theme
    {
        foreach ($this->directives() as $directive) {    
            $directive->load();
        }

        return $this;
    }

    /**
     * {@inheritDoc}
     */
    public function publish() : bool
    {
        if (! $this->exists()) {
            throw new ThemeNotFoundException($this->package());
        }

        $from = $this->structure()->assets();
        $to   = $this->structure()->public();

        File::copyDirectory($from, $to);

        return (is_dir($to)) ? true : false;
    }
    
    /**
     * {@inheritDoc}
     */
    public function url(string $file = null) : string
    {
        $domain  = $this->env()->get('APP_URL');
        $public  = $this->config()->publishable();
        $package = $this->package();

        $file =  '/' . $file ?? '';
        $file = str_replace("'", "", $file);

        return sprintf('%s/%s/%s%s', $domain, $public, $package, $file);
    }

    /**
     * Registra o nome do pacote do tema no arquivo de ambiente 
     * do projeto Laravel
     *
     * @return void
     */
    private function register()
    {
        $name = $this->package();

        $key = $this->config()->env();

        $this->env()->set($key, $name);
    }

    /**
     * Inicia as regras de negócio do tema  
     * Se o tema já existir dentro do projeto, carrega suas informações  
     *
     * @param  string $package
     * @return Theme
     */
    private function init(string $package) : Theme
    {
        $this->setVendor($package)
            ->setDirectiveFinder()
            ->setComposer()
            ->setStructure();

        if ($this->exists()) {
            return $this->import();
        }        

        return $this;
    }

    /**
     * Carrega as informações vindas do arquivo composer.json
     * para dentro da instância  
     *
     * @return Theme
     */
    private function import() : Theme
    {
        $info = $this->composer()->load()->info();

        $this->author()->name($info->authors[0]->name);
        $this->author()->email($info->authors[0]->email);

        return $this;
    }

    /**
     * Define o nome do vendor do tema.  
     *
     * @return Theme
     */
    private function setVendor(string $vendor) : Theme
    {
        $this->vendorInstance = new Vendor($vendor);

        return $this;
    }

    /**
     * Define as informações do autor do tema
     *
     * @param  string $author
     * @return Theme
     */
    private function setAuthor(string $author) : Theme
    {
        $this->authorInstance = new Author($author);
        
        return $this;
    }

    /**
     * Retorna as informações do autor do tema
     *
     * @return Author
     */
    private function getAuthor() : Author
    {
        return $this->authorInstance ?? new Author();
    }

    /**
     * Define a instância de estrutura de diretórios do tema
     *
     * @return Theme
     */
    private function setStructure() : Theme
    {
        $vendor = $this->vendor();

        $this->structureInstance = new Structure($vendor);

        return $this;
    }

    /**
     * Retorna a instância de estrutura do tema
     *
     * @return Structure
     */
    private function structure() : Structure
    {
        return $this->structureInstance;
    }

    /**
     * Define o composer do tema
     *
     * @return Theme
     */
    private function setComposer() : Theme
    {
        $this->composerInstance = new Composer($this);

        return $this;
    }

    /**
     * Retorna a instância do composer do tema
     *
     * @return Theme
     */
    private function composer() : Composer
    {
        return $this->composerInstance;

    }

    /**
     * Define a instância de busca de diretivas dentro do tema.  
     *
     * @return Theme
     */
    private function setDirectiveFinder() : Theme
    {
        $this->finderInstance = new DirectiveFinder($this);

        return $this;
    }

    /**
     * Retorna a instância de busca de diretivas dentro do tema.  
     *
     * @return DirectiveFinder
     */
    private function finder() : DirectiveFinder
    {
        return $this->finderInstance;
    }

    /**
     * Faz as devidas validações sobre o tema.  
     * Se existir algo incompátivel, emite um Exception.  
     *
     * @return void
     */
    private function guard() : void
    {
        if ($this->exists()) {
            return; 
        }

        throw new ThemeNotFoundException($this->package());
    }

}


1			<?php
2
3			namespace Maestriam\Samurai\Entities;
4
5			use Illuminate\Support\Facades\File;
6			use Maestriam\Samurai\Entities\Foundation;
7			use Maestriam\Samurai\Foundation\DirectiveFinder;
8			use Maestriam\Samurai\Exceptions\ThemeExistsException;
9			use Maestriam\Samurai\Exceptions\ThemeNotFoundException;
10			use Maestriam\Samurai\Contracts\Entities\ThemeContract;
11
12			class Theme extends Foundation implements ThemeContract
13			{
14			/**
15			* Nome do distribuidor do tema/nome do tema
16			* Ex: vendor/theme
17			*
18			* @var Vendor
19			*/
20			protected Vendor $vendorInstance;
21
22			/**
23			* Informações do autor do tema
24			*
25			* @var Author
26			*/
27			protected Author $authorInstance;
28
29			/**
30			* Controle de caminhos de tema
31			*
32			* @var Structure
33			*/
34			protected Structure $structureInstance;
35
36			/**
37			* Controle do arquivo composer.json do tema
38			*
39			* @var Composer
40			*/
41			protected Composer $composerInstance;
42
43			/**
44			* Regras de negócio sobre busca de diretivas dentro do tema.
45			*
46			* @var DirectiveFinder
47			*/
48			protected DirectiveFinder $finderInstance;
49
50			/**
51			* Regras de negócio do tema
52			*
53			* @param string $package
54			*/
55			public function __construct(string $package)
56			{
57			$this->init($package);
58			}
59
60			/**
61			* {@inheritDoc}
62			*/
63			public function vendor() : Vendor
64			{
65			return $this->vendorInstance;
66			}
67
68			/**
69			* {@inheritDoc}
70			*/
71			public function author(string $author = null) : Author\|Theme
72			{
73			if (! $author) {
74			return $this->getAuthor();
75			}
76
77			return $this->setAuthor($author);
78			}
79
80			/**
81			* {@inheritDoc}
82			*/
83			public function name() : string
84			{
85			return $this->vendor()->name();
86			}
87
88			/**
89			* {@inheritDoc}
90			*/
91			public function namespace() : string
92			{
93			return $this->vendor()->namespace();
94			}
95
96			/**
97			* {@inheritDoc}
98			*/
99			public function paths() : Structure
100			{
101			return $this->structureInstance;
102			}
103
104			/**
105			* {@inheritDoc}
106			*/
107			public function package() : string
108			{
109			return $this->vendor()->package();
110			}
111
112			/**
113			* {@inheritDoc}
114			*/
115			public function exists() : bool
116			{
117			return $this->composer()->exists();
118			}
119
120			/**
121			* {@inheritDoc}
122			*/
123			public function preview() : string
124			{
125			return $this->composer()->preview();
126			}
127
128			/**
129			* {@inheritDoc}
130			*/
131			public function find() : ?Theme
132			{
133			if (! $this->exists()) {
134			return null;
135			}
136
137			return $this->import();
138			}
139
140			/**
141			* {@inheritDoc}
142			*/
143			public function description(string $description = null) : Theme\|string
144			{
145			if (! $description) {
146			return $this->composer()->description();
147			}
148
149			$this->composer()->description($description);
150
151			return $this;
152			}
153
154			/**
155			* {@inheritDoc}
156			*/
157			public function make() : Theme
158			{
159			if ($this->exists()) {
160			throw new ThemeExistsException($this->package());
161			}
162
163			$this->structure()->init();
164
165			$this->composer()->create()->load();
166
167			return $this;
168			}
169
170			/**
171			* {@inheritDoc}
172			*/
173			public function findOrCreate() : Theme
174			{
175			if (! $this->exists()) {
176			return $this->make();
177			}
178
179			return $this->import();
180			}
181
182			/**
183			* {@inheritDoc}
184			*/
185			public function use() : Theme
186			{
187			$this->guard();
188
189			$this->register();
190
191			return $this;
192			}
193
194			/**
195			* {@inheritDoc}
196			*/
197			public function include(string $sentence) : Includer
198			{
199			return $this->finder()->include($sentence);
200			}
201
202			/**
203			* {@inheritDoc}
204			*/
205			public function component(string $sentence) : Component
206			{
207			return $this->finder()->component($sentence);
208			}
209
210			/**
211			* {@inheritDoc}
212			*/
213			public function directives() : array
214			{
215			return $this->finder()->all();
216			}
217
218			/**
219			* {@inheritDoc}
220			*/
221			public function load() : Theme
222			{
223			foreach ($this->directives() as $directive) {
224			$directive->load();
225			}
226
227			return $this;
228			}
229
230			/**
231			* {@inheritDoc}
232			*/
233			public function publish() : bool
234			{
235			if (! $this->exists()) {
236			throw new ThemeNotFoundException($this->package());
237			}
238
239			$from = $this->structure()->assets();
240			$to = $this->structure()->public();
241
242			File::copyDirectory($from, $to);
243
244			return (is_dir($to)) ? true : false;
245			}
246
247			/**
248			* {@inheritDoc}
249			*/
250			public function url(string $file = null) : string
251			{
252			$domain = $this->env()->get('APP_URL');
253			$public = $this->config()->publishable();
254			$package = $this->package();
255
256			$file = '/' . $file ?? '';
257			$file = str_replace("'", "", $file);
258
259			return sprintf('%s/%s/%s%s', $domain, $public, $package, $file);
260			}
261
262			/**
263			* Registra o nome do pacote do tema no arquivo de ambiente
264			* do projeto Laravel
265			*
266			* @return void
267			*/
268			private function register()
269			{
270			$name = $this->package();
271
272			$key = $this->config()->env();
273
274			$this->env()->set($key, $name);
275			}
276
277			/**
278			* Inicia as regras de negócio do tema
279			* Se o tema já existir dentro do projeto, carrega suas informações
280			*
281			* @param string $package
282			* @return Theme
283			*/
284			private function init(string $package) : Theme
285			{
286			$this->setVendor($package)
287			->setDirectiveFinder()
288			->setComposer()
289			->setStructure();
290
291			if ($this->exists()) {
292			return $this->import();
293			}
294
295			return $this;
296			}
297
298			/**
299			* Carrega as informações vindas do arquivo composer.json
300			* para dentro da instância
301			*
302			* @return Theme
303			*/
304			private function import() : Theme
305			{
306			$info = $this->composer()->load()->info();
307
308			$this->author()->name($info->authors[0]->name);
309			$this->author()->email($info->authors[0]->email);
310
311			return $this;
312			}
313
314			/**
315			* Define o nome do vendor do tema.
316			*
317			* @return Theme
318			*/
319			private function setVendor(string $vendor) : Theme
320			{
321			$this->vendorInstance = new Vendor($vendor);
322
323			return $this;
324			}
325
326			/**
327			* Define as informações do autor do tema
328			*
329			* @param string $author
330			* @return Theme
331			*/
332			private function setAuthor(string $author) : Theme
333			{
334			$this->authorInstance = new Author($author);
335
336			return $this;
337			}
338
339			/**
340			* Retorna as informações do autor do tema
341			*
342			* @return Author
343			*/
344			private function getAuthor() : Author
345			{
346			return $this->authorInstance ?? new Author();
347			}
348
349			/**
350			* Define a instância de estrutura de diretórios do tema
351			*
352			* @return Theme
353			*/
354			private function setStructure() : Theme
355			{
356			$vendor = $this->vendor();
357
358			$this->structureInstance = new Structure($vendor);
359
360			return $this;
361			}
362
363			/**
364			* Retorna a instância de estrutura do tema
365			*
366			* @return Structure
367			*/
368			private function structure() : Structure
369			{
370			return $this->structureInstance;
371			}
372
373			/**
374			* Define o composer do tema
375			*
376			* @return Theme
377			*/
378			private function setComposer() : Theme
379			{
380			$this->composerInstance = new Composer($this);
381
382			return $this;
383			}
384
385			/**
386			* Retorna a instância do composer do tema
387			*
388			* @return Theme
389			*/
390			private function composer() : Composer
391			{
392			return $this->composerInstance;
			0 ignored issues – show Bug Best Practice introduced 2021-07-02 06:15 UTC by Report Bug Copy Issue Report The expression `return $this->composerInstance` returns the type `Maestriam\Samurai\Entities\Composer` which is incompatible with the documented return type `Maestriam\Samurai\Entities\Theme`. Loading history...
393			}
394
395			/**
396			* Define a instância de busca de diretivas dentro do tema.
397			*
398			* @return Theme
399			*/
400			private function setDirectiveFinder() : Theme
401			{
402			$this->finderInstance = new DirectiveFinder($this);
403
404			return $this;
405			}
406
407			/**
408			* Retorna a instância de busca de diretivas dentro do tema.
409			*
410			* @return DirectiveFinder
411			*/
412			private function finder() : DirectiveFinder
413			{
414			return $this->finderInstance;
415			}
416
417			/**
418			* Faz as devidas validações sobre o tema.
419			* Se existir algo incompátivel, emite um Exception.
420			*
421			* @return void
422			*/
423			private function guard() : void
424			{
425			if ($this->exists()) {
426			return;
427			}
428
429			throw new ThemeNotFoundException($this->package());
430			}
431
432			}
433

maestriam / samurai

Branch — feature/refactoring-samurai (8cc7c1)

Theme::exists() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like