Yiisoft\Yii\Gii\CodeFile

Complexity

Total Complexity

35

Size/Duplication

Total Lines	247
Duplicated Lines	0 %

Test Coverage

Coverage

74.7%

Importance

Changes	1
Bugs	0	Features	0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	getPath()	0	3	1
A	renderDiff()	0	17	5
A	withBasePath()	0	6	1
B	save()	0	28	7
A	preview()	0	22	4
A	getId()	0	3	1
A	withNewFileMode()	0	6	1
A	withNewDirMode()	0	6	1
A	__construct()	0	6	3
A	getContent()	0	3	1
A	preparePath()	0	3	1
A	getType()	0	7	2
A	getOperation()	0	3	1
A	diff()	0	12	3
A	getRelativePath()	0	7	3

<?php

declare(strict_types=1);

namespace Yiisoft\Yii\Gii;

use Diff;
use RuntimeException;
use Yiisoft\Yii\Gii\Component\DiffRendererHtmlInline;

/**
 * CodeFile represents a code file to be generated.
 */
final class CodeFile
{
    /**
     * The new file mode
     */
    private const FILE_MODE = 0666;
    /**
     * The new directory mode
     */
    private const DIR_MODE = 0777;
    /**
     * The code file is new.
     */
    public const OP_CREATE = 0;
    /**
     * The code file already exists, and the new one may need to overwrite it.
     */
    public const OP_OVERWRITE = 1;
    /**
     * The new code file and the existing one are identical.
     */
    public const OP_SKIP = 2;
    /**
     * Operations map to be performed.
     */
    public const OPERATIONS_MAP = [
        self::OP_CREATE => 'Create',
        self::OP_OVERWRITE => 'Overwrite',
        self::OP_SKIP => 'Skip',
    ];

    /**
     * @var string an ID that uniquely identifies this code file.
     */
    private string $id;
    /**
     * @var string the file path that the new code should be saved to.
     */
    private string $path;
    /**
     * @var int the operation to be performed. This can be {@see OP_CREATE}, {@see OP_OVERWRITE} or {@see OP_SKIP}.
     */
    private int $operation = self::OP_CREATE;
    /**
     * @var string the base path
     */
    private string $basePath = '';
    /**
     * @var int the permission to be set for newly generated code files.
     * This value will be used by PHP chmod function.
     * Defaults to 0666, meaning the file is read-writable by all users.
     */
    private int $newFileMode = self::FILE_MODE;
    /**
     * @var int the permission to be set for newly generated directories.
     * This value will be used by PHP chmod function.
     * Defaults to 0777, meaning the directory can be read, written and executed by all users.
     */
    private int $newDirMode = self::DIR_MODE;

    /**
     * Constructor.
     *
     * @param string $path the file path that the new code should be saved to.
     * @param string $content the newly generated code content.
     */
    public function __construct(string $path, private string $content)
    {
        $this->path = $this->preparePath($path);
        $this->id = dechex(crc32($this->path));
        if (is_file($path)) {
            $this->operation = file_get_contents($path) === $content ? self::OP_SKIP : self::OP_OVERWRITE;
        }
    }

    /**
     * Saves the code into the file specified by [[path]].
     *
     * @return bool the error occurred while saving the code file, or true if no error.
     */
    public function save(): bool
    {
        if ($this->operation === self::OP_CREATE) {
            $dir = dirname($this->path);
            if (!is_dir($dir)) {
                if ($this->newDirMode !== self::DIR_MODE) {
                    $mask = @umask(0);
                    $result = @mkdir($dir, $this->newDirMode, true);
                    @umask($mask);

It seems like you do not handle an error condition for umask(). This can introduce security issues, and is generally not recommended.

                } else {
                    $result = @mkdir($dir, 0777, true);
                }
                if (!$result) {
                    throw new RuntimeException("Unable to create the directory '$dir'.");
                }
            }
        }
        if (@file_put_contents($this->path, $this->content) === false) {
            throw new RuntimeException("Unable to write the file '{$this->path}'.");
        }

        if ($this->newFileMode !== self::FILE_MODE) {
            $mask = @umask(0);
            @chmod($this->path, $this->newFileMode);

It seems like you do not handle an error condition for chmod(). This can introduce security issues, and is generally not recommended.

            @umask($mask);
        }

        return true;
    }

    /**
     * @return string the code file path relative to the application base path.
     */
    public function getRelativePath(): string
    {
        if (!empty($this->basePath) && str_starts_with($this->path, $this->basePath)) {
            return substr($this->path, strlen($this->basePath) + 1);
        }

        return $this->path;
    }

    /**
     * @return string the code file extension (e.g. php, txt)
     */
    public function getType(): string
    {
        if (($pos = strrpos($this->path, '.')) !== false) {
            return substr($this->path, $pos + 1);
        }

        return 'unknown';
    }

    /**
     * Returns preview or false if it cannot be rendered
     */
    public function preview(): false|string
    {
        if (($pos = strrpos($this->path, '.')) !== false) {
            $type = substr($this->path, $pos + 1);
        } else {
            $type = 'unknown';
        }

        if ($type === 'php') {
            return highlight_string($this->content, true);

The expression return highlight_string($this->content, true) could return the type true which is incompatible with the type-hinted return false|string. Consider adding an additional type-check to rule them out.

        }

        if (!in_array($type, ['jpg', 'gif', 'png', 'exe'])) {
            $content = htmlspecialchars(
                $this->content,
                ENT_NOQUOTES | ENT_SUBSTITUTE | ENT_HTML5,
                'UTF-8'
            );
            return nl2br($content);
        }

        return false;
    }

    /**
     * Returns diff or false if it cannot be calculated
     */
    public function diff(): false|string
    {
        $type = strtolower($this->getType());
        if (in_array($type, ['jpg', 'gif', 'png', 'exe'])) {
            return false;
        }

        if ($this->operation === self::OP_OVERWRITE) {
            return $this->renderDiff(file($this->path), $this->content);
        }

        return '';
    }

    /**
     * Renders diff between two sets of lines
     */
    private function renderDiff(mixed $lines1, mixed $lines2): string
    {
        if (!is_array($lines1)) {
            $lines1 = explode("\n", $lines1);
        }
        if (!is_array($lines2)) {
            $lines2 = explode("\n", $lines2);
        }
        foreach ($lines1 as $i => $line) {
            $lines1[$i] = rtrim($line, "\r\n");
        }
        foreach ($lines2 as $i => $line) {
            $lines2[$i] = rtrim($line, "\r\n");
        }

        $renderer = new DiffRendererHtmlInline();
        return (new Diff($lines1, $lines2))->render($renderer);
    }

    public function getId(): string
    {
        return $this->id;
    }

    public function getOperation(): int
    {
        return $this->operation;
    }

    public function getPath(): string
    {
        return $this->path;
    }

    public function getContent(): string
    {
        return $this->content;
    }

    public function withBasePath(string $basePath): self
    {
        $new = clone $this;
        $new->basePath = $this->preparePath($basePath);

        return $new;
    }

    public function withNewFileMode(int $mode): self
    {
        $new = clone $this;
        $new->newFileMode = $mode;

        return $new;
    }

    public function withNewDirMode(int $mode): self
    {
        $new = clone $this;
        $new->newDirMode = $mode;

        return $new;
    }

    private function preparePath(string $path): string
    {
        return strtr($path, '/\\', DIRECTORY_SEPARATOR . DIRECTORY_SEPARATOR);
    }
}