<form method="POST">
    <h3>Editing: ProgressBar.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

/*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier &lt;fabien@symfony.com&gt;
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Symfony\Component\Console\Helper;

use Symfony\Component\Console\Cursor;
use Symfony\Component\Console\Exception\LogicException;
use Symfony\Component\Console\Output\ConsoleOutputInterface;
use Symfony\Component\Console\Output\ConsoleSectionOutput;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Terminal;

/**
 * The ProgressBar provides helpers to display progress output.
 *
 * @author Fabien Potencier &lt;fabien@symfony.com&gt;
 * @author Chris Jones &lt;leeked@gmail.com&gt;
 */
final class ProgressBar
{
    public const FORMAT_VERBOSE = 'verbose';
    public const FORMAT_VERY_VERBOSE = 'very_verbose';
    public const FORMAT_DEBUG = 'debug';
    public const FORMAT_NORMAL = 'normal';

    private const FORMAT_VERBOSE_NOMAX = 'verbose_nomax';
    private const FORMAT_VERY_VERBOSE_NOMAX = 'very_verbose_nomax';
    private const FORMAT_DEBUG_NOMAX = 'debug_nomax';
    private const FORMAT_NORMAL_NOMAX = 'normal_nomax';

    private $barWidth = 28;
    private $barChar;
    private $emptyBarChar = '-';
    private $progressChar = '&gt;';
    private $format;
    private $internalFormat;
    private $redrawFreq = 1;
    private $writeCount;
    private $lastWriteTime;
    private $minSecondsBetweenRedraws = 0;
    private $maxSecondsBetweenRedraws = 1;
    private $output;
    private $step = 0;
    private $max;
    private $startTime;
    private $stepWidth;
    private $percent = 0.0;
    private $messages = [];
    private $overwrite = true;
    private $terminal;
    private $previousMessage;
    private $cursor;

    private static $formatters;
    private static $formats;

    /**
     * @param int $max Maximum steps (0 if unknown)
     */
    public function __construct(OutputInterface $output, int $max = 0, float $minSecondsBetweenRedraws = 1 / 25)
    {
        if ($output instanceof ConsoleOutputInterface) {
            $output = $output-&gt;getErrorOutput();
        }

        $this-&gt;output = $output;
        $this-&gt;setMaxSteps($max);
        $this-&gt;terminal = new Terminal();

        if (0 &lt; $minSecondsBetweenRedraws) {
            $this-&gt;redrawFreq = null;
            $this-&gt;minSecondsBetweenRedraws = $minSecondsBetweenRedraws;
        }

        if (!$this-&gt;output-&gt;isDecorated()) {
            // disable overwrite when output does not support ANSI codes.
            $this-&gt;overwrite = false;

            // set a reasonable redraw frequency so output isn't flooded
            $this-&gt;redrawFreq = null;
        }

        $this-&gt;startTime = time();
        $this-&gt;cursor = new Cursor($output);
    }

    /**
     * Sets a placeholder formatter for a given name.
     *
     * This method also allow you to override an existing placeholder.
     *
     * @param string   $name     The placeholder name (including the delimiter char like %)
     * @param callable $callable A PHP callable
     */
    public static function setPlaceholderFormatterDefinition(string $name, callable $callable): void
    {
        if (!self::$formatters) {
            self::$formatters = self::initPlaceholderFormatters();
        }

        self::$formatters[$name] = $callable;
    }

    /**
     * Gets the placeholder formatter for a given name.
     *
     * @param string $name The placeholder name (including the delimiter char like %)
     */
    public static function getPlaceholderFormatterDefinition(string $name): ?callable
    {
        if (!self::$formatters) {
            self::$formatters = self::initPlaceholderFormatters();
        }

        return self::$formatters[$name] ?? null;
    }

