Remorhaz\UCD\Tool\PropertiesRangeIterator

Complexity

Total Complexity

12

Size/Duplication

Total Lines	65
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	getIterator()	0	10	3
A	fetchNextLine()	0	8	3
A	fetchPropertyRange()	0	23	5
A	__construct()	0	4	1

<?php

declare(strict_types=1);

namespace Remorhaz\UCD\Tool;

use Iterator;
use IteratorAggregate;
use Remorhaz\IntRangeSets\Range;
use SplFileObject;
use Throwable;

final class PropertiesRangeIterator implements IteratorAggregate
{

    /**
     * @var SplFileObject
     */
    private $file;

    /**
     * @var callable
     */
    private $onProgress;

    public function __construct(SplFileObject $file, callable $onProgress)
    {
        $this->file = $file;
        $this->onProgress = $onProgress;
    }

    public function getIterator(): Iterator
    {
        while (!$this->file->eof()) {
            $line = $this->fetchNextLine($this->file);
            if (!isset($line)) {
                continue;
            }
            yield from $this->fetchPropertyRange($line);

            ($this->onProgress)(strlen($line));
        }
    }

    private function fetchNextLine(SplFileObject $file): ?string
    {
        $line = $file->fgets();
        if (false === $line) {
            throw new Exception\LineNotReadException($file->getFilename());
        }

        return '' == $line ? null : $line;
    }

    private function fetchPropertyRange(string $line): Iterator
    {
        $dataWithComment = explode('#', $line, 2);
        $data = trim($dataWithComment[0] ?? '');
        if ('' == $data) {
            return;
        }
        $rangeWithProp = explode(';', $data);
        $unSplitRange = trim($rangeWithProp[0] ?? null);

It seems like $rangeWithProp[0] ?? null can also be of type null; however, parameter $string of trim() does only seem to accept string, maybe add an additional type check?

        $prop = trim($rangeWithProp[1] ?? null);
        if (!isset($unSplitRange, $prop)) {
            throw new Exception\InvalidLineException($line);
        }
        $splitRange = explode('..', $unSplitRange);
        $start = hexdec($splitRange[0]);
        $finish = isset($splitRange[1])
            ? hexdec($splitRange[1])
            : $start;

        try {
            yield $prop => new Range($start, $finish);

It seems like $start can also be of type double; however, parameter $start of Remorhaz\IntRangeSets\Range::__construct() does only seem to accept integer, maybe add an additional type check?

It seems like $finish can also be of type double; however, parameter $finish of Remorhaz\IntRangeSets\Range::__construct() does only seem to accept integer|null, maybe add an additional type check?

        } catch (Throwable $e) {
            throw new Exception\RangeNotCreatedException($e);
        }
    }
}