Jumilla\Generators\FileGenerator

Complexity

Total Complexity

37

Size/Duplication

Total Lines	347
Duplicated Lines	6.34 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

99.11%

Importance

Changes

0

23 Methods

Rating	Name	Duplication	Size	Complexity
A	make()	0	19	2
A	__construct()	0	6	1
A	directory()	0	17	2
A	sourceDirectory()	11	11	3
A	templateDirectory()	11	11	3
A	keepDirectory()	0	4	1
A	file()	0	6	1
A	exists()	0	4	1
A	blank()	0	4	1
A	text()	0	4	2
A	json()	0	4	1
A	source()	0	4	1
A	template()	0	4	1
A	gitKeepFile()	0	4	1
A	phpBlankFile()	0	4	1
A	phpConfigFile()	0	4	1
A	phpSourceFile()	0	8	2
A	sourceFile()	0	4	1
A	templateFile()	0	4	1
A	makePath()	0	4	2
A	allFiles()	0	12	3
A	generate()	0	11	3
A	read()	0	10	2

<?php

namespace Jumilla\Generators;

use stdClass;
use InvalidArgumentException;
use League\Flysystem\FilesystemInterface;

class FileGenerator
{
    /**
     * Output directory filesystem.
     *
     * @var \League\Flysystem\FilesystemInterface
     */
    protected $outbox;

    /**
     * Stub directory filessytem.
     *
     * @var \League\Flysystem\FilesystemInterface
     */
    protected $stubbox;

    /**
     * Context of generate.
     *
     * @var \stdClass
     */
    protected $context;

    /**
     * Create file generator.
     *
     * @param string $outbox_root_path
     * @param string $stubbox_root_path
     *
     * @return static
     */
    public static function make($outbox_root_path, $stubbox_root_path)
    {
        if (!is_dir($outbox_root_path)) {
            mkdir($outbox_root_path, 0755, true);
        }

        $outbox = FilesystemFactory::local($outbox_root_path);

        $stubbox = FilesystemFactory::local($stubbox_root_path);

        $context = (object) [
            'outbox_root' => $outbox_root_path,
            'stubbox_root' => $stubbox_root_path,
            'directory' => null,
            'file' => null,
        ];

        return new static($outbox, $stubbox, $context);
    }

    /**
     * the Constructor.
     *
     * @param \Legue\Flysystem\FilesystemInterface $outbox
     * @param \Legue\Flysystem\FilesystemInterface $stubbox
     * @param \stdClass                            $context
     */
    public function __construct(FilesystemInterface $outbox, FilesystemInterface $stubbox, stdClass $context)
    {
        $this->outbox = $outbox;
        $this->stubbox = $stubbox;
        $this->context = $context;
    }

    /**
     * Get directory walker.
     *
     * @param string   $path
     * @param callable $callable
     *
     * @return static
     */
    public function directory($path, callable $callable = null)
    {
        $directory_path = $this->makePath($path);

        $this->outbox->createDir($directory_path);

        $context = clone($this->context);
        $context->directory = $directory_path;

        $sub = new static($this->outbox, $this->stubbox, $context);

        if ($callable) {
            call_user_func($callable, $sub);
        }

        return $sub;
    }

    /**
     * Generate sources.
     *
     * @param string $path
     */
    public function sourceDirectory($path)

This method seems to be duplicated in your project.

    {
        foreach ($this->allFiles($this->stubbox, $this->makePath($path)) as $stubbox_path) {
            if ($this->context->directory) {
                $outbox_path = substr($stubbox_path, strlen($this->context->directory) + 1);
            } else {
                $outbox_path = $stubbox_path;
            }
            $this->directory(dirname($outbox_path))->file(basename($outbox_path))->source($stubbox_path);
        }
    }

    /**
     * Generate sources from templates.
     *
     * @param string $path
     * @param array $arguments
     */
    public function templateDirectory($path, array $arguments = [])

This method seems to be duplicated in your project.

    {
        foreach ($this->allFiles($this->stubbox, $this->makePath($path)) as $stubbox_path) {
            if ($this->context->directory) {
                $outbox_path = substr($stubbox_path, strlen($this->context->directory) + 1);
            } else {
                $outbox_path = $stubbox_path;
            }
            $this->directory(dirname($outbox_path))->file(basename($outbox_path))->template($stubbox_path, $arguments);
        }
    }

