CodeFile::renderDiff() - Code Metrics - Inspection of "Fix #36: Remove yiisoft/view dependency" - yiisoft/yii-gii - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#56)

by Rustam
created 2022-10-13 05:21 UTC
CodeFile::renderDiff() A

↳ Parent: CodeFile
Complexity

Conditions	5
Paths	16
Size

Total Lines	17
Code Lines	10
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	10
CRAP Score	5.0187
Importance

Changes
Metric	Value
eloc	10
c	0
b	0
f	0
dl	0
loc	17
ccs	10
cts	11
cp	0.9091
rs	9.6111
cc	5
nc	16
nop	2
crap	5.0187
<?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;
    public const OPERATIONS = [
        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 [[OP_CREATE]], [[OP_OVERWRITE]] or [[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);
                    /** @scrutinizer ignore-unhandled */ @umask($mask);
                } 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);
            /** @scrutinizer ignore-unhandled */ @chmod($this->path, $this->newFileMode);
            @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);

        }

        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);
    }
}

yiisoft / yii-gii

Pull Request — master (#56)

CodeFile::renderDiff() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
