Spaghetti\XLSXParser\RowIterator

Complexity

Total Complexity

20

Size/Duplication

Total Lines	117
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	valid()	0	3	1
A	processEndElement()	0	4	2
A	processRow()	0	4	1
A	process()	0	8	2
A	processDefault()	0	3	1
A	rewind()	0	7	2
A	next()	0	12	3
A	processValue()	0	3	1
A	processColumn()	0	5	1
A	key()	0	3	1
A	processEndValue()	0	7	3
A	__construct()	0	6	1
A	current()	0	3	1

<?php declare(strict_types = 1);

namespace Spaghetti\XLSXParser;

use Iterator;
use XMLReader;

/**
 * @internal
 */
final class RowIterator implements Iterator
{
    private const ROW = 'row';
    private const ROW_INDEX = 'r';
    private const COLUMN = 'c';
    private const VALUE = 'v';
    private const STYLE = 's';
    private const TYPE = 't';

    private ?Row $row = null;
    private XMLReader $xml;
    private array $currentValue;
    private bool $valid;
    private int $currentKey;
    private int $index;
    private readonly Transformer\Column $columnTransformer;
    private string $style;
    private string $type;

    public function __construct(
        private readonly Transformer\Value $valueTransformer,
        private readonly string $path,
        ?Transformer\Column $columnTransformer = null,
    ) {
        $this->columnTransformer = $columnTransformer ?? new Transformer\Column();

The property columnTransformer is declared read-only in Spaghetti\XLSXParser\RowIterator.

    }

    public function current(): array
    {
        return $this->currentValue;
    }

    public function key(): int
    {
        return $this->currentKey;
    }

    public function next(): void
    {
        $this->valid = false;

        while ($this->xml->read()) {
            $this->processEndElement();

            if ($this->valid) {
                return;
            }

            $this->process();
        }
    }

    public function rewind(): void
    {
        $xml = new XMLReader();

        $this->xml = false === $xml->open(uri: $this->path) ? null : $xml;

        $this->next();
    }

    public function valid(): bool
    {
        return $this->valid;
    }

    private function processEndElement(): void
    {
        if (XMLReader::END_ELEMENT === $this->xml->nodeType) {
            $this->processEndValue();
        }
    }

    private function processEndValue(): void
    {
        if (self::ROW === $this->xml->name) {
            $currentValue = $this->row?->getData();
            if ([] !== $currentValue) {
                $this->currentValue = $currentValue;
                $this->valid = true;
            }
        }
    }

    private function process(): void
    {
        if (XMLReader::ELEMENT === $this->xml->nodeType) {
            match ($this->xml->name) {
                self::ROW => $this->processRow(),

Are you sure the usage of $this->processRow() targeting Spaghetti\XLSXParser\RowIterator::processRow() seems to always return null.

                self::COLUMN => $this->processColumn(),

Are you sure the usage of $this->processColumn() targeting Spaghetti\XLSXParser\RowIterator::processColumn() seems to always return null.

                self::VALUE => $this->processValue(),

Are you sure the usage of $this->processValue() targeting Spaghetti\XLSXParser\RowIterator::processValue() seems to always return null.

                default => $this->processDefault(),

Are you sure the usage of $this->processDefault() targeting Spaghetti\XLSXParser\RowIterator::processDefault() seems to always return null.

            };
        }
    }

    private function processRow(): void
    {
        $this->currentKey = (int) $this->xml->getAttribute(name: self::ROW_INDEX);
        $this->row = new Row();
    }

    private function processColumn(): void
    {
        $this->index = $this->columnTransformer->transform(name: $this->xml->getAttribute(name: self::ROW_INDEX));
        $this->style = $this->xml->getAttribute(name: self::STYLE) ?? '';
        $this->type = $this->xml->getAttribute(name: self::TYPE) ?? '';
    }

    private function processValue(): void
    {
        $this->row?->addValue(columnIndex: $this->index, value: $this->valueTransformer->transform(value: $this->xml->readString(), type: $this->type, style: $this->style), );
    }

    private function processDefault(): void
    {
        $this->row?->addValue(columnIndex: $this->index, value: $this->xml->readString());
    }
}