    /**
     * Sets a format for a given name.
     *
     * This method also allow you to override an existing format.
     *
     * @param string $name   The format name
     * @param string $format A format string
     */
    public static function setFormatDefinition(string $name, string $format): void
    {
        if (!self::$formats) {
            self::$formats = self::initFormats();
        }

        self::$formats[$name] = $format;
    }

    /**
     * Gets the format for a given name.
     *
     * @param string $name The format name
     */
    public static function getFormatDefinition(string $name): ?string
    {
        if (!self::$formats) {
            self::$formats = self::initFormats();
        }

        return self::$formats[$name] ?? null;
    }

    /**
     * Associates a text with a named placeholder.
     *
     * The text is displayed when the progress bar is rendered but only
     * when the corresponding placeholder is part of the custom format line
     * (by wrapping the name with %).
     *
     * @param string $message The text to associate with the placeholder
     * @param string $name    The name of the placeholder
     */
    public function setMessage(string $message, string $name = 'message')
    {
        $this-&gt;messages[$name] = $message;
    }

    public function getMessage(string $name = 'message')
    {
        return $this-&gt;messages[$name];
    }

    public function getStartTime(): int
    {
        return $this-&gt;startTime;
    }

    public function getMaxSteps(): int
    {
        return $this-&gt;max;
    }

    public function getProgress(): int
    {
        return $this-&gt;step;
    }

    private function getStepWidth(): int
    {
        return $this-&gt;stepWidth;
    }

    public function getProgressPercent(): float
    {
        return $this-&gt;percent;
    }

    public function getBarOffset(): float
    {
        return floor($this-&gt;max ? $this-&gt;percent * $this-&gt;barWidth : (null === $this-&gt;redrawFreq ? (int) (min(5, $this-&gt;barWidth / 15) * $this-&gt;writeCount) : $this-&gt;step) % $this-&gt;barWidth);
    }

    public function getEstimated(): float
    {
        if (!$this-&gt;step) {
            return 0;
        }

        return round((time() - $this-&gt;startTime) / $this-&gt;step * $this-&gt;max);
    }

    public function getRemaining(): float
    {
        if (!$this-&gt;step) {
            return 0;
        }

        return round((time() - $this-&gt;startTime) / $this-&gt;step * ($this-&gt;max - $this-&gt;step));
    }

    public function setBarWidth(int $size)
    {
        $this-&gt;barWidth = max(1, $size);
    }

    public function getBarWidth(): int
    {
        return $this-&gt;barWidth;
    }

    public function setBarCharacter(string $char)
    {
        $this-&gt;barChar = $char;
    }

    public function getBarCharacter(): string
    {
        return $this-&gt;barChar ?? ($this-&gt;max ? '=' : $this-&gt;emptyBarChar);
    }

    public function setEmptyBarCharacter(string $char)
    {
        $this-&gt;emptyBarChar = $char;
    }

    public function getEmptyBarCharacter(): string
    {
        return $this-&gt;emptyBarChar;
    }

    public function setProgressCharacter(string $char)
    {
        $this-&gt;progressChar = $char;
    }

    public function getProgressCharacter(): string
    {
        return $this-&gt;progressChar;
    }

    public function setFormat(string $format)
    {
        $this-&gt;format = null;
        $this-&gt;internalFormat = $format;
    }

    /**
     * Sets the redraw frequency.
     *
     * @param int|null $freq The frequency in steps
     */
    public function setRedrawFrequency(?int $freq)
    {
        $this-&gt;redrawFreq = null !== $freq ? max(1, $freq) : null;
    }

    public function minSecondsBetweenRedraws(float $seconds): void
    {
        $this-&gt;minSecondsBetweenRedraws = $seconds;
    }

    public function maxSecondsBetweenRedraws(float $seconds): void
    {
        $this-&gt;maxSecondsBetweenRedraws = $seconds;
    }

