PhpMyAdmin\Plugins\Import\ImportMediawiki::doImport()

Complexity

Conditions	29
Paths	2

Size

Total Lines	212
Code Lines	89

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	76
CRAP Score	30.6983

Importance

Changes	1
Bugs	0	Features	0

<?php
    public function doImport(File|null $importHandle = null): array
    {
        $GLOBALS['error'] ??= null;

        $sqlStatements = [];

        // Defaults for parser

        // The buffer that will be used to store chunks read from the imported file
        $buffer = '';

        // Used as storage for the last part of the current chunk data
        // Will be appended to the first line of the next chunk, if there is one
        $lastChunkLine = '';

        // Remembers whether the current buffer line is part of a comment
        $insideComment = false;
        // Remembers whether the current buffer line is part of a data comment
        $insideDataComment = false;
        // Remembers whether the current buffer line is part of a structure comment
        $insideStructureComment = false;

        // MediaWiki only accepts "\n" as row terminator
        $mediawikiNewLine = "\n";

        // Initialize the name of the current table
        $curTableName = '';

        $curTempTableHeaders = [];
        $curTempTable = [];

        $inTableHeader = false;

        /** @infection-ignore-all */
        while (! ImportSettings::$finished && ! $GLOBALS['error'] && ! ImportSettings::$timeoutPassed) {
            $data = $this->import->getNextChunk($importHandle);

            if ($data === false) {
                // Subtract data we didn't handle yet and stop processing
                ImportSettings::$offset -= mb_strlen($buffer);
                break;
            }

            if ($data !== true) {
                // Append new data to buffer
                $buffer = $data;
                unset($data);
                // Don't parse string if we're not at the end
                // and don't have a new line inside
                if (! str_contains($buffer, $mediawikiNewLine)) {
                    continue;
                }
            }

            // Because of reading chunk by chunk, the first line from the buffer
            // contains only a portion of an actual line from the imported file.
            // Therefore, we have to append it to the last line from the previous
            // chunk. If we are at the first chunk, $last_chunk_line should be empty.
            $buffer = $lastChunkLine . $buffer;

            // Process the buffer line by line
            $bufferLines = explode($mediawikiNewLine, $buffer);

            $fullBufferLinesCount = count($bufferLines);
            // If the reading is not finalized, the final line of the current chunk
            // will not be complete
            if (! ImportSettings::$finished) {
                $lastChunkLine = $bufferLines[--$fullBufferLinesCount];
            }

            /** @var list<string> $curTempLine Temporary storage of cell values */
            $curTempLine = [];
            for ($lineNr = 0; $lineNr < $fullBufferLinesCount; ++$lineNr) {
                $curBufferLine = trim($bufferLines[$lineNr]);

                // If the line is empty, go to the next one
                if ($curBufferLine === '') {
                    continue;
                }

                $firstCharacter = $curBufferLine[0];

                // Check beginning of comment
                if (str_starts_with($curBufferLine, '<!--')) {
                    $insideComment = true;
                    continue;
                }

                if ($insideComment) {
                    // Check end of comment
                    if (str_starts_with($curBufferLine, '-->')) {
                        // Only data comments are closed. The structure comments
                        // will be closed when a data comment begins (in order to
                        // skip structure tables)
                        if ($insideDataComment) {
                            $insideDataComment = false;
                        }

                        // End comments that are not related to table structure
                        if (! $insideStructureComment) {
                            $insideComment = false;
                        }
                    } else {
                        // Check table name
                        $matchTableName = [];
                        if (preg_match('/^Table data for `(.*)`$/', $curBufferLine, $matchTableName)) {
                            $curTableName = $matchTableName[1];
                            $insideDataComment = true;

                            $insideStructureComment = false;
                        } elseif (preg_match('/^Table structure for `(.*)`$/', $curBufferLine, $matchTableName)) {
                            // The structure comments will be ignored
                            $insideStructureComment = true;
                        }
                    }

                    continue;
                }

                if (preg_match('/^\{\|(.*)$/', $curBufferLine)) {
                    // Check start of table

                    // This will store all the column info on all rows from
                    // the current table read from the buffer
                    $curTempTable = [];

                    // Will be used as storage for the current row in the buffer
                    // Once all its columns are read, it will be added to
                    // $cur_temp_table and then it will be emptied
                    $curTempLine = [];

                    // Helps us differentiate the header columns
                    // from the normal columns
                    $inTableHeader = false;
                    // End processing because the current line does not
                    // contain any column information
                } elseif (
                    str_starts_with($curBufferLine, '|-')
                    || str_starts_with($curBufferLine, '|+')
                    || str_starts_with($curBufferLine, '|}')
                ) {
                    // Check begin row or end table

                    // Add current line to the values storage
                    if ($curTempLine !== []) {
                        // If the current line contains header cells
                        // ( marked with '!' ),
                        // it will be marked as table header
                        if ($inTableHeader) {
                            // Set the header columns
                            $curTempTableHeaders = $curTempLine;
                        } else {
                            // Normal line, add it to the table
                            $curTempTable[] = $curTempLine;
                        }
                    }

                    // Empty the temporary buffer
                    $curTempLine = [];

                    // No more processing required at the end of the table
                    if (str_starts_with($curBufferLine, '|}')) {
                        // Import the current table data into the database
                        $this->importDataOneTable(
                            new ImportTable($curTableName, $curTempTableHeaders, $curTempTable),

It seems like $curTempTableHeaders can also be of type PhpMyAdmin\Plugins\Import\list; however, parameter $columns of PhpMyAdmin\Import\ImportTable::__construct() does only seem to accept array, maybe add an additional type check?

                            $sqlStatements,
                        );

                        // Reset table name
                        $curTableName = '';
                    }
                    // What's after the row tag is now only attributes
                } elseif ($firstCharacter === '|' || $firstCharacter === '!') {
                    // Check cell elements

                    // Header cells
                    if ($firstCharacter === '!') {
                        // Mark as table header, but treat as normal row
                        $curBufferLine = str_replace('!!', '||', $curBufferLine);
                        // Will be used to set $cur_temp_line as table header
                        $inTableHeader = true;
                    } else {
                        $inTableHeader = false;
                    }

                    // Loop through each table cell
                    $cells = $this->explodeMarkup($curBufferLine);
                    foreach ($cells as $cell) {
                        $cell = $this->getCellData($cell);

                        // Delete the beginning of the column, if there is one
                        $cell = trim($cell);
                        foreach (['|', '!'] as $colStartChar) {
                            $cell = $this->getCellContent($cell, $colStartChar);
                        }

                        // Add the cell to the row
                        $curTempLine[] = $cell;
                    }
                } else {
                    // If it's none of the above, then the current line has a bad
                    // format
                    $message = Message::error(
                        __('Invalid format of mediawiki input on line: <br>%s.'),
                    );
                    $message->addParam($curBufferLine);
                    $GLOBALS['error'] = true;
                }
            }
        }

        return $sqlStatements;
    }