Update website
This commit is contained in:
parent
4413528994
commit
1d90fbf296
6865 changed files with 1091082 additions and 0 deletions
534
vendor/doctrine/rst-parser/lib/Nodes/TableNode.php
vendored
Normal file
534
vendor/doctrine/rst-parser/lib/Nodes/TableNode.php
vendored
Normal file
|
|
@ -0,0 +1,534 @@
|
|||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Doctrine\RST\Nodes;
|
||||
|
||||
use Doctrine\RST\Exception\InvalidTableStructure;
|
||||
use Doctrine\RST\Nodes\Table\TableColumn;
|
||||
use Doctrine\RST\Nodes\Table\TableRow;
|
||||
use Doctrine\RST\Parser;
|
||||
use Doctrine\RST\Parser\LineChecker;
|
||||
use Doctrine\RST\Parser\TableSeparatorLineConfig;
|
||||
use Exception;
|
||||
use LogicException;
|
||||
|
||||
use function array_keys;
|
||||
use function array_reverse;
|
||||
use function array_values;
|
||||
use function count;
|
||||
use function explode;
|
||||
use function implode;
|
||||
use function ksort;
|
||||
use function max;
|
||||
use function mb_convert_encoding;
|
||||
use function preg_match;
|
||||
use function sprintf;
|
||||
use function str_repeat;
|
||||
use function strlen;
|
||||
use function strpos;
|
||||
use function substr;
|
||||
use function trim;
|
||||
|
||||
class TableNode extends Node
|
||||
{
|
||||
public const TYPE_SIMPLE = 'simple';
|
||||
public const TYPE_PRETTY = 'pretty';
|
||||
|
||||
/** @var TableSeparatorLineConfig[] */
|
||||
private $separatorLineConfigs = [];
|
||||
|
||||
/** @var string[] */
|
||||
private $rawDataLines = [];
|
||||
|
||||
/** @var int */
|
||||
private $currentLineNumber = 0;
|
||||
|
||||
/** @var bool */
|
||||
private $isCompiled = false;
|
||||
|
||||
/** @var TableRow[] */
|
||||
protected $data = [];
|
||||
|
||||
/** @var bool[] */
|
||||
protected $headers = [];
|
||||
|
||||
/** @var string[] */
|
||||
private $errors = [];
|
||||
|
||||
/** @var string */
|
||||
protected $type;
|
||||
|
||||
/** @var LineChecker */
|
||||
private $lineChecker;
|
||||
|
||||
public function __construct(TableSeparatorLineConfig $separatorLineConfig, string $type, LineChecker $lineChecker)
|
||||
{
|
||||
parent::__construct();
|
||||
|
||||
$this->pushSeparatorLine($separatorLineConfig);
|
||||
$this->type = $type;
|
||||
$this->lineChecker = $lineChecker;
|
||||
}
|
||||
|
||||
public function getCols(): int
|
||||
{
|
||||
if ($this->isCompiled === false) {
|
||||
throw new LogicException('Call compile() first.');
|
||||
}
|
||||
|
||||
$columns = 0;
|
||||
foreach ($this->data as $row) {
|
||||
$columns = max($columns, count($row->getColumns()));
|
||||
}
|
||||
|
||||
return $columns;
|
||||
}
|
||||
|
||||
public function getRows(): int
|
||||
{
|
||||
if ($this->isCompiled === false) {
|
||||
throw new LogicException('Call compile() first.');
|
||||
}
|
||||
|
||||
return count($this->data);
|
||||
}
|
||||
|
||||
/** @return TableRow[] */
|
||||
public function getData(): array
|
||||
{
|
||||
if ($this->isCompiled === false) {
|
||||
throw new LogicException('Call compile() first.');
|
||||
}
|
||||
|
||||
return $this->data;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns an of array of which rows should be headers,
|
||||
* where the row index is the key of the array and
|
||||
* the value is always true.
|
||||
*
|
||||
* @return bool[]
|
||||
*/
|
||||
public function getHeaders(): array
|
||||
{
|
||||
if ($this->isCompiled === false) {
|
||||
throw new LogicException('Call compile() first.');
|
||||
}
|
||||
|
||||
return $this->headers;
|
||||
}
|
||||
|
||||
public function pushSeparatorLine(TableSeparatorLineConfig $separatorLineConfig): void
|
||||
{
|
||||
if ($this->isCompiled === true) {
|
||||
throw new LogicException('Cannot push data after TableNode is compiled');
|
||||
}
|
||||
|
||||
$this->separatorLineConfigs[$this->currentLineNumber] = $separatorLineConfig;
|
||||
$this->currentLineNumber++;
|
||||
}
|
||||
|
||||
public function pushContentLine(string $line): void
|
||||
{
|
||||
if ($this->isCompiled === true) {
|
||||
throw new LogicException('Cannot push data after TableNode is compiled');
|
||||
}
|
||||
|
||||
$this->rawDataLines[$this->currentLineNumber] = mb_convert_encoding($line, 'ISO-8859-1', 'UTF-8');
|
||||
$this->currentLineNumber++;
|
||||
}
|
||||
|
||||
public function finalize(Parser $parser): void
|
||||
{
|
||||
if ($this->isCompiled === false) {
|
||||
$this->compile();
|
||||
}
|
||||
|
||||
$tableAsString = $this->getTableAsString();
|
||||
|
||||
if (count($this->errors) > 0) {
|
||||
$parser->getEnvironment()
|
||||
->getErrorManager()
|
||||
->error(sprintf("%s\n\n%s", $this->errors[0], $tableAsString), $parser->getFilename());
|
||||
|
||||
$this->data = [];
|
||||
$this->headers = [];
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
foreach ($this->data as $i => $row) {
|
||||
foreach ($row->getColumns() as $col) {
|
||||
$lines = explode("\n", $col->getContent());
|
||||
|
||||
if ($this->lineChecker->isListLine($lines[0])) {
|
||||
$node = $parser->parseFragment($col->getContent())->getNodes()[0];
|
||||
} else {
|
||||
$node = $parser->createSpanNode($col->getContent());
|
||||
}
|
||||
|
||||
$col->setNode($node);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Looks at all the raw data and finally populates the data
|
||||
* and headers.
|
||||
*/
|
||||
private function compile(): void
|
||||
{
|
||||
$this->isCompiled = true;
|
||||
|
||||
if ($this->type === self::TYPE_SIMPLE) {
|
||||
$this->compileSimpleTable();
|
||||
} else {
|
||||
$this->compilePrettyTable();
|
||||
}
|
||||
}
|
||||
|
||||
private function compileSimpleTable(): void
|
||||
{
|
||||
// determine if there is second === separator line (other than
|
||||
// the last line): this would mean there are header rows
|
||||
$finalHeadersRow = 0;
|
||||
foreach ($this->separatorLineConfigs as $i => $separatorLine) {
|
||||
// skip the first line: we're looking for the *next* line
|
||||
if ($i === 0) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// we found the next ==== line
|
||||
if ($separatorLine->getLineCharacter() === '=') {
|
||||
// found the end of the header rows
|
||||
$finalHeadersRow = $i;
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// if the final header row is *after* the last data line, it's not
|
||||
// really a header "ending" and so there are no headers
|
||||
$lastDataLineNumber = array_keys($this->rawDataLines)[count($this->rawDataLines) - 1];
|
||||
if ($finalHeadersRow > $lastDataLineNumber) {
|
||||
$finalHeadersRow = 0;
|
||||
}
|
||||
|
||||
// todo - support "---" in the future for colspan
|
||||
$columnRanges = $this->separatorLineConfigs[0]->getPartRanges();
|
||||
$lastColumnRangeEnd = array_values($columnRanges)[count($columnRanges) - 1][1];
|
||||
foreach ($this->rawDataLines as $i => $line) {
|
||||
$row = new TableRow();
|
||||
// loop over where all the columns should be
|
||||
|
||||
$previousColumnEnd = null;
|
||||
foreach ($columnRanges as $columnRange) {
|
||||
$isRangeBeyondText = $columnRange[0] >= strlen($line);
|
||||
// check for content in the "gap"
|
||||
if ($previousColumnEnd !== null && ! $isRangeBeyondText) {
|
||||
$gapText = substr($line, $previousColumnEnd, $columnRange[0] - $previousColumnEnd);
|
||||
if (strlen(trim($gapText)) !== 0) {
|
||||
$this->addError(sprintf('Malformed table: content "%s" appears in the "gap" on row "%s"', $gapText, $line));
|
||||
}
|
||||
}
|
||||
|
||||
if ($isRangeBeyondText) {
|
||||
// the text for this line ended earlier. This column should be blank
|
||||
|
||||
$content = '';
|
||||
} elseif ($lastColumnRangeEnd === $columnRange[1]) {
|
||||
// this is the last column, so get the rest of the line
|
||||
// this is because content can go *beyond* the table legally
|
||||
$content = substr(
|
||||
$line,
|
||||
$columnRange[0]
|
||||
);
|
||||
} else {
|
||||
$content = substr(
|
||||
$line,
|
||||
$columnRange[0],
|
||||
$columnRange[1] - $columnRange[0]
|
||||
);
|
||||
}
|
||||
|
||||
$content = trim($content);
|
||||
$row->addColumn($content, 1);
|
||||
|
||||
$previousColumnEnd = $columnRange[1];
|
||||
}
|
||||
|
||||
// is header row?
|
||||
if ($i <= $finalHeadersRow) {
|
||||
$this->headers[$i] = true;
|
||||
}
|
||||
|
||||
$this->data[$i] = $row;
|
||||
}
|
||||
|
||||
$previousRow = null;
|
||||
// check for empty first columns, which means this is
|
||||
// not a new row, but the continuation of the previous row
|
||||
foreach ($this->data as $i => $row) {
|
||||
if ($row->getFirstColumn()->isCompletelyEmpty() && $previousRow !== null) {
|
||||
try {
|
||||
$previousRow->absorbRowContent($row);
|
||||
} catch (InvalidTableStructure $e) {
|
||||
$this->addError($e->getMessage());
|
||||
}
|
||||
|
||||
unset($this->data[$i]);
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
$previousRow = $row;
|
||||
}
|
||||
}
|
||||
|
||||
private function compilePrettyTable(): void
|
||||
{
|
||||
// loop over ALL separator lines to find ALL of the column ranges
|
||||
$columnRanges = [];
|
||||
$finalHeadersRow = 0;
|
||||
foreach ($this->separatorLineConfigs as $rowIndex => $separatorLine) {
|
||||
if ($separatorLine->isHeader()) {
|
||||
if ($finalHeadersRow !== 0) {
|
||||
$this->addError(sprintf('Malformed table: multiple "header rows" using "===" were found. See table lines "%d" and "%d"', $finalHeadersRow + 1, $rowIndex));
|
||||
}
|
||||
|
||||
// indicates that "=" was used
|
||||
$finalHeadersRow = $rowIndex - 1;
|
||||
}
|
||||
|
||||
foreach ($separatorLine->getPartRanges() as $columnRange) {
|
||||
$colStart = $columnRange[0];
|
||||
$colEnd = $columnRange[1];
|
||||
|
||||
// we don't have this "start" yet? just add it
|
||||
// in theory, should only happen for the first row
|
||||
if (! isset($columnRanges[$colStart])) {
|
||||
$columnRanges[$colStart] = $colEnd;
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
// an exact column range we've already seen
|
||||
// OR, this new column goes beyond what we currently
|
||||
// have recorded, which means its a colspan, and so
|
||||
// we already have correctly recorded the "smallest"
|
||||
// current column ranges
|
||||
if ($columnRanges[$colStart] <= $colEnd) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// this is not a new "start", but it is a new "end"
|
||||
// this means that we've found a "shorter" column that
|
||||
// we've seen before. We need to update the "end" of
|
||||
// the existing column, and add a "new" column
|
||||
$previousEnd = $columnRanges[$colStart];
|
||||
|
||||
// A) update the end of this column to the new end
|
||||
$columnRanges[$colStart] = $colEnd;
|
||||
// B) add a new column from this new end, to the previous end
|
||||
$columnRanges[$colEnd + 1] = $previousEnd;
|
||||
ksort($columnRanges);
|
||||
}
|
||||
}
|
||||
|
||||
/** @var TableRow[] $rows */
|
||||
$rows = [];
|
||||
$partialSeparatorRows = [];
|
||||
foreach ($this->rawDataLines as $rowIndex => $line) {
|
||||
$row = new TableRow();
|
||||
|
||||
// if the row is part separator row, part content, this
|
||||
// is a rowspan situation - e.g.
|
||||
// | +----------------+----------------------------+
|
||||
// look for +-----+ pattern
|
||||
if (preg_match('/\+[-]+\+/', $this->rawDataLines[$rowIndex]) === 1) {
|
||||
$partialSeparatorRows[$rowIndex] = true;
|
||||
}
|
||||
|
||||
$currentColumnStart = null;
|
||||
$currentSpan = 1;
|
||||
$previousColumnEnd = null;
|
||||
foreach ($columnRanges as $start => $end) {
|
||||
// a content line that ends before it should
|
||||
if ($end >= strlen($line)) {
|
||||
$this->errors[] = sprintf("Malformed table: Line\n\n%s\n\ndoes not appear to be a complete table row", $line);
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
if ($currentColumnStart !== null) {
|
||||
$gapText = substr($line, $previousColumnEnd, $start - $previousColumnEnd);
|
||||
if (strpos($gapText, '|') === false && strpos($gapText, '+') === false) {
|
||||
// text continued through the "gap". This is a colspan
|
||||
// "+" is an odd character - it's usually "|", but "+" can
|
||||
// happen in row-span situations
|
||||
$currentSpan++;
|
||||
} else {
|
||||
// we just hit a proper "gap" record the line up until now
|
||||
$row->addColumn(
|
||||
substr($line, $currentColumnStart, $previousColumnEnd - $currentColumnStart),
|
||||
$currentSpan
|
||||
);
|
||||
$currentSpan = 1;
|
||||
$currentColumnStart = null;
|
||||
}
|
||||
}
|
||||
|
||||
// if the current column start is null, then set it
|
||||
// other wise, leave it - this is a colspan, and eventually
|
||||
// we want to get all the text starting here
|
||||
if ($currentColumnStart === null) {
|
||||
$currentColumnStart = $start;
|
||||
}
|
||||
|
||||
$previousColumnEnd = $end;
|
||||
}
|
||||
|
||||
// record the last column
|
||||
if ($currentColumnStart !== null) {
|
||||
if ($previousColumnEnd === null) {
|
||||
throw new LogicException('The previous column end is not set yet');
|
||||
}
|
||||
|
||||
$row->addColumn(
|
||||
substr($line, $currentColumnStart, $previousColumnEnd - $currentColumnStart),
|
||||
$currentSpan
|
||||
);
|
||||
}
|
||||
|
||||
$rows[$rowIndex] = $row;
|
||||
}
|
||||
|
||||
$columnIndexesCurrentlyInRowspan = [];
|
||||
foreach ($rows as $rowIndex => $row) {
|
||||
if (isset($partialSeparatorRows[$rowIndex])) {
|
||||
// this row is part content, part separator due to a rowspan
|
||||
// for each column that contains content, we need to
|
||||
// push it onto the last real row's content and record
|
||||
// that this column in the next row should also be
|
||||
// included in that previous row's content
|
||||
foreach ($row->getColumns() as $columnIndex => $column) {
|
||||
if (! $column->isCompletelyEmpty() && str_repeat('-', strlen($column->getContent())) === $column->getContent()) {
|
||||
// only a line separator in this column - not content!
|
||||
continue;
|
||||
}
|
||||
|
||||
$prevTargetColumn = $this->findColumnInPreviousRows((int) $columnIndex, $rows, (int) $rowIndex);
|
||||
$prevTargetColumn->addContent("\n" . $column->getContent());
|
||||
$prevTargetColumn->incrementRowSpan();
|
||||
// mark that this column on the next row should also be added
|
||||
// to the previous row
|
||||
$columnIndexesCurrentlyInRowspan[] = $columnIndex;
|
||||
}
|
||||
|
||||
// remove the row - it's not real
|
||||
unset($rows[$rowIndex]);
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
// check if the previous row was a partial separator row, and
|
||||
// we need to take some columns and add them to a previous row's content
|
||||
foreach ($columnIndexesCurrentlyInRowspan as $columnIndex) {
|
||||
$prevTargetColumn = $this->findColumnInPreviousRows($columnIndex, $rows, (int) $rowIndex);
|
||||
$columnInRowspan = $row->getColumn($columnIndex);
|
||||
if ($columnInRowspan === null) {
|
||||
throw new LogicException(sprintf('Cannot find column for index "%s"', $columnIndex));
|
||||
}
|
||||
|
||||
$prevTargetColumn->addContent("\n" . $columnInRowspan->getContent());
|
||||
|
||||
// now this column actually needs to be removed from this row,
|
||||
// as it's not a real column that needs to be printed
|
||||
$row->removeColumn($columnIndex);
|
||||
}
|
||||
|
||||
$columnIndexesCurrentlyInRowspan = [];
|
||||
|
||||
// if the next row is just $i+1, it means there
|
||||
// was no "separator" and this is really just a
|
||||
// continuation of this row.
|
||||
$nextRowCounter = 1;
|
||||
while (isset($rows[(int) $rowIndex + $nextRowCounter])) {
|
||||
// but if the next line is actually a partial separator, then
|
||||
// it is not a continuation of the content - quit now
|
||||
if (isset($partialSeparatorRows[(int) $rowIndex + $nextRowCounter])) {
|
||||
break;
|
||||
}
|
||||
|
||||
$targetRow = $rows[(int) $rowIndex + $nextRowCounter];
|
||||
unset($rows[(int) $rowIndex + $nextRowCounter]);
|
||||
|
||||
try {
|
||||
$row->absorbRowContent($targetRow);
|
||||
} catch (InvalidTableStructure $e) {
|
||||
$this->addError($e->getMessage());
|
||||
}
|
||||
|
||||
$nextRowCounter++;
|
||||
}
|
||||
}
|
||||
|
||||
// one more loop to set headers
|
||||
foreach ($rows as $rowIndex => $row) {
|
||||
if ($rowIndex > $finalHeadersRow) {
|
||||
continue;
|
||||
}
|
||||
|
||||
$this->headers[$rowIndex] = true;
|
||||
}
|
||||
|
||||
$this->data = $rows;
|
||||
}
|
||||
|
||||
private function getTableAsString(): string
|
||||
{
|
||||
$lines = [];
|
||||
$i = 0;
|
||||
while (isset($this->separatorLineConfigs[$i]) || isset($this->rawDataLines[$i])) {
|
||||
if (isset($this->separatorLineConfigs[$i])) {
|
||||
$lines[] = $this->separatorLineConfigs[$i]->getRawContent();
|
||||
} else {
|
||||
$lines[] = $this->rawDataLines[$i];
|
||||
}
|
||||
|
||||
$i++;
|
||||
}
|
||||
|
||||
return implode("\n", $lines);
|
||||
}
|
||||
|
||||
private function addError(string $message): void
|
||||
{
|
||||
$this->errors[] = $message;
|
||||
}
|
||||
|
||||
/** @param TableRow[] $rows */
|
||||
private function findColumnInPreviousRows(int $columnIndex, array $rows, int $currentRowIndex): TableColumn
|
||||
{
|
||||
/** @var TableRow[] $reversedRows */
|
||||
$reversedRows = array_reverse($rows, true);
|
||||
|
||||
// go through the rows backwards to find the last/previous
|
||||
// row that actually had a real column at this position
|
||||
foreach ($reversedRows as $k => $row) {
|
||||
// start by skipping any future rows, as we go backward
|
||||
if ($k >= $currentRowIndex) {
|
||||
continue;
|
||||
}
|
||||
|
||||
$prevTargetColumn = $row->getColumn($columnIndex);
|
||||
if ($prevTargetColumn !== null) {
|
||||
return $prevTargetColumn;
|
||||
}
|
||||
}
|
||||
|
||||
throw new Exception('Could not find column in any previous rows');
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue