Wowstack\Dbc\DBCRecord

Complexity

Total Complexity

15

Size/Duplication

Total Lines	122
Duplicated Lines	0 %

Test Coverage

Coverage

92.86%

Importance

Changes

0

2 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	16	3
C	read()	0	53	12

<?php

declare(strict_types=1);

namespace Wowstack\Dbc;

/**
 * Implements a single record within a DBC file.
 */
class DBCRecord
{
    /**
     * @var DBC
     */
    protected $dbcFile = null;

    /**
     * @var int
     */
    protected $position = 0;

    /**
     * @var int
     */
    protected $recordOffset = 0;

    /**
     * @var int
     */
    protected $recordSize = 0;

    /**
     * @var resource
     */
    protected $fileHandle = null;

    /**
     * @var mixed
     */
    protected $data = null;

    /**
     * @var int
     */
    protected $identifier = 0;

    /**
     * Constructs a new DBC row.
     *
     * @param DBC $dbcFile
     * @param int $position
     */
    public function __construct(DBC $dbcFile, int $position)
    {
        $this->dbcFile = $dbcFile;
        $this->position = $position;

        $this->recordSize = $this->dbcFile->getRecordSize();
        $this->recordOffset = DBC::HEADER_SIZE + $this->position * $this->recordSize;
        $this->fileHandle = $this->dbcFile->getFileHandle();

It seems like $this->dbcFile->getFileHandle() can also be of type boolean. However, the property $fileHandle is declared as type resource. Maybe add an additional type check?

        if (false === $this->fileHandle) {
            throw new DBCException('DBC file is not readable.');
        }

        fseek($this->fileHandle, $this->recordOffset);

It seems like $this->fileHandle can also be of type true; however, parameter $handle of fseek() does only seem to accept resource, maybe add an additional type check?

        if ($this->recordSize > 0) {
            $this->data = fread($this->fileHandle, $this->recordSize);

It seems like $this->fileHandle can also be of type true; however, parameter $handle of fread() does only seem to accept resource, maybe add an additional type check?

        }
    }

    /**
     * Reads the current row into key/value array.
     *
     * @return array
     *
     * @throws DBCException
     */
    public function read(): array
    {
        $map = $this->dbcFile->getMap();
        if (empty($map)) {
            throw new DBCException('DBCRecord can not be read without a mapping');
        }

        $format = [];
        $strings = [];
        $foreignKeys = [];
        $fields = $map->getParsedFields();

        foreach ($fields as $fieldName => $fieldData) {
            $format[] = $fieldData['format'];
            if ('string' === $fieldData['type'] || 'localized_string' === $fieldData['type']) {
                $strings[] = $fieldName;
            }
            if ('foreign_key' === $fieldData['type']) {
                $foreignKeys[] = $fieldName;
            }
        }

        $format = implode('/', $format);
        $data = unpack($format, $this->data);

        // This ensure that string fields will be empty strings instead of 0.
        foreach ($strings as $string) {
            $stringPointer = $data[$string];
            if ($data[$string] > 0) {
                try {
                    $data[$string] = $this->dbcFile->getString($data[$string]);
                } catch (DBCException $dbcException) {
                    $data[$string] = '';
                    $this->dbcFile->addError('string', $this->position, $string, 'String pointer not found at offset '.$stringPointer);

Concat operator must be surrounded by a single space

This line exceeds maximum limit of 120 characters; contains 135 characters

                }
            } else {
                $data[$string] = '';
            }
        }

        // This ensures fields containing references to other tables will be nulled
        // if they do not contain a valid reference.
        foreach ($foreignKeys as $foreignKey) {
            if ($data[$foreignKey] <= 0) {
                $data[$foreignKey] = null;
            }
        }

        $data = array_filter($data, function ($key) {

It seems like $data can also be of type false; however, parameter $input of array_filter() does only seem to accept array, maybe add an additional type check?

            return false === strpos($key, '_checksum') && false === strpos($key, '_unused');
        }, ARRAY_FILTER_USE_KEY);

        return $data;
    }
}