Maestriam\Samurai\Entities\Theme

Complexity

Total Complexity

43

Size/Duplication

Total Lines	418
Duplicated Lines	0 %

Importance

Changes	6
Bugs	0	Features	0

33 Methods

Rating	Name	Duplication	Size	Complexity
A	paths()	0	3	1
A	exists()	0	3	1
A	composer()	0	3	1
A	directives()	0	3	1
A	author()	0	7	2
A	component()	0	3	1
A	url()	0	10	1
A	vendor()	0	3	1
A	find()	0	7	2
A	setVendor()	0	5	1
A	include()	0	3	1
A	structure()	0	3	1
A	guard()	0	7	2
A	setComposer()	0	5	1
A	description()	0	9	2
A	__construct()	0	3	1
A	publish()	0	12	3
A	findOrCreate()	0	7	2
A	make()	0	11	2
A	getAuthor()	0	3	1
A	namespace()	0	3	1
A	load()	0	7	2
A	preview()	0	3	1
A	setStructure()	0	7	1
A	register()	0	7	1
A	package()	0	3	1
A	setDirectiveFinder()	0	5	1
A	setAuthor()	0	5	1
A	name()	0	3	1
A	import()	0	8	1
A	finder()	0	3	1
A	use()	0	7	1
A	init()	0	12	2

<?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;

The expression return $this->composerInstance returns the type Maestriam\Samurai\Entities\Composer which is incompatible with the documented return type Maestriam\Samurai\Entities\Theme.

    }

    /**
     * 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());
    }

}