    /**
     * Returns an iterator that will automatically update the progress bar when iterated.
     *
     * @param int|null $max Number of steps to complete the bar (0 if indeterminate), if null it will be inferred from $iterable
     */
    public function iterate(iterable $iterable, ?int $max = null): iterable
    {
        $this-&gt;start($max ?? (is_countable($iterable) ? \count($iterable) : 0));

        foreach ($iterable as $key =&gt; $value) {
            yield $key =&gt; $value;

            $this-&gt;advance();
        }

        $this-&gt;finish();
    }

    /**
     * Starts the progress output.
     *
     * @param int|null $max Number of steps to complete the bar (0 if indeterminate), null to leave unchanged
     */
    public function start(?int $max = null)
    {
        $this-&gt;startTime = time();
        $this-&gt;step = 0;
        $this-&gt;percent = 0.0;

        if (null !== $max) {
            $this-&gt;setMaxSteps($max);
        }

        $this-&gt;display();
    }

    /**
     * Advances the progress output X steps.
     *
     * @param int $step Number of steps to advance
     */
    public function advance(int $step = 1)
    {
        $this-&gt;setProgress($this-&gt;step + $step);
    }

    /**
     * Sets whether to overwrite the progressbar, false for new line.
     */
    public function setOverwrite(bool $overwrite)
    {
        $this-&gt;overwrite = $overwrite;
    }

    public function setProgress(int $step)
    {
        if ($this-&gt;max &amp;&amp; $step &gt; $this-&gt;max) {
            $this-&gt;max = $step;
        } elseif ($step &lt; 0) {
            $step = 0;
        }

        $redrawFreq = $this-&gt;redrawFreq ?? (($this-&gt;max ?: 10) / 10);
        $prevPeriod = (int) ($this-&gt;step / $redrawFreq);
        $currPeriod = (int) ($step / $redrawFreq);
        $this-&gt;step = $step;
        $this-&gt;percent = $this-&gt;max ? (float) $this-&gt;step / $this-&gt;max : 0;
        $timeInterval = microtime(true) - $this-&gt;lastWriteTime;

        // Draw regardless of other limits
        if ($this-&gt;max === $step) {
            $this-&gt;display();

            return;
        }

        // Throttling
        if ($timeInterval &lt; $this-&gt;minSecondsBetweenRedraws) {
            return;
        }

        // Draw each step period, but not too late
        if ($prevPeriod !== $currPeriod || $timeInterval &gt;= $this-&gt;maxSecondsBetweenRedraws) {
            $this-&gt;display();
        }
    }

    public function setMaxSteps(int $max)
    {
        $this-&gt;format = null;
        $this-&gt;max = max(0, $max);
        $this-&gt;stepWidth = $this-&gt;max ? Helper::width((string) $this-&gt;max) : 4;
    }

    /**
     * Finishes the progress output.
     */
    public function finish(): void
    {
        if (!$this-&gt;max) {
            $this-&gt;max = $this-&gt;step;
        }

        if ($this-&gt;step === $this-&gt;max &amp;&amp; !$this-&gt;overwrite) {
            // prevent double 100% output
            return;
        }

        $this-&gt;setProgress($this-&gt;max);
    }

    /**
     * Outputs the current progress string.
     */
    public function display(): void
    {
        if (OutputInterface::VERBOSITY_QUIET === $this-&gt;output-&gt;getVerbosity()) {
            return;
        }

        if (null === $this-&gt;format) {
            $this-&gt;setRealFormat($this-&gt;internalFormat ?: $this-&gt;determineBestFormat());
        }

        $this-&gt;overwrite($this-&gt;buildLine());
    }

    /**
     * Removes the progress bar from the current line.
     *
     * This is useful if you wish to write some output
     * while a progress bar is running.
     * Call display() to show the progress bar again.
     */
    public function clear(): void
    {
        if (!$this-&gt;overwrite) {
            return;
        }

        if (null === $this-&gt;format) {
            $this-&gt;setRealFormat($this-&gt;internalFormat ?: $this-&gt;determineBestFormat());
        }

        $this-&gt;overwrite('');
    }

