MoReader\Reader

Complexity

Total Complexity

28

Size/Duplication

Total Lines	283
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	load()	0	15	1
A	readStringTables()	0	14	1
A	readTranslations()	0	13	2
A	processRecord()	0	14	4
A	readMsgId()	0	9	2
A	readTranslation()	0	9	2
A	readStringFromTable()	0	13	2
A	calcSizeKey()	0	4	1
A	openFile()	0	23	3
A	determineByteOrder()	0	18	3
A	verifyMajorRevision()	0	14	3
A	readInteger()	0	10	2
A	readIntegerList()	0	8	2

<?php

namespace MoReader;

/**
 * Gettext loader
 */
class Reader
{
    /**
     * Current file pointer.
     *
     * @var resource
     */
    protected $file;

    /**
     * @var string
     */
    protected $filename;

    /**
     * Whether the current file is little endian.
     *
     * @var bool
     */
    protected $littleEndian;

    /**
     * @var int
     */
    protected $stringsCount;

    /**
     * @var array
     */
    protected $msgIdTable;

    /**
     * @var array
     */
    protected $msgStrTable;

    /**
     *
     * @param string $filename
     * @return array
     * @throws \Exception
     */
    public function load($filename)
    {
        $this->openFile($filename);

        $this->determineByteOrder();
        $this->verifyMajorRevision();

        $this->readStringTables();

        $data = $this->readTranslations();

        fclose($this->file);

        return $data;
    }

    /**
     *
     */
    protected function readStringTables()
    {
        $this->stringsCount = $this->readInteger();
        $msgIdTableOffset = $this->readInteger();
        $msgStrTableOffset = $this->readInteger();

        // Usually there follow size and offset of the hash table, but we have
        // no need for it, so we skip them.
        fseek($this->file, $msgIdTableOffset);
        $this->msgIdTable = $this->readIntegerList(2 * $this->stringsCount);

        fseek($this->file, $msgStrTableOffset);
        $this->msgStrTable = $this->readIntegerList(2 * $this->stringsCount);
    }

    /**
     * @return array
     */
    protected function readTranslations()
    {
        $data = array();

        for ($counter = 0; $counter < $this->stringsCount; $counter++) {
            $msgId = $this->readMsgId($counter);
            $msgStr = $this->readTranslation($counter);

            $this->processRecord($data, $msgId, $msgStr);
        }

        return $data;
    }

    /**
     * @param array $data
     * @param array $msgId
     * @param array $msgStr
     */
    protected function processRecord(&$data, $msgId, $msgStr)
    {
        if (count($msgId) > 1 && count($msgStr) > 1) {
            $data[$msgId[0]] = $msgStr;

            array_shift($msgId);

            foreach ($msgId as $string) {
                $data[$string] = '';
            }
        } else {
            $data[$msgId[0]] = $msgStr[0];
        }
    }

    /**
     * Reads specified message id record
     *
     * @param int $index
     *
     * @return array
     */
    protected function readMsgId($index)
    {
        $msgId = $this->readStringFromTable($index, $this->msgIdTable);
        if (false === $msgId) {
            $msgId = array('');
        }

        return $msgId;
    }

    /**
     * Reads specified translation record
     *
     * @param int $index
     *
     * @return array
     */
    protected function readTranslation($index)
    {
        $msgStr = $this->readStringFromTable($index, $this->msgStrTable);
        if (false === $msgStr) {
            $msgStr = array();
        }

        return $msgStr;
    }

    /**
     * @param int $index
     * @param array $table
     *
     * @return array|bool
     */
    protected function readStringFromTable($index, $table)
    {
        $sizeKey = $this->calcSizeKey($index);
        $size = $table[$sizeKey];

        if ($size > 0) {
            $offset = $table[$sizeKey + 1];
            fseek($this->file, $offset);
            return explode("\0", fread($this->file, $size));
        }

        return false;
    }

    /**
     * @param $counter
     *
     * @return int
     */
    protected function calcSizeKey($counter)
    {
        return $counter * 2 + 1;
    }

    /**
     * Prepare file for reading
     *
     * @param $filename
     *
     * @throws \Exception
     */
    protected function openFile($filename)
    {
        $this->filename = $filename;

        if (!is_file($this->filename)) {
            throw new \Exception(
                sprintf(
                    'File %s does not exist',
                    $this->filename
                )
            );
        }

        $this->file = fopen($this->filename, 'rb');
        if (false === $this->file) {
            throw new \Exception(
                sprintf(
                    'Could not open file %s for reading',
                    $this->filename
                )
            );
        }
    }

    /**
     * Determines byte order
     *
     * @throws \Exception
     */
    protected function determineByteOrder()
    {
        $orderHeader = fread($this->file, 4);

        if ($orderHeader == "\x95\x04\x12\xde") {
            $this->littleEndian = false;
        } elseif ($orderHeader == "\xde\x12\x04\x95") {
            $this->littleEndian = true;
        } else {
            fclose($this->file);
            throw new \Exception(
                sprintf(
                    '%s is not a valid gettext file',
                    $this->filename
                )
            );
        }
    }

    /**
     * Verify major revision (only 0 and 1 supported)
     *
     * @throws \Exception
     */
    protected function verifyMajorRevision()
    {
        $majorRevision = ($this->readInteger() >> 16);

        if ($majorRevision !== 0 && $majorRevision !== 1) {
            fclose($this->file);
            throw new \Exception(
                sprintf(
                    '%s has an unknown major revision',
                    $this->filename
                )
            );
        }
    }

    /**
     * Read a single integer from the current file.
     *
     * @return int
     */
    protected function readInteger()
    {
        if ($this->littleEndian) {
            $result = unpack('Vint', fread($this->file, 4));
        } else {
            $result = unpack('Nint', fread($this->file, 4));
        }

        return $result['int'];
    }

    /**
     * Read an integer from the current file.
     *
     * @param int $num
     * @return array
     */
    protected function readIntegerList($num)
    {
        if ($this->littleEndian) {
            return unpack('V' . $num, fread($this->file, 4 * $num));
        }

        return unpack('N' . $num, fread($this->file, 4 * $num));
    }
}