    /**
     * Generate blank directory with '.gitkeep'.
     *
     * @param string $path
     * @param string $file
     */
    public function keepDirectory($path, $file = '.gitkeep')
    {
        $this->directory($path)->gitKeepFile($file);
    }

    /**
     * Set file path.
     *
     * @param string $path
     * @return $this
     */
    public function file($path)
    {
        $this->context->file = $this->makePath($path);

        return $this;
    }

    /**
     * Check file existing.
     *
     * @param string $path
     * @return bool
     */
    public function exists($path)
    {
        return $this->outbox->has($this->makePath($path));
    }

    /**
     * Generate blank file.
     */
    public function blank()
    {
        $this->outbox->put($this->context->file, '');
    }

    /**
     * Generate text file.
     *
     * @param string $content
     * @param array $arguments
     */
    public function text($content, array $arguments = [])
    {
        $this->outbox->put($this->context->file, $arguments ? $this->generate($content, $arguments) : $content);
    }

    /**
     * Generate json file.
     *
     * @param array $data
     */
    public function json(array $data)
    {
        $this->outbox->put($this->context->file, json_encode($data, JSON_PRETTY_PRINT));
    }

    /**
     * Generate source file from stub.
     *
     * @param string $stub_path
     */
    public function source($stub_path)
    {
        $this->outbox->put($this->context->file, $this->read($stub_path));
    }

    /**
     * Generate source file from template.
     *
     * @param string $stub_path
     * @param array $arguments
     */
    public function template($stub_path, array $arguments = [])
    {
        $this->outbox->put($this->context->file, $this->generate($this->read($stub_path), $arguments));
    }

    /**
     * Generate '.gitkeep' file.
     *
     * @param string $path
     */
    public function gitKeepFile($path = '.gitkeep')
    {
        $this->file($path)->blank();
    }

    /**
     * Generate PHP blank file.
     *
     * @param string $path
     */
    public function phpBlankFile($path)
    {
        $this->file($path)->text('<?php'.PHP_EOL.PHP_EOL);
    }

    /**
     * Generate PHP config file.
     *
     * @param string $path
     * @param string $namespace
     */
    public function phpConfigFile($path, array $config = [], $namespace = null)
    {
        $this->file($path)->text(Php\ConfigGenerator::generateText($config, $namespace));
    }

    /**
     * Generate PHP source file.
     *
     * @param string $path
     * @param string $source
     * @param string $namespace
     */
    public function phpSourceFile($path, $source, $namespace = '')
    {
        if ($namespace) {
            $namespace = "namespace {$namespace};".PHP_EOL.PHP_EOL;
        }

        $this->file($path)->text('<?php'.PHP_EOL.PHP_EOL.$namespace.$source.PHP_EOL);
    }

    /**
     * Generate source file, same name.
     *
     * @param string $path
     */
    public function sourceFile($path)
    {
        $this->file($path)->source($this->makePath($path));
    }

    /**
     * Generate template file, same name.
     *
     * @param string $path
     * @param array $arguments
     */
    public function templateFile($path, array $arguments = [])
    {
        $this->file($path)->template($this->makePath($path), $arguments);
    }

    /**
     * Create relative path in box.
     *
     * @param $path
     * @return string
     */
    protected function makePath($path)
    {
        return $this->context->directory ? $this->context->directory.'/'.$path : $path;
    }

    /**
     * Get all files in directory
     *
     * @param FilesystemInterface $filesystem
     * @param string $path
     * @return array
     */
    protected function allFiles(FilesystemInterface $filesystem, $path)
    {
        $files = [];

        foreach ($filesystem->listContents($path, true) as $file) {
            if ($file['type'] == 'file') {
                $files[] = $file['path'];
            }
        }

        return $files;
    }

    /**
     * Generate template
     *
     * @param string $content
     * @param array $arguments
     * @return mixed
     */
    protected function generate($content, array $arguments)
    {
        foreach ($arguments as $name => $value) {
            if (is_array($value)) {
                $value = implode(', ', $value);
            }
            $content = preg_replace('/\{\s*\$'.$name.'\s*\}/', $value, $content);
        }

        return $content;
    }

    /**
     * Read stub file
     *
     * @param string $content

There is no parameter named $content. Was it maybe removed?

     * @param array $arguments

There is no parameter named $arguments. Was it maybe removed?

     * @return mixed
     */
    protected function read($stub_path)
    {
        $content = $this->stubbox->read($stub_path);

        if ($content === false) {
            throw new InvalidArgumentException("File '$stub_path' is not found.");
        }

        return $content;
    }
}