    private function setRealFormat(string $format)
    {
        // try to use the _nomax variant if available
        if (!$this-&gt;max &amp;&amp; null !== self::getFormatDefinition($format.'_nomax')) {
            $this-&gt;format = self::getFormatDefinition($format.'_nomax');
        } elseif (null !== self::getFormatDefinition($format)) {
            $this-&gt;format = self::getFormatDefinition($format);
        } else {
            $this-&gt;format = $format;
        }
    }

    /**
     * Overwrites a previous message to the output.
     */
    private function overwrite(string $message): void
    {
        if ($this-&gt;previousMessage === $message) {
            return;
        }

        $originalMessage = $message;

        if ($this-&gt;overwrite) {
            if (null !== $this-&gt;previousMessage) {
                if ($this-&gt;output instanceof ConsoleSectionOutput) {
                    $messageLines = explode(&quot;\n&quot;, $this-&gt;previousMessage);
                    $lineCount = \count($messageLines);
                    foreach ($messageLines as $messageLine) {
                        $messageLineLength = Helper::width(Helper::removeDecoration($this-&gt;output-&gt;getFormatter(), $messageLine));
                        if ($messageLineLength &gt; $this-&gt;terminal-&gt;getWidth()) {
                            $lineCount += floor($messageLineLength / $this-&gt;terminal-&gt;getWidth());
                        }
                    }
                    $this-&gt;output-&gt;clear($lineCount);
                } else {
                    $lineCount = substr_count($this-&gt;previousMessage, &quot;\n&quot;);
                    for ($i = 0; $i &lt; $lineCount; ++$i) {
                        $this-&gt;cursor-&gt;moveToColumn(1);
                        $this-&gt;cursor-&gt;clearLine();
                        $this-&gt;cursor-&gt;moveUp();
                    }

                    $this-&gt;cursor-&gt;moveToColumn(1);
                    $this-&gt;cursor-&gt;clearLine();
                }
            }
        } elseif ($this-&gt;step &gt; 0) {
            $message = \PHP_EOL.$message;
        }

        $this-&gt;previousMessage = $originalMessage;
        $this-&gt;lastWriteTime = microtime(true);

        $this-&gt;output-&gt;write($message);
        ++$this-&gt;writeCount;
    }

    private function determineBestFormat(): string
    {
        switch ($this-&gt;output-&gt;getVerbosity()) {
            // OutputInterface::VERBOSITY_QUIET: display is disabled anyway
            case OutputInterface::VERBOSITY_VERBOSE:
                return $this-&gt;max ? self::FORMAT_VERBOSE : self::FORMAT_VERBOSE_NOMAX;
            case OutputInterface::VERBOSITY_VERY_VERBOSE:
                return $this-&gt;max ? self::FORMAT_VERY_VERBOSE : self::FORMAT_VERY_VERBOSE_NOMAX;
            case OutputInterface::VERBOSITY_DEBUG:
                return $this-&gt;max ? self::FORMAT_DEBUG : self::FORMAT_DEBUG_NOMAX;
            default:
                return $this-&gt;max ? self::FORMAT_NORMAL : self::FORMAT_NORMAL_NOMAX;
        }
    }

