Upgrade 1-11.38

vendor/symfony/console/Helper/Table.php

@@ -12,6 +12,10 @@
 namespace Symfony\Component\Console\Helper;
 
 use Symfony\Component\Console\Exception\InvalidArgumentException;
+use Symfony\Component\Console\Exception\RuntimeException;
+use Symfony\Component\Console\Formatter\OutputFormatter;
+use Symfony\Component\Console\Formatter\WrappableOutputFormatterInterface;
+use Symfony\Component\Console\Output\ConsoleSectionOutput;
 use Symfony\Component\Console\Output\OutputInterface;
 
 /**
@@ -21,9 +25,20 @@ use Symfony\Component\Console\Output\OutputInterface;
  * @author Саша Стаменковић <umpirsky@gmail.com>
  * @author Abdellatif Ait boudad <a.aitboudad@gmail.com>
  * @author Max Grigorian <maxakawizard@gmail.com>
+ * @author Dany Maillard <danymaillard93b@gmail.com>
  */
 class Table
 {
+    private const SEPARATOR_TOP = 0;
+    private const SEPARATOR_TOP_BOTTOM = 1;
+    private const SEPARATOR_MID = 2;
+    private const SEPARATOR_BOTTOM = 3;
+    private const BORDER_OUTSIDE = 0;
+    private const BORDER_INSIDE = 1;
+
+    private $headerTitle;
+    private $footerTitle;
+
     /**
      * Table headers.
      */
@@ -67,9 +82,12 @@ class Table
      * @var array
      */
     private $columnWidths = [];
+    private $columnMaxWidths = [];
 
     private static $styles;
 
+    private $rendered = false;
+
     public function __construct(OutputInterface $output)
     {
         $this->output = $output;
@@ -168,11 +186,7 @@ class Table
      */
     public function getColumnStyle($columnIndex)
     {
-        if (isset($this->columnStyles[$columnIndex])) {
-            return $this->columnStyles[$columnIndex];
-        }
-
-        return $this->getStyle();
+        return $this->columnStyles[$columnIndex] ?? $this->getStyle();
     }
 
     /**
@@ -193,6 +207,8 @@ class Table
     /**
      * Sets the minimum width of all columns.
      *
+     * @param array $widths
+     *
      * @return $this
      */
     public function setColumnWidths(array $widths)
@@ -205,6 +221,25 @@ class Table
         return $this;
     }
 
+    /**
+     * Sets the maximum width of a column.
+     *
+     * Any cell within this column which contents exceeds the specified width will be wrapped into multiple lines, while
+     * formatted strings are preserved.
+     *
+     * @return $this
+     */
+    public function setColumnMaxWidth(int $columnIndex, int $width): self
+    {
+        if (!$this->output->getFormatter() instanceof WrappableOutputFormatterInterface) {
+            throw new \LogicException(sprintf('Setting a maximum column width is only supported when using a "%s" formatter, got "%s".', WrappableOutputFormatterInterface::class, \get_class($this->output->getFormatter())));
+        }
+
+        $this->columnMaxWidths[$columnIndex] = $width;
+
+        return $this;
+    }
+
     public function setHeaders(array $headers)
     {
         $headers = array_values($headers);
@@ -250,6 +285,25 @@ class Table
         return $this;
     }
 
+    /**
+     * Adds a row to the table, and re-renders the table.
+     */
+    public function appendRow($row): self
+    {
+        if (!$this->output instanceof ConsoleSectionOutput) {
+            throw new RuntimeException(sprintf('Output should be an instance of "%s" when calling "%s".', ConsoleSectionOutput::class, __METHOD__));
+        }
+
+        if ($this->rendered) {
+            $this->output->clear($this->calculateRowCount());
+        }
+
+        $this->addRow($row);
+        $this->render();
+
+        return $this;
+    }
+
     public function setRow($column, array $row)
     {
         $this->rows[$column] = $row;
@@ -257,6 +311,20 @@ class Table
         return $this;
     }
 
+    public function setHeaderTitle(?string $title): self
+    {
+        $this->headerTitle = $title;
+
+        return $this;
+    }
+
+    public function setFooterTitle(?string $title): self
+    {
+        $this->footerTitle = $title;
+
+        return $this;
+    }
+
     /**
      * Renders table to output.
      *
@@ -272,31 +340,45 @@ class Table
      */
     public function render()
     {
-        $this->calculateNumberOfColumns();
-        $rows = $this->buildTableRows($this->rows);
-        $headers = $this->buildTableRows($this->headers);
+        $rows = array_merge($this->headers, [$divider = new TableSeparator()], $this->rows);
+        $this->calculateNumberOfColumns($rows);
 
-        $this->calculateColumnsWidth(array_merge($headers, $rows));
+        $rows = $this->buildTableRows($rows);
+        $this->calculateColumnsWidth($rows);
 
-        $this->renderRowSeparator();
-        if (!empty($headers)) {
-            foreach ($headers as $header) {
-                $this->renderRow($header, $this->style->getCellHeaderFormat());
-                $this->renderRowSeparator();
-            }
-        }
+        $isHeader = true;
+        $isFirstRow = false;
         foreach ($rows as $row) {
+            if ($divider === $row) {
+                $isHeader = false;
+                $isFirstRow = true;
+
+                continue;
+            }
             if ($row instanceof TableSeparator) {
                 $this->renderRowSeparator();
-            } else {
-                $this->renderRow($row, $this->style->getCellRowFormat());
+
+                continue;
             }
+            if (!$row) {
+                continue;
+            }
+
+            if ($isHeader || $isFirstRow) {
+                if ($isFirstRow) {
+                    $this->renderRowSeparator(self::SEPARATOR_TOP_BOTTOM);
+                    $isFirstRow = false;
+                } else {
+                    $this->renderRowSeparator(self::SEPARATOR_TOP, $this->headerTitle, $this->style->getHeaderTitleFormat());
+                }
+            }
+
+            $this->renderRow($row, $isHeader ? $this->style->getCellHeaderFormat() : $this->style->getCellRowFormat());
         }
-        if (!empty($rows)) {
-            $this->renderRowSeparator();
-        }
+        $this->renderRowSeparator(self::SEPARATOR_BOTTOM, $this->footerTitle, $this->style->getFooterTitleFormat());
 
         $this->cleanup();
+        $this->rendered = true;
     }
 
     /**
@@ -306,19 +388,49 @@ class Table
      *
      *     +-----+-----------+-------+
      */
-    private function renderRowSeparator()
+    private function renderRowSeparator(int $type = self::SEPARATOR_MID, string $title = null, string $titleFormat = null)
     {
         if (0 === $count = $this->numberOfColumns) {
             return;
         }
 
-        if (!$this->style->getHorizontalBorderChar() && !$this->style->getCrossingChar()) {
+        $borders = $this->style->getBorderChars();
+        if (!$borders[0] && !$borders[2] && !$this->style->getCrossingChar()) {
             return;
         }
 
-        $markup = $this->style->getCrossingChar();
+        $crossings = $this->style->getCrossingChars();
+        if (self::SEPARATOR_MID === $type) {
+            list($horizontal, $leftChar, $midChar, $rightChar) = [$borders[2], $crossings[8], $crossings[0], $crossings[4]];
+        } elseif (self::SEPARATOR_TOP === $type) {
+            list($horizontal, $leftChar, $midChar, $rightChar) = [$borders[0], $crossings[1], $crossings[2], $crossings[3]];
+        } elseif (self::SEPARATOR_TOP_BOTTOM === $type) {
+            list($horizontal, $leftChar, $midChar, $rightChar) = [$borders[0], $crossings[9], $crossings[10], $crossings[11]];
+        } else {
+            list($horizontal, $leftChar, $midChar, $rightChar) = [$borders[0], $crossings[7], $crossings[6], $crossings[5]];
+        }
+
+        $markup = $leftChar;
         for ($column = 0; $column < $count; ++$column) {
-            $markup .= str_repeat($this->style->getHorizontalBorderChar(), $this->effectiveColumnWidths[$column]).$this->style->getCrossingChar();
+            $markup .= str_repeat($horizontal, $this->effectiveColumnWidths[$column]);
+            $markup .= $column === $count - 1 ? $rightChar : $midChar;
+        }
+
+        if (null !== $title) {
+            $titleLength = Helper::strlenWithoutDecoration($formatter = $this->output->getFormatter(), $formattedTitle = sprintf($titleFormat, $title));
+            $markupLength = Helper::strlen($markup);
+            if ($titleLength > $limit = $markupLength - 4) {
+                $titleLength = $limit;
+                $formatLength = Helper::strlenWithoutDecoration($formatter, sprintf($titleFormat, ''));
+                $formattedTitle = sprintf($titleFormat, Helper::substr($title, 0, $limit - $formatLength - 3).'...');
+            }
+
+            $titleStart = ($markupLength - $titleLength) / 2;
+            if (false === mb_detect_encoding($markup, null, true)) {
+                $markup = substr_replace($markup, $formattedTitle, $titleStart, $titleLength);
+            } else {
+                $markup = mb_substr($markup, 0, $titleStart).$formattedTitle.mb_substr($markup, $titleStart + $titleLength);
+            }
         }
 
         $this->output->writeln(sprintf($this->style->getBorderFormat(), $markup));
@@ -327,9 +439,11 @@ class Table
     /**
      * Renders vertical column separator.
      */
-    private function renderColumnSeparator()
+    private function renderColumnSeparator($type = self::BORDER_OUTSIDE)
     {
-        return sprintf($this->style->getBorderFormat(), $this->style->getVerticalBorderChar());
+        $borders = $this->style->getBorderChars();
+
+        return sprintf($this->style->getBorderFormat(), self::BORDER_OUTSIDE === $type ? $borders[1] : $borders[3]);
     }
 
     /**
@@ -338,30 +452,23 @@ class Table
      * Example:
      *
      *     | 9971-5-0210-0 | A Tale of Two Cities  | Charles Dickens  |
-     *
-     * @param string $cellFormat
      */
-    private function renderRow(array $row, $cellFormat)
+    private function renderRow(array $row, string $cellFormat)
     {
-        if (empty($row)) {
-            return;
-        }
-
-        $rowContent = $this->renderColumnSeparator();
-        foreach ($this->getRowColumns($row) as $column) {
+        $rowContent = $this->renderColumnSeparator(self::BORDER_OUTSIDE);
+        $columns = $this->getRowColumns($row);
+        $last = \count($columns) - 1;
+        foreach ($columns as $i => $column) {
             $rowContent .= $this->renderCell($row, $column, $cellFormat);
-            $rowContent .= $this->renderColumnSeparator();
+            $rowContent .= $this->renderColumnSeparator($last === $i ? self::BORDER_OUTSIDE : self::BORDER_INSIDE);
         }
         $this->output->writeln($rowContent);
     }
 
     /**
      * Renders table cell with padding.
-     *
-     * @param int    $column
-     * @param string $cellFormat
      */
-    private function renderCell(array $row, $column, $cellFormat)
+    private function renderCell(array $row, int $column, string $cellFormat)
     {
         $cell = isset($row[$column]) ? $row[$column] : '';
         $width = $this->effectiveColumnWidths[$column];
@@ -380,7 +487,7 @@ class Table
         $style = $this->getColumnStyle($column);
 
         if ($cell instanceof TableSeparator) {
-            return sprintf($style->getBorderFormat(), str_repeat($style->getHorizontalBorderChar(), $width));
+            return sprintf($style->getBorderFormat(), str_repeat($style->getBorderChars()[2], $width));
         }
 
         $width += Helper::strlen($cell) - Helper::strlenWithoutDecoration($this->output->getFormatter(), $cell);
@@ -392,14 +499,10 @@ class Table
     /**
      * Calculate number of columns for this table.
      */
-    private function calculateNumberOfColumns()
+    private function calculateNumberOfColumns($rows)
     {
-        if (null !== $this->numberOfColumns) {
-            return;
-        }
-
         $columns = [0];
-        foreach (array_merge($this->headers, $this->rows) as $row) {
+        foreach ($rows as $row) {
             if ($row instanceof TableSeparator) {
                 continue;
             }
@@ -412,19 +515,28 @@ class Table
 
     private function buildTableRows($rows)
     {
+        /** @var WrappableOutputFormatterInterface $formatter */
+        $formatter = $this->output->getFormatter();
         $unmergedRows = [];
         for ($rowKey = 0; $rowKey < \count($rows); ++$rowKey) {
             $rows = $this->fillNextRows($rows, $rowKey);
 
             // Remove any new line breaks and replace it with a new line
             foreach ($rows[$rowKey] as $column => $cell) {
+                $colspan = $cell instanceof TableCell ? $cell->getColspan() : 1;
+
+                if (isset($this->columnMaxWidths[$column]) && Helper::strlenWithoutDecoration($formatter, $cell) > $this->columnMaxWidths[$column]) {
+                    $cell = $formatter->formatAndWrap($cell, $this->columnMaxWidths[$column] * $colspan);
+                }
                 if (!strstr($cell, "\n")) {
                     continue;
                 }
+                $escaped = implode("\n", array_map([OutputFormatter::class, 'escapeTrailingBackslash'], explode("\n", $cell)));
+                $cell = $cell instanceof TableCell ? new TableCell($escaped, ['colspan' => $cell->getColspan()]) : $escaped;
                 $lines = explode("\n", str_replace("\n", "<fg=default;bg=default>\n</>", $cell));
                 foreach ($lines as $lineKey => $line) {
-                    if ($cell instanceof TableCell) {
-                        $line = new TableCell($line, ['colspan' => $cell->getColspan()]);
+                    if ($colspan > 1) {
+                        $line = new TableCell($line, ['colspan' => $colspan]);
                     }
                     if (0 === $lineKey) {
                         $rows[$rowKey][$column] = $line;
@@ -435,32 +547,43 @@ class Table
             }
         }
 
-        $tableRows = [];
-        foreach ($rows as $rowKey => $row) {
-            $tableRows[] = $this->fillCells($row);
-            if (isset($unmergedRows[$rowKey])) {
-                $tableRows = array_merge($tableRows, $unmergedRows[$rowKey]);
+        return new TableRows(function () use ($rows, $unmergedRows) {
+            foreach ($rows as $rowKey => $row) {
+                yield $this->fillCells($row);
+
+                if (isset($unmergedRows[$rowKey])) {
+                    foreach ($unmergedRows[$rowKey] as $row) {
+                        yield $row;
+                    }
+                }
             }
+        });
+    }
+
+    private function calculateRowCount(): int
+    {
+        $numberOfRows = \count(iterator_to_array($this->buildTableRows(array_merge($this->headers, [new TableSeparator()], $this->rows))));
+
+        if ($this->headers) {
+            ++$numberOfRows; // Add row for header separator
         }
 
-        return $tableRows;
+        ++$numberOfRows; // Add row for footer separator
+
+        return $numberOfRows;
     }
 
     /**
      * fill rows that contains rowspan > 1.
      *
-     * @param int $line
-     *
-     * @return array
-     *
      * @throws InvalidArgumentException
      */
-    private function fillNextRows(array $rows, $line)
+    private function fillNextRows(array $rows, int $line): array
     {
         $unmergedRows = [];
         foreach ($rows[$line] as $column => $cell) {
             if (null !== $cell && !$cell instanceof TableCell && !is_scalar($cell) && !(\is_object($cell) && method_exists($cell, '__toString'))) {
-                throw new InvalidArgumentException(sprintf('A cell must be a TableCell, a scalar or an object implementing "__toString()", "%s" given.', \gettype($cell)));
+                throw new InvalidArgumentException(sprintf('A cell must be a TableCell, a scalar or an object implementing __toString, %s given.', \gettype($cell)));
             }
             if ($cell instanceof TableCell && $cell->getRowspan() > 1) {
                 $nbLines = $cell->getRowspan() - 1;
@@ -508,8 +631,6 @@ class Table
 
     /**
      * fill cells for a row that contains colspan > 1.
-     *
-     * @return array
      */
     private function fillCells($row)
     {
@@ -527,12 +648,7 @@ class Table
         return $newRow ?: $row;
     }
 
-    /**
-     * @param int $line
-     *
-     * @return array
-     */
-    private function copyRow(array $rows, $line)
+    private function copyRow(array $rows, int $line): array
     {
         $row = $rows[$line];
         foreach ($row as $cellKey => $cellValue) {
@@ -547,10 +663,8 @@ class Table
 
     /**
      * Gets number of columns by row.
-     *
-     * @return int
      */
-    private function getNumberOfColumns(array $row)
+    private function getNumberOfColumns(array $row): int
     {
         $columns = \count($row);
         foreach ($row as $column) {
@@ -562,10 +676,8 @@ class Table
 
     /**
      * Gets list of columns for the given row.
-     *
-     * @return array
      */
-    private function getRowColumns(array $row)
+    private function getRowColumns(array $row): array
     {
         $columns = range(0, $this->numberOfColumns - 1);
         foreach ($row as $cellKey => $cell) {
@@ -581,7 +693,7 @@ class Table
     /**
      * Calculates columns widths.
      */
-    private function calculateColumnsWidth(array $rows)
+    private function calculateColumnsWidth(iterable $rows)
     {
         for ($column = 0; $column < $this->numberOfColumns; ++$column) {
             $lengths = [];
@@ -610,24 +722,12 @@ class Table
         }
     }
 
-    /**
-     * Gets column width.
-     *
-     * @return int
-     */
-    private function getColumnSeparatorWidth()
+    private function getColumnSeparatorWidth(): int
     {
-        return Helper::strlen(sprintf($this->style->getBorderFormat(), $this->style->getVerticalBorderChar()));
+        return Helper::strlen(sprintf($this->style->getBorderFormat(), $this->style->getBorderChars()[3]));
     }
 
-    /**
-     * Gets cell width.
-     *
-     * @param int $column
-     *
-     * @return int
-     */
-    private function getCellWidth(array $row, $column)
+    private function getCellWidth(array $row, int $column): int
     {
         $cellWidth = 0;
 
@@ -637,8 +737,9 @@ class Table
         }
 
         $columnWidth = isset($this->columnWidths[$column]) ? $this->columnWidths[$column] : 0;
+        $cellWidth = max($cellWidth, $columnWidth);
 
-        return max($cellWidth, $columnWidth);
+        return isset($this->columnMaxWidths[$column]) ? min($this->columnMaxWidths[$column], $cellWidth) : $cellWidth;
     }
 
     /**
@@ -654,32 +755,46 @@ class Table
     {
         $borderless = new TableStyle();
         $borderless
-            ->setHorizontalBorderChar('=')
-            ->setVerticalBorderChar(' ')
-            ->setCrossingChar(' ')
+            ->setHorizontalBorderChars('=')
+            ->setVerticalBorderChars(' ')
+            ->setDefaultCrossingChar(' ')
         ;
 
         $compact = new TableStyle();
         $compact
-            ->setHorizontalBorderChar('')
-            ->setVerticalBorderChar(' ')
-            ->setCrossingChar('')
+            ->setHorizontalBorderChars('')
+            ->setVerticalBorderChars(' ')
+            ->setDefaultCrossingChar('')
             ->setCellRowContentFormat('%s')
         ;
 
         $styleGuide = new TableStyle();
         $styleGuide
-            ->setHorizontalBorderChar('-')
-            ->setVerticalBorderChar(' ')
-            ->setCrossingChar(' ')
+            ->setHorizontalBorderChars('-')
+            ->setVerticalBorderChars(' ')
+            ->setDefaultCrossingChar(' ')
             ->setCellHeaderFormat('%s')
         ;
 
+        $box = (new TableStyle())
+            ->setHorizontalBorderChars('─')
+            ->setVerticalBorderChars('│')
+            ->setCrossingChars('┼', '┌', '┬', '┐', '┤', '┘', '┴', '└', '├')
+        ;
+
+        $boxDouble = (new TableStyle())
+            ->setHorizontalBorderChars('═', '─')
+            ->setVerticalBorderChars('║', '│')
+            ->setCrossingChars('┼', '╔', '╤', '╗', '╢', '╝', '╧', '╚', '╟', '╠', '╪', '╣')
+        ;
+
         return [
             'default' => new TableStyle(),
             'borderless' => $borderless,
             'compact' => $compact,
             'symfony-style-guide' => $styleGuide,
+            'box' => $box,
+            'box-double' => $boxDouble,
         ];
     }