Spatie\Export\Exporter

Complexity

Total Complexity

19

Size/Duplication

Total Lines	138
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	exclude()	0	6	1
A	export()	0	6	1
A	__construct()	0	5	1
A	paths()	0	6	1
A	include()	0	6	1
A	exportPaths()	0	25	2
A	exportIncludedFiles()	0	12	3
A	exportIncludedFile()	0	10	2
A	exportIncludedDirectory()	0	15	3
A	excludes()	0	10	3
A	setCli()	0	4	1

<?php

namespace Spatie\Export;

use Illuminate\Console\Command;
use Illuminate\Contracts\Filesystem\Filesystem;
use App\Http\Kernel;
use Illuminate\Http\Request;
use RecursiveDirectoryIterator;
use RecursiveIteratorIterator;
use Spatie\Export\Concerns\Messenger;

class Exporter
{
    use Messenger;

    /** @var \App\Http\Kernel */
    protected $kernel;

    /** @var \Illuminate\Contracts\Filesystem\Filesystem */
    protected $filesystem;

    /** @var string[] */
    protected $paths = [];

    /** @var string[] */
    protected $include = [];

    /** @var string[] */
    protected $exclude = [];

    /** @var \Illuminate\Console\Command */
    protected $cli;

    public function __construct(Kernel $kernel, Filesystem $filesystem)
    {
        $this->kernel = $kernel;
        $this->filesystem = $filesystem;
    }

    public function paths(array $paths): Exporter
    {
        $this->paths = array_merge($this->paths, $paths);

It seems like array_merge($this->paths, $paths) of type array is incompatible with the declared type array<integer,string> of property $paths.

        return $this;
    }

    public function include(array $include): Exporter
    {
        $this->include = array_merge($this->include, $include);

It seems like array_merge($this->include, $include) of type array is incompatible with the declared type array<integer,string> of property $include.

        return $this;
    }

    public function exclude(array $exclude): Exporter
    {
        $this->exclude = array_merge($this->exclude, $exclude);

It seems like array_merge($this->exclude, $exclude) of type array is incompatible with the declared type array<integer,string> of property $exclude.

        return $this;
    }

    public function export(): void
    {
        $this->exportPaths();

        $this->exportIncludedFiles();
    }

    protected function exportPaths(): void
    {
        $this->cli->comment("Exporting paths...");

        $progressBar = $this->cli->getOutput()->createProgressBar(count($this->paths));

        $progressBar->start();

        foreach ($this->paths as $path) {
            $response = $this->kernel->handle(
                Request::create($path, 'GET')
            );

            $targetPath = '/'.ltrim($path . '/index.html', '/');

            $progressBar->advance();

            $contents = str_replace('http://localhost/', '/', $response->content());
            $contents = str_replace('http://localhost', '/', $contents);

            $this->filesystem->put($targetPath, $contents);
        }

        $progressBar->finish();
    }

    protected function exportIncludedFiles(): void
    {
        $this->cli->comment("\nExporting files...");

        foreach ($this->include as ['source' => $source, 'target' => $target]) {
            if (is_file($source)) {
                $this->exportIncludedFile($source, $target);

The variable $source does not exist. Did you forget to declare it?

The variable $target does not exist. Did you forget to declare it?

            } else {
                $this->exportIncludedDirectory($source, $target);
            }
        }
    }

    protected function exportIncludedFile(string $source, string $target): void
    {
        if ($this->excludes($source)) {
            return;
        }

        $target = '/'.ltrim($target, '/');

        $this->filesystem->put($target, file_get_contents($source));
    }

    protected function exportIncludedDirectory(string $source, string $target): void
    {
        $iterator = new RecursiveIteratorIterator(
            new RecursiveDirectoryIterator($source, RecursiveDirectoryIterator::SKIP_DOTS),
            RecursiveIteratorIterator::SELF_FIRST
        );

        foreach ($iterator as $item) {
            if ($item->isDir()) {
                continue;
            }

            $this->exportIncludedFile($item->getPathname(), $target.'/'.$iterator->getSubPathName());
        }
    }

    protected function excludes(string $source): bool
    {
        foreach ($this->exclude as $pattern) {
            if (preg_match($pattern, $source)) {
                return true;
            }
        }

        return false;
    }

    public function setCli(Command $cli)
    {
        $this->cli = $cli;
    }
}