    private static function initPlaceholderFormatters(): array
    {
        return [
            'bar' =&gt; function (self $bar, OutputInterface $output) {
                $completeBars = $bar-&gt;getBarOffset();
                $display = str_repeat($bar-&gt;getBarCharacter(), $completeBars);
                if ($completeBars &lt; $bar-&gt;getBarWidth()) {
                    $emptyBars = $bar-&gt;getBarWidth() - $completeBars - Helper::length(Helper::removeDecoration($output-&gt;getFormatter(), $bar-&gt;getProgressCharacter()));
                    $display .= $bar-&gt;getProgressCharacter().str_repeat($bar-&gt;getEmptyBarCharacter(), $emptyBars);
                }

                return $display;
            },
            'elapsed' =&gt; function (self $bar) {
                return Helper::formatTime(time() - $bar-&gt;getStartTime());
            },
            'remaining' =&gt; function (self $bar) {
                if (!$bar-&gt;getMaxSteps()) {
                    throw new LogicException('Unable to display the remaining time if the maximum number of steps is not set.');
                }

                return Helper::formatTime($bar-&gt;getRemaining());
            },
            'estimated' =&gt; function (self $bar) {
                if (!$bar-&gt;getMaxSteps()) {
                    throw new LogicException('Unable to display the estimated time if the maximum number of steps is not set.');
                }

                return Helper::formatTime($bar-&gt;getEstimated());
            },
            'memory' =&gt; function (self $bar) {
                return Helper::formatMemory(memory_get_usage(true));
            },
            'current' =&gt; function (self $bar) {
                return str_pad($bar-&gt;getProgress(), $bar-&gt;getStepWidth(), ' ', \STR_PAD_LEFT);
            },
            'max' =&gt; function (self $bar) {
                return $bar-&gt;getMaxSteps();
            },
            'percent' =&gt; function (self $bar) {
                return floor($bar-&gt;getProgressPercent() * 100);
            },
        ];
    }

    private static function initFormats(): array
    {
        return [
            self::FORMAT_NORMAL =&gt; ' %current%/%max% [%bar%] %percent:3s%%',
            self::FORMAT_NORMAL_NOMAX =&gt; ' %current% [%bar%]',

            self::FORMAT_VERBOSE =&gt; ' %current%/%max% [%bar%] %percent:3s%% %elapsed:6s%',
            self::FORMAT_VERBOSE_NOMAX =&gt; ' %current% [%bar%] %elapsed:6s%',

            self::FORMAT_VERY_VERBOSE =&gt; ' %current%/%max% [%bar%] %percent:3s%% %elapsed:6s%/%estimated:-6s%',
            self::FORMAT_VERY_VERBOSE_NOMAX =&gt; ' %current% [%bar%] %elapsed:6s%',

            self::FORMAT_DEBUG =&gt; ' %current%/%max% [%bar%] %percent:3s%% %elapsed:6s%/%estimated:-6s% %memory:6s%',
            self::FORMAT_DEBUG_NOMAX =&gt; ' %current% [%bar%] %elapsed:6s% %memory:6s%',
        ];
    }

    private function buildLine(): string
    {
        $regex = &quot;{%([a-z\-_]+)(?:\:([^%]+))?%}i&quot;;
        $callback = function ($matches) {
            if ($formatter = $this::getPlaceholderFormatterDefinition($matches[1])) {
                $text = $formatter($this, $this-&gt;output);
            } elseif (isset($this-&gt;messages[$matches[1]])) {
                $text = $this-&gt;messages[$matches[1]];
            } else {
                return $matches[0];
            }

            if (isset($matches[2])) {
                $text = sprintf('%'.$matches[2], $text);
            }

            return $text;
        };
        $line = preg_replace_callback($regex, $callback, $this-&gt;format);

        // gets string length for each sub line with multiline format
        $linesLength = array_map(function ($subLine) {
            return Helper::width(Helper::removeDecoration($this-&gt;output-&gt;getFormatter(), rtrim($subLine, &quot;\r&quot;)));
        }, explode(&quot;\n&quot;, $line));

        $linesWidth = max($linesLength);

        $terminalWidth = $this-&gt;terminal-&gt;getWidth();
        if ($linesWidth &lt;= $terminalWidth) {
            return $line;
        }

        $this-&gt;setBarWidth($this-&gt;barWidth - $linesWidth + $terminalWidth);

        return preg_replace_callback($regex, $callback, $this-&gt;format);
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>