vendor and env first commit

vendor/maximebf/debugbar/src/DebugBar/DataCollector/AggregatedCollector.php

@@ -0,0 +1,190 @@
+<?php
+/*
+ * This file is part of the DebugBar package.
+ *
+ * (c) 2013 Maxime Bouroumeau-Fuseau
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace DebugBar\DataCollector;
+
+use ArrayAccess;
+use DebugBar\DebugBarException;
+
+/**
+ * Aggregates data from multiple collectors
+ *
+ * <code>
+ * $aggcollector = new AggregateCollector('foobar');
+ * $aggcollector->addCollector(new MessagesCollector('msg1'));
+ * $aggcollector->addCollector(new MessagesCollector('msg2'));
+ * $aggcollector['msg1']->addMessage('hello world');
+ * </code>
+ */
+class AggregatedCollector implements DataCollectorInterface, ArrayAccess
+{
+    protected $name;
+
+    protected $mergeProperty;
+
+    protected $sort;
+
+    protected $collectors = array();
+
+    /**
+     * @param string $name
+     * @param string $mergeProperty
+     * @param boolean $sort
+     */
+    public function __construct($name, $mergeProperty = null, $sort = false)
+    {
+        $this->name = $name;
+        $this->mergeProperty = $mergeProperty;
+        $this->sort = $sort;
+    }
+
+    /**
+     * @param DataCollectorInterface $collector
+     */
+    public function addCollector(DataCollectorInterface $collector) : void
+    {
+        $this->collectors[$collector->getName()] = $collector;
+    }
+
+    /**
+     * @return array
+     */
+    public function getCollectors() : array
+    {
+        return $this->collectors;
+    }
+
+    /**
+     * Merge data from one of the key/value pair of the collected data
+     *
+     * @param string $property
+     */
+    public function setMergeProperty($property) : void
+    {
+        $this->mergeProperty = $property;
+    }
+
+    /**
+     * @return string
+     */
+    public function getMergeProperty() : string
+    {
+        return $this->mergeProperty;
+    }
+
+    /**
+     * Sorts the collected data
+     *
+     * If true, sorts using sort()
+     * If it is a string, sorts the data using the value from a key/value pair of the array
+     *
+     * @param bool|string $sort
+     */
+    public function setSort($sort) : void
+    {
+        $this->sort = $sort;
+    }
+
+    /**
+     * @return bool|string
+     */
+    public function getSort()
+    {
+        return $this->sort;
+    }
+
+    /**
+     * @return array
+     */
+    public function collect() : array
+    {
+        $aggregate = array();
+        foreach ($this->collectors as $collector) {
+            $data = $collector->collect();
+            if ($this->mergeProperty !== null) {
+                $data = $data[$this->mergeProperty];
+            }
+            $aggregate = array_merge($aggregate, $data);
+        }
+
+        return $this->sort($aggregate);
+    }
+
+    /**
+     * Sorts the collected data
+     *
+     * @param array $data
+     * @return array
+     */
+    protected function sort($data) : array
+    {
+        if (is_string($this->sort)) {
+            $p = $this->sort;
+            usort($data, function ($a, $b) use ($p) {
+                if ($a[$p] == $b[$p]) {
+                    return 0;
+                }
+                return $a[$p] < $b[$p] ? -1 : 1;
+            });
+        } elseif ($this->sort === true) {
+            sort($data);
+        }
+        return $data;
+    }
+
+    /**
+     * @return string
+     */
+    public function getName() : string
+    {
+        return $this->name;
+    }
+
+    // --------------------------------------------
+    // ArrayAccess implementation
+
+    /**
+     * @param mixed $key
+     * @param mixed $value
+     * @throws DebugBarException
+     */
+    public function offsetSet($key, $value): void
+    {
+        throw new DebugBarException("AggregatedCollector[] is read-only");
+    }
+
+    /**
+     * @param mixed $key
+     * @return mixed
+     */
+    #[\ReturnTypeWillChange]
+    public function offsetGet($key)
+    {
+        return $this->collectors[$key];
+    }
+
+    /**
+     * @param mixed $key
+     * @return bool
+     */
+    public function offsetExists($key): bool
+    {
+        return isset($this->collectors[$key]);
+    }
+
+    /**
+     * @param mixed $key
+     * @throws DebugBarException
+     */
+    public function offsetUnset($key): void
+    {
+        throw new DebugBarException("AggregatedCollector[] is read-only");
+    }
+}

vendor/maximebf/debugbar/src/DebugBar/DataCollector/AssetProvider.php

@@ -0,0 +1,43 @@
+<?php
+/*
+ * This file is part of the DebugBar package.
+ *
+ * (c) 2013 Maxime Bouroumeau-Fuseau
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace DebugBar\DataCollector;
+
+/**
+ * Indicates that a DataCollector provides some assets
+ */
+interface AssetProvider
+{
+    /**
+     * Returns an array with the following keys:
+     *  - base_path
+     *  - base_url
+     *  - css: an array of filenames
+     *  - js: an array of filenames
+     *  - inline_css: an array map of content ID to inline CSS content (not including <style> tag)
+     *  - inline_js: an array map of content ID to inline JS content (not including <script> tag)
+     *  - inline_head: an array map of content ID to arbitrary inline HTML content (typically
+     *        <style>/<script> tags); it must be embedded within the <head> element
+     *
+     * All keys are optional.
+     *
+     * Ideally, you should store static assets in filenames that are returned via the normal css/js
+     * keys.  However, the inline asset elements are useful when integrating with 3rd-party
+     * libraries that require static assets that are only available in an inline format.
+     *
+     * The inline content arrays require special string array keys:  the caller of this function
+     * will use them to deduplicate content.  This is particularly useful if multiple instances of
+     * the same asset provider are used.  Inline assets from all collectors are merged together into
+     * the same array, so these content IDs effectively deduplicate the inline assets.
+     *
+     * @return array
+     */
+    function getAssets();
+}

vendor/maximebf/debugbar/src/DebugBar/DataCollector/ConfigCollector.php

@@ -0,0 +1,92 @@
+<?php
+/*
+ * This file is part of the DebugBar package.
+ *
+ * (c) 2013 Maxime Bouroumeau-Fuseau
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace DebugBar\DataCollector;
+
+/**
+ * Collects array data
+ */
+class ConfigCollector extends DataCollector implements Renderable, AssetProvider
+{
+    protected $name;
+
+    protected $data;
+
+    /**
+     * @param array  $data
+     * @param string $name
+     */
+    public function __construct(array $data = array(), $name = 'config')
+    {
+        $this->name = $name;
+        $this->data = $data;
+    }
+
+    /**
+     * Sets the data
+     *
+     * @param array $data
+     */
+    public function setData(array $data)
+    {
+        $this->data = $data;
+    }
+
+    /**
+     * @return array
+     */
+    public function collect()
+    {
+        $data = array();
+        foreach ($this->data as $k => $v) {
+            if ($this->isHtmlVarDumperUsed()) {
+                $v = $this->getVarDumper()->renderVar($v);
+            } else if (!is_string($v)) {
+                $v = $this->getDataFormatter()->formatVar($v);
+            }
+            $data[$k] = $v;
+        }
+        return $data;
+    }
+
+    /**
+     * @return string
+     */
+    public function getName()
+    {
+        return $this->name;
+    }
+
+    /**
+     * @return array
+     */
+    public function getAssets() {
+        return $this->isHtmlVarDumperUsed() ? $this->getVarDumper()->getAssets() : array();
+    }
+
+    /**
+     * @return array
+     */
+    public function getWidgets()
+    {
+        $name = $this->getName();
+        $widget = $this->isHtmlVarDumperUsed()
+            ? "PhpDebugBar.Widgets.HtmlVariableListWidget"
+            : "PhpDebugBar.Widgets.VariableListWidget";
+        return array(
+            "$name" => array(
+                "icon" => "gear",
+                "widget" => $widget,
+                "map" => "$name",
+                "default" => "{}"
+            )
+        );
+    }
+}

vendor/maximebf/debugbar/src/DebugBar/DataCollector/DataCollector.php

@@ -0,0 +1,27 @@
+<?php
+/*
+ * This file is part of the DebugBar package.
+ *
+ * (c) 2013 Maxime Bouroumeau-Fuseau
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace DebugBar\DataCollector;
+
+use DebugBar\DataFormatter\HasDataFormatter;
+use DebugBar\DataFormatter\HasXdebugLinks;
+
+/**
+ * Abstract class for data collectors
+ */
+abstract class DataCollector implements DataCollectorInterface
+{
+    use HasDataFormatter, HasXdebugLinks;
+
+    public static $defaultDataFormatter;
+    public static $defaultVarDumper;
+
+
+}

vendor/maximebf/debugbar/src/DebugBar/DataCollector/DataCollectorInterface.php

@@ -0,0 +1,31 @@
+<?php
+/*
+ * This file is part of the DebugBar package.
+ *
+ * (c) 2013 Maxime Bouroumeau-Fuseau
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace DebugBar\DataCollector;
+
+/**
+ * DataCollector Interface
+ */
+interface DataCollectorInterface
+{
+    /**
+     * Called by the DebugBar when data needs to be collected
+     *
+     * @return array Collected data
+     */
+    function collect();
+
+    /**
+     * Returns the unique name of the collector
+     *
+     * @return string
+     */
+    function getName();
+}

vendor/maximebf/debugbar/src/DebugBar/DataCollector/ExceptionsCollector.php

@@ -0,0 +1,191 @@
+<?php
+/*
+ * This file is part of the DebugBar package.
+ *
+ * (c) 2013 Maxime Bouroumeau-Fuseau
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace DebugBar\DataCollector;
+
+use Exception;
+use Symfony\Component\Debug\Exception\FatalThrowableError;
+
+/**
+ * Collects info about exceptions
+ */
+class ExceptionsCollector extends DataCollector implements Renderable
+{
+    protected $exceptions = array();
+    protected $chainExceptions = false;
+
+    /**
+     * Adds an exception to be profiled in the debug bar
+     *
+     * @param Exception $e
+     * @deprecated in favor on addThrowable
+     */
+    public function addException(Exception $e)
+    {
+        $this->addThrowable($e);
+    }
+
+    /**
+     * Adds a Throwable to be profiled in the debug bar
+     *
+     * @param \Throwable $e
+     */
+    public function addThrowable($e)
+    {
+        $this->exceptions[] = $e;
+        if ($this->chainExceptions && $previous = $e->getPrevious()) {
+            $this->addThrowable($previous);
+        }
+    }
+
+    /**
+     * Configure whether or not all chained exceptions should be shown.
+     *
+     * @param bool $chainExceptions
+     */
+    public function setChainExceptions($chainExceptions = true)
+    {
+        $this->chainExceptions = $chainExceptions;
+    }
+
+    /**
+     * Returns the list of exceptions being profiled
+     *
+     * @return array[\Throwable]
+     */
+    public function getExceptions()
+    {
+        return $this->exceptions;
+    }
+
+    public function collect()
+    {
+        return array(
+            'count' => count($this->exceptions),
+            'exceptions' => array_map(array($this, 'formatThrowableData'), $this->exceptions)
+        );
+    }
+
+    /**
+     * Returns exception data as an array
+     *
+     * @param Exception $e
+     * @return array
+     * @deprecated in favor on formatThrowableData
+     */
+    public function formatExceptionData(Exception $e)
+    {
+        return $this->formatThrowableData($e);
+    }
+
+    /**
+     * Returns Throwable trace as an formated array
+     *
+     * @return array
+     */
+    public function formatTrace(array $trace)
+    {
+        if (! empty($this->xdebugReplacements)) {
+            $trace = array_map(function ($track) {
+                if (isset($track['file'])) {
+                    $track['file'] = $this->normalizeFilePath($track['file']);
+                }
+
+                return $track;
+            }, $trace);
+        }
+
+        return $trace;
+    }
+
+    /**
+     * Returns Throwable data as an string
+     *
+     * @param \Throwable $e
+     * @return string
+     */
+    public function formatTraceAsString($e)
+    {
+        if (! empty($this->xdebugReplacements)) {
+            return implode("\n", array_map(function ($track) {
+                $track = explode(' ', $track);
+                if (isset($track[1])) {
+                    $track[1] = $this->normalizeFilePath($track[1]);
+                }
+
+                return implode(' ', $track);
+            }, explode("\n", $e->getTraceAsString())));
+        }
+
+        return $e->getTraceAsString();
+    }
+
+    /**
+     * Returns Throwable data as an array
+     *
+     * @param \Throwable $e
+     * @return array
+     */
+    public function formatThrowableData($e)
+    {
+        $filePath = $e->getFile();
+        if ($filePath && file_exists($filePath)) {
+            $lines = file($filePath);
+            $start = $e->getLine() - 4;
+            $lines = array_slice($lines, $start < 0 ? 0 : $start, 7);
+        } else {
+            $lines = array('Cannot open the file ('.$this->normalizeFilePath($filePath).') in which the exception occurred');
+        }
+
+        $traceHtml = null;
+        if ($this->isHtmlVarDumperUsed()) {
+            $traceHtml = $this->getVarDumper()->renderVar($this->formatTrace($e->getTrace()));
+        }
+
+        return array(
+            'type' => get_class($e),
+            'message' => $e->getMessage(),
+            'code' => $e->getCode(),
+            'file' => $this->normalizeFilePath($filePath),
+            'line' => $e->getLine(),
+            'stack_trace' => $traceHtml ? null : $this->formatTraceAsString($e),
+            'stack_trace_html' => $traceHtml,
+            'surrounding_lines' => $lines,
+            'xdebug_link' => $this->getXdebugLink($filePath, $e->getLine())
+        );
+    }
+
+    /**
+     * @return string
+     */
+    public function getName()
+    {
+        return 'exceptions';
+    }
+
+    /**
+     * @return array
+     */
+    public function getWidgets()
+    {
+        return array(
+            'exceptions' => array(
+                'icon' => 'bug',
+                'widget' => 'PhpDebugBar.Widgets.ExceptionsWidget',
+                'map' => 'exceptions.exceptions',
+                'default' => '[]'
+            ),
+            'exceptions:badge' => array(
+                'map' => 'exceptions.count',
+                'default' => 'null'
+            )
+        );
+    }
+}

vendor/maximebf/debugbar/src/DebugBar/DataCollector/LocalizationCollector.php

@@ -0,0 +1,73 @@
+<?php
+/*
+ * This file is part of the DebugBar package.
+ *
+ * (c) 2013 Maxime Bouroumeau-Fuseau
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace DebugBar\DataCollector;
+
+/**
+ * Collects info about the current localization state
+ */
+class LocalizationCollector extends DataCollector implements Renderable
+{
+    /**
+     * Get the current locale
+     *
+     * @return string
+     */
+    public function getLocale()
+    {
+        return setlocale(LC_ALL, 0);
+    }
+
+    /**
+     * Get the current translations domain
+     *
+     * @return string
+     */
+    public function getDomain()
+    {
+        return textdomain();
+    }
+
+    /**
+     * @return array
+     */
+    public function collect()
+    {
+        return array(
+          'locale' => $this->getLocale(),
+          'domain' => $this->getDomain(),
+        );
+    }
+
+    /**
+     * @return string
+     */
+    public function getName()
+    {
+        return 'localization';
+    }
+
+    /**
+     * @return array
+     */
+    public function getWidgets()
+    {
+        return array(
+            'domain' => array(
+                'icon' => 'bookmark',
+                'map'  => 'localization.domain',
+            ),
+            'locale' => array(
+                'icon' => 'flag',
+                'map'  => 'localization.locale',
+            )
+        );
+    }
+}

vendor/maximebf/debugbar/src/DebugBar/DataCollector/MemoryCollector.php

@@ -0,0 +1,123 @@
+<?php
+/*
+ * This file is part of the DebugBar package.
+ *
+ * (c) 2013 Maxime Bouroumeau-Fuseau
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace DebugBar\DataCollector;
+
+/**
+ * Collects info about memory usage
+ */
+class MemoryCollector extends DataCollector implements Renderable
+{
+    protected $realUsage = false;
+
+    protected $memoryRealStart = 0;
+
+    protected $memoryStart = 0;
+
+    protected $peakUsage = 0;
+
+    protected $precision = 0;
+
+    /**
+     * Set the precision of the 'peak_usage_str' output.
+     *
+     * @param int $precision
+     */
+    public function setPrecision($precision)
+    {
+        $this->precision = $precision;
+    }
+
+    /**
+     * Returns whether total allocated memory page size is used instead of actual used memory size
+     * by the application.  See $real_usage parameter on memory_get_peak_usage for details.
+     *
+     * @return bool
+     */
+    public function getRealUsage()
+    {
+        return $this->realUsage;
+    }
+
+    /**
+     * Sets whether total allocated memory page size is used instead of actual used memory size
+     * by the application.  See $real_usage parameter on memory_get_peak_usage for details.
+     *
+     * @param bool $realUsage
+     */
+    public function setRealUsage($realUsage)
+    {
+        $this->realUsage = $realUsage;
+    }
+
+    /**
+     * Reset memory baseline, to measure multiple requests in a long running process
+     *
+     * @return void
+     */
+    public function resetMemoryBaseline()
+    {
+        $this->memoryStart = memory_get_usage(false);
+        $this->memoryRealStart = memory_get_usage(true);
+    }
+
+    /**
+     * Returns the peak memory usage
+     *
+     * @return integer
+     */
+    public function getPeakUsage()
+    {
+        return $this->peakUsage - ($this->realUsage ? $this->memoryRealStart : $this->memoryStart);
+    }
+
+    /**
+     * Updates the peak memory usage value
+     */
+    public function updatePeakUsage()
+    {
+        $this->peakUsage = memory_get_peak_usage($this->realUsage);
+    }
+
+    /**
+     * @return array
+     */
+    public function collect()
+    {
+        $this->updatePeakUsage();
+        return array(
+            'peak_usage' => $this->getPeakUsage(),
+            'peak_usage_str' => $this->getDataFormatter()->formatBytes($this->getPeakUsage(), $this->precision)
+        );
+    }
+
+    /**
+     * @return string
+     */
+    public function getName()
+    {
+        return 'memory';
+    }
+
+    /**
+     * @return array
+     */
+    public function getWidgets()
+    {
+        return array(
+            "memory" => array(
+                "icon" => "cogs",
+                "tooltip" => "Memory Usage",
+                "map" => "memory.peak_usage_str",
+                "default" => "'0B'"
+            )
+        );
+    }
+}

vendor/maximebf/debugbar/src/DebugBar/DataCollector/MessagesAggregateInterface.php

@@ -0,0 +1,21 @@
+<?php
+/*
+ * This file is part of the DebugBar package.
+ *
+ * (c) 2013 Maxime Bouroumeau-Fuseau
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace DebugBar\DataCollector;
+
+interface MessagesAggregateInterface
+{
+    /**
+     * Returns collected messages
+     *
+     * @return array
+     */
+    public function getMessages();
+}

vendor/maximebf/debugbar/src/DebugBar/DataCollector/MessagesCollector.php

@@ -0,0 +1,252 @@
+<?php
+/*
+ * This file is part of the DebugBar package.
+ *
+ * (c) 2013 Maxime Bouroumeau-Fuseau
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace DebugBar\DataCollector;
+
+use DebugBar\DataFormatter\HasXdebugLinks;
+use Psr\Log\AbstractLogger;
+use DebugBar\DataFormatter\HasDataFormatter;
+
+/**
+ * Provides a way to log messages
+ */
+class MessagesCollector extends AbstractLogger implements DataCollectorInterface, MessagesAggregateInterface, Renderable, AssetProvider
+{
+    use HasDataFormatter, HasXdebugLinks;
+
+    protected $name;
+
+    protected $messages = array();
+
+    protected $aggregates = array();
+
+    /** @var bool */
+    protected $collectFile = false;
+
+    /**
+     * @param string $name
+     */
+    public function __construct($name = 'messages')
+    {
+        $this->name = $name;
+    }
+
+    /** @return void */
+    public function collectFileTrace($enabled = true)
+    {
+        $this->collectFile = $enabled;
+    }
+
+    /**
+     * @param string|null $messageHtml
+     * @param mixed $message
+     *
+     * @return string|null
+     */
+    protected function customizeMessageHtml($messageHtml, $message)
+    {
+        $pos = strpos((string) $messageHtml, 'sf-dump-expanded');
+        if ($pos !== false) {
+            $messageHtml = substr_replace($messageHtml, 'sf-dump-compact', $pos, 16);
+        }
+
+        return $messageHtml;
+    }
+
+    /**
+     * Adds a message
+     *
+     * A message can be anything from an object to a string
+     *
+     * @param mixed $message
+     * @param string $label
+     */
+    public function addMessage($message, $label = 'info', $isString = true)
+    {
+        $messageText = $message;
+        $messageHtml = null;
+        if (!is_string($message)) {
+            // Send both text and HTML representations; the text version is used for searches
+            $messageText = $this->getDataFormatter()->formatVar($message);
+            if ($this->isHtmlVarDumperUsed()) {
+                $messageHtml = $this->getVarDumper()->renderVar($message);
+            }
+            $isString = false;
+        }
+
+        $stackItem = [];
+        if ($this->collectFile) {
+            $stacktrace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 5);
+            $stackItem = $stacktrace[0];
+            foreach ($stacktrace as $trace) {
+                if (!isset($trace['file']) || strpos($trace['file'], '/vendor/') !== false) {
+                    continue;
+                }
+
+                $stackItem = $trace;
+                break;
+            }
+        }
+
+        $this->messages[] = array(
+            'message' => $messageText,
+            'message_html' => $this->customizeMessageHtml($messageHtml, $message),
+            'is_string' => $isString,
+            'label' => $label,
+            'time' => microtime(true),
+            'xdebug_link' => $stackItem ? $this->getXdebugLink($stackItem['file'], $stackItem['line'] ?? null) : null,
+        );
+    }
+
+    /**
+     * Aggregates messages from other collectors
+     *
+     * @param MessagesAggregateInterface $messages
+     */
+    public function aggregate(MessagesAggregateInterface $messages)
+    {
+        if ($this->collectFile && method_exists($messages, 'collectFileTrace')) {
+            $messages->collectFileTrace();
+        }
+
+        $this->aggregates[] = $messages;
+    }
+
+    /**
+     * @return array
+     */
+    public function getMessages()
+    {
+        $messages = $this->messages;
+        foreach ($this->aggregates as $collector) {
+            $msgs = array_map(function ($m) use ($collector) {
+                $m['collector'] = $collector->getName();
+                return $m;
+            }, $collector->getMessages());
+            $messages = array_merge($messages, $msgs);
+        }
+
+        // sort messages by their timestamp
+        usort($messages, function ($a, $b) {
+            if ($a['time'] === $b['time']) {
+                return 0;
+            }
+            return $a['time'] < $b['time'] ? -1 : 1;
+        });
+
+        return $messages;
+    }
+
+    /**
+     * @param $level
+     * @param $message
+     * @param array $context
+     */
+    public function log($level, $message, array $context = array()): void
+    {
+        // For string messages, interpolate the context following PSR-3
+        if (is_string($message)) {
+            $message = $this->interpolate($message, $context);
+        }
+        $this->addMessage($message, $level);
+    }
+
+    /**
+     * Interpolates context values into the message placeholders.
+     *
+     * @param string $message
+     * @param array $context
+     * @return string
+     */
+    function interpolate($message, array $context = array())
+    {
+        // build a replacement array with braces around the context keys
+        $replace = array();
+        foreach ($context as $key => $val) {
+            $placeholder = '{' . $key . '}';
+            if (strpos($message, $placeholder) === false) {
+                continue;
+            }
+            // check that the value can be cast to string
+            if (null === $val || is_scalar($val) || (is_object($val) && method_exists($val, "__toString"))) {
+                $replace[$placeholder] = $val;
+            } elseif ($val instanceof \DateTimeInterface) {
+                $replace[$placeholder] = $val->format("Y-m-d\TH:i:s.uP");
+            } elseif ($val instanceof \UnitEnum) {
+                $replace[$placeholder] = $val instanceof \BackedEnum ? $val->value : $val->name;
+            } elseif (is_object($val)) {
+                $replace[$placeholder] = '[object ' . $this->getDataFormatter()->formatClassName($val) . ']';
+            } elseif (is_array($val)) {
+                $json = @json_encode($val);
+                $replace[$placeholder] = false === $json ? 'null' : 'array' . $json;
+            } else {
+                $replace[$placeholder] = '['.gettype($val).']';
+            }
+        }
+
+        // interpolate replacement values into the message and return
+        return strtr($message, $replace);
+    }
+
+    /**
+     * Deletes all messages
+     */
+    public function clear()
+    {
+        $this->messages = array();
+    }
+
+    /**
+     * @return array
+     */
+    public function collect()
+    {
+        $messages = $this->getMessages();
+        return array(
+            'count' => count($messages),
+            'messages' => $messages
+        );
+    }
+
+    /**
+     * @return string
+     */
+    public function getName()
+    {
+        return $this->name;
+    }
+
+    /**
+     * @return array
+     */
+    public function getAssets() {
+        return $this->isHtmlVarDumperUsed() ? $this->getVarDumper()->getAssets() : array();
+    }
+
+    /**
+     * @return array
+     */
+    public function getWidgets()
+    {
+        $name = $this->getName();
+        return array(
+            "$name" => array(
+                'icon' => 'list-alt',
+                "widget" => "PhpDebugBar.Widgets.MessagesWidget",
+                "map" => "$name.messages",
+                "default" => "[]"
+            ),
+            "$name:badge" => array(
+                "map" => "$name.count",
+                "default" => "null"
+            )
+        );
+    }
+}

vendor/maximebf/debugbar/src/DebugBar/DataCollector/ObjectCountCollector.php

@@ -0,0 +1,102 @@
+<?php
+
+namespace DebugBar\DataCollector;
+
+use DebugBar\DataCollector\DataCollector;
+use DebugBar\DataCollector\DataCollectorInterface;
+use DebugBar\DataCollector\Renderable;
+
+/**
+ * Collector for hit counts.
+ */
+class ObjectCountCollector extends DataCollector implements DataCollectorInterface, Renderable
+{
+    /** @var string */
+    private $name;
+    /** @var string */
+    private $icon;
+    /** @var int */
+    protected $classCount = 0;
+    /** @var array */
+    protected $classList = [];
+
+    /**
+     * @param string $name
+     * @param string $icon
+     */
+    public function __construct($name = 'counter', $icon = 'cubes')
+    {
+        $this->name = $name;
+        $this->icon = $icon;
+    }
+
+    /**
+     * @param string|mixed $class
+     * @param int $count
+     */
+    public function countClass($class, $count = 1) {
+        if (! is_string($class)) {
+            $class = get_class($class);
+        }
+
+        $this->classList[$class] = ($this->classList[$class] ?? 0) + $count;
+        $this->classCount += $count;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function collect()
+    {
+        arsort($this->classList, SORT_NUMERIC);
+
+        if (! $this->getXdebugLinkTemplate()) {
+            return ['data' => $this->classList, 'count' => $this->classCount, 'is_counter' => true];
+        }
+
+        $data = [];
+        foreach ($this->classList as $class => $count) {
+            $reflector = class_exists($class) ? new \ReflectionClass($class) : null;
+
+            if ($reflector && $link = $this->getXdebugLink($reflector->getFileName())) {
+                $data[$class] = [
+                    'value' => $count,
+                    'xdebug_link' => $link,
+                ];
+            } else {
+                $data[$class] = $count;
+            }
+        }
+
+        return ['data' => $data, 'count' => $this->classCount, 'is_counter' => true];
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getName()
+    {
+        return $this->name;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getWidgets()
+    {
+        $name = $this->getName();
+
+        return [
+            "$name" => [
+                'icon' => $this->icon,
+                'widget' => 'PhpDebugBar.Widgets.HtmlVariableListWidget',
+                'map' => "$name.data",
+                'default' => '{}'
+            ],
+            "$name:badge" => [
+                'map' => "$name.count",
+                'default' => 0
+            ]
+        ];
+    }
+}

vendor/maximebf/debugbar/src/DebugBar/DataCollector/PDO/PDOCollector.php

@@ -0,0 +1,239 @@
+<?php
+
+namespace DebugBar\DataCollector\PDO;
+
+use DebugBar\DataCollector\AssetProvider;
+use DebugBar\DataCollector\DataCollector;
+use DebugBar\DataCollector\Renderable;
+use DebugBar\DataCollector\TimeDataCollector;
+
+/**
+ * Collects data about SQL statements executed with PDO
+ */
+class PDOCollector extends DataCollector implements Renderable, AssetProvider
+{
+    protected $connections = array();
+
+    protected $timeCollector;
+
+    protected $renderSqlWithParams = false;
+
+    protected $sqlQuotationChar = '<>';
+
+    protected $durationBackground = false;
+
+    /**
+     * @param \PDO $pdo
+     * @param TimeDataCollector $timeCollector
+     */
+    public function __construct(\PDO $pdo = null, TimeDataCollector $timeCollector = null)
+    {
+        $this->timeCollector = $timeCollector;
+        if ($pdo !== null) {
+            $this->addConnection($pdo, 'default');
+        }
+    }
+
+    /**
+     * Renders the SQL of traced statements with params embeded
+     *
+     * @param boolean $enabled
+     */
+    public function setRenderSqlWithParams($enabled = true, $quotationChar = '<>')
+    {
+        $this->renderSqlWithParams = $enabled;
+        $this->sqlQuotationChar = $quotationChar;
+    }
+
+    /**
+     * Enable/disable the shaded duration background on queries
+     *
+     * @param  bool $enabled
+     */
+    public function setDurationBackground($enabled)
+    {
+        $this->durationBackground = $enabled;
+    }
+
+    /**
+     * @return bool
+     */
+    public function isSqlRenderedWithParams()
+    {
+        return $this->renderSqlWithParams;
+    }
+
+    /**
+     * @return string
+     */
+    public function getSqlQuotationChar()
+    {
+        return $this->sqlQuotationChar;
+    }
+
+    /**
+     * Adds a new PDO instance to be collector
+     *
+     * @param TraceablePDO $pdo
+     * @param string $name Optional connection name
+     */
+    public function addConnection(\PDO $pdo, $name = null)
+    {
+        if ($name === null) {
+            $name = spl_object_hash($pdo);
+        }
+        if (!($pdo instanceof TraceablePDO)) {
+            $pdo = new TraceablePDO($pdo);
+        }
+        $this->connections[$name] = $pdo;
+    }
+
+    /**
+     * Returns PDO instances to be collected
+     *
+     * @return array
+     */
+    public function getConnections()
+    {
+        return $this->connections;
+    }
+
+    /**
+     * @return array
+     */
+    public function collect()
+    {
+        $data = array(
+            'nb_statements' => 0,
+            'nb_failed_statements' => 0,
+            'accumulated_duration' => 0,
+            'memory_usage' => 0,
+            'peak_memory_usage' => 0,
+            'statements' => array()
+        );
+
+        foreach ($this->connections as $name => $pdo) {
+            $pdodata = $this->collectPDO($pdo, $this->timeCollector, $name);
+            $data['nb_statements'] += $pdodata['nb_statements'];
+            $data['nb_failed_statements'] += $pdodata['nb_failed_statements'];
+            $data['accumulated_duration'] += $pdodata['accumulated_duration'];
+            $data['memory_usage'] += $pdodata['memory_usage'];
+            $data['peak_memory_usage'] = max($data['peak_memory_usage'], $pdodata['peak_memory_usage']);
+            $data['statements'] = array_merge($data['statements'],
+                array_map(function ($s) use ($name) { $s['connection'] = $name; return $s; }, $pdodata['statements']));
+        }
+
+        $data['accumulated_duration_str'] = $this->getDataFormatter()->formatDuration($data['accumulated_duration']);
+        $data['memory_usage_str'] = $this->getDataFormatter()->formatBytes($data['memory_usage']);
+        $data['peak_memory_usage_str'] = $this->getDataFormatter()->formatBytes($data['peak_memory_usage']);
+
+        return $data;
+    }
+
+    /**
+     * Collects data from a single TraceablePDO instance
+     *
+     * @param TraceablePDO $pdo
+     * @param TimeDataCollector $timeCollector
+     * @param string|null $connectionName the pdo connection (eg default | read | write)
+     * @return array
+     */
+    protected function collectPDO(TraceablePDO $pdo, TimeDataCollector $timeCollector = null, $connectionName = null)
+    {
+        if (empty($connectionName) || $connectionName == 'default') {
+            $connectionName = 'pdo';
+        } else {
+            $connectionName = 'pdo ' . $connectionName;
+        }
+        $stmts = array();
+        foreach ($pdo->getExecutedStatements() as $stmt) {
+            $stmts[] = array(
+                'sql' => $this->renderSqlWithParams ? $stmt->getSqlWithParams($this->sqlQuotationChar) : $stmt->getSql(),
+                'row_count' => $stmt->getRowCount(),
+                'stmt_id' => $stmt->getPreparedId(),
+                'prepared_stmt' => $stmt->getSql(),
+                'params' => (object) $stmt->getParameters(),
+                'duration' => $stmt->getDuration(),
+                'duration_str' => $this->getDataFormatter()->formatDuration($stmt->getDuration()),
+                'memory' => $stmt->getMemoryUsage(),
+                'memory_str' => $this->getDataFormatter()->formatBytes($stmt->getMemoryUsage()),
+                'end_memory' => $stmt->getEndMemory(),
+                'end_memory_str' => $this->getDataFormatter()->formatBytes($stmt->getEndMemory()),
+                'is_success' => $stmt->isSuccess(),
+                'error_code' => $stmt->getErrorCode(),
+                'error_message' => $stmt->getErrorMessage()
+            );
+            if ($timeCollector !== null) {
+                $timeCollector->addMeasure($stmt->getSql(), $stmt->getStartTime(), $stmt->getEndTime(), array(), $connectionName);
+            }
+        }
+
+        $totalTime = $pdo->getAccumulatedStatementsDuration();
+        if ($this->durationBackground && $totalTime > 0) {
+            // For showing background measure on Queries tab
+            $start_percent = 0;
+            foreach ($stmts as $i => $stmt) {
+                if (!isset($stmt['duration'])) {
+                    continue;
+                }
+
+                $width_percent = $stmt['duration'] / $totalTime * 100;
+                $stmts[$i] = array_merge($stmt, [
+                    'start_percent' => round($start_percent, 3),
+                    'width_percent' => round($width_percent, 3),
+                ]);
+                $start_percent += $width_percent;
+            }
+        }
+
+        return array(
+            'nb_statements' => count($stmts),
+            'nb_failed_statements' => count($pdo->getFailedExecutedStatements()),
+            'accumulated_duration' => $totalTime,
+            'accumulated_duration_str' => $this->getDataFormatter()->formatDuration($totalTime),
+            'memory_usage' => $pdo->getMemoryUsage(),
+            'memory_usage_str' => $this->getDataFormatter()->formatBytes($pdo->getPeakMemoryUsage()),
+            'peak_memory_usage' => $pdo->getPeakMemoryUsage(),
+            'peak_memory_usage_str' => $this->getDataFormatter()->formatBytes($pdo->getPeakMemoryUsage()),
+            'statements' => $stmts
+        );
+    }
+
+    /**
+     * @return string
+     */
+    public function getName()
+    {
+        return 'pdo';
+    }
+
+    /**
+     * @return array
+     */
+    public function getWidgets()
+    {
+        return array(
+            "database" => array(
+                "icon" => "database",
+                "widget" => "PhpDebugBar.Widgets.SQLQueriesWidget",
+                "map" => "pdo",
+                "default" => "[]"
+            ),
+            "database:badge" => array(
+                "map" => "pdo.nb_statements",
+                "default" => 0
+            )
+        );
+    }
+
+    /**
+     * @return array
+     */
+    public function getAssets()
+    {
+        return array(
+            'css' => 'widgets/sqlqueries/widget.css',
+            'js' => 'widgets/sqlqueries/widget.js'
+        );
+    }
+}

vendor/maximebf/debugbar/src/DebugBar/DataCollector/PDO/TraceablePDO.php

@@ -0,0 +1,321 @@
+<?php
+
+namespace DebugBar\DataCollector\PDO;
+
+use PDO;
+use PDOException;
+use DebugBar\DataCollector\PDO\TraceablePDOStatement;
+
+/**
+ * A PDO proxy which traces statements
+ */
+class TraceablePDO extends PDO
+{
+    /** @var PDO */
+    protected $pdo;
+
+    /** @var TracedStatement[] */
+    protected $executedStatements = [];
+
+    public function __construct(PDO $pdo)
+    {
+        $this->pdo = $pdo;
+        $this->pdo->setAttribute(PDO::ATTR_STATEMENT_CLASS, [TraceablePDOStatement::class, [$this]]);
+    }
+
+   /**
+    * Initiates a transaction
+    *
+    * @link   http://php.net/manual/en/pdo.begintransaction.php
+    * @return bool TRUE on success or FALSE on failure.
+    */
+    public function beginTransaction() : bool
+    {
+        return $this->pdo->beginTransaction();
+    }
+
+    /**
+     * Commits a transaction
+     *
+     * @link   http://php.net/manual/en/pdo.commit.php
+     * @return bool TRUE on success or FALSE on failure.
+     */
+    public function commit() : bool
+    {
+        return $this->pdo->commit();
+    }
+
+    /**
+     * Fetch extended error information associated with the last operation on the database handle
+     *
+     * @link   http://php.net/manual/en/pdo.errorinfo.php
+     * @return array PDO::errorInfo returns an array of error information
+     */
+    #[\ReturnTypeWillChange]
+    public function errorCode()
+    {
+        return $this->pdo->errorCode();
+    }
+
+    /**
+     * Fetch extended error information associated with the last operation on the database handle
+     *
+     * @link   http://php.net/manual/en/pdo.errorinfo.php
+     * @return array PDO::errorInfo returns an array of error information
+     */
+    public function errorInfo() : array
+    {
+        return $this->pdo->errorInfo();
+    }
+
+    /**
+     * Execute an SQL statement and return the number of affected rows
+     *
+     * @link   http://php.net/manual/en/pdo.exec.php
+     * @param  string   $statement
+     * @return int|bool PDO::exec returns the number of rows that were modified or deleted by the
+     * SQL statement you issued. If no rows were affected, PDO::exec returns 0. This function may
+     * return Boolean FALSE, but may also return a non-Boolean value which evaluates to FALSE.
+     * Please read the section on Booleans for more information
+     */
+    #[\ReturnTypeWillChange]
+    public function exec($statement)
+    {
+        return $this->profileCall('exec', $statement, func_get_args());
+    }
+
+    /**
+     * Retrieve a database connection attribute
+     *
+     * @link   http://php.net/manual/en/pdo.getattribute.php
+     * @param  int   $attribute One of the PDO::ATTR_* constants
+     * @return mixed A successful call returns the value of the requested PDO attribute.
+     * An unsuccessful call returns null.
+     */
+    #[\ReturnTypeWillChange]
+    public function getAttribute($attribute)
+    {
+        return $this->pdo->getAttribute($attribute);
+    }
+
+    /**
+     * Checks if inside a transaction
+     *
+     * @link   http://php.net/manual/en/pdo.intransaction.php
+     * @return bool TRUE if a transaction is currently active, and FALSE if not.
+     */
+    public function inTransaction() : bool
+    {
+        return $this->pdo->inTransaction();
+    }
+
+    /**
+     * Returns the ID of the last inserted row or sequence value
+     *
+     * @link   http://php.net/manual/en/pdo.lastinsertid.php
+     * @param  string $name [optional]
+     * @return string If a sequence name was not specified for the name parameter, PDO::lastInsertId
+     * returns a string representing the row ID of the last row that was inserted into the database.
+     */
+    #[\ReturnTypeWillChange]
+    public function lastInsertId($name = null)
+    {
+        return $this->pdo->lastInsertId($name);
+    }
+
+    /**
+     * Prepares a statement for execution and returns a statement object
+     *
+     * @link   http://php.net/manual/en/pdo.prepare.php
+     * @param  string $statement This must be a valid SQL statement template for the target DB server.
+     * @param  array  $driver_options [optional] This array holds one or more key=&gt;value pairs to
+     * set attribute values for the PDOStatement object that this method returns.
+     * @return TraceablePDOStatement|bool If the database server successfully prepares the statement,
+     * PDO::prepare returns a PDOStatement object. If the database server cannot successfully prepare
+     * the statement, PDO::prepare returns FALSE or emits PDOException (depending on error handling).
+     */
+    #[\ReturnTypeWillChange]
+    public function prepare($statement, $driver_options = [])
+    {
+        return $this->pdo->prepare($statement, $driver_options);
+    }
+
+    /**
+     * Executes an SQL statement, returning a result set as a PDOStatement object
+     *
+     * @link   http://php.net/manual/en/pdo.query.php
+     * @param  string $statement
+     * @param  int $fetchMode
+     * @param  mixed ...$fetchModeArgs
+     * @return TraceablePDOStatement|bool PDO::query returns a PDOStatement object, or FALSE on
+     * failure.
+     */
+    #[\ReturnTypeWillChange]
+    public function query($statement, $fetchMode = null, ...$fetchModeArgs)
+    {
+        return $this->profileCall('query', $statement, func_get_args());
+    }
+
+    /**
+     * Quotes a string for use in a query.
+     *
+     * @link   http://php.net/manual/en/pdo.quote.php
+     * @param  string $string The string to be quoted.
+     * @param  int    $parameter_type [optional] Provides a data type hint for drivers that have
+     * alternate quoting styles.
+     * @return string|bool A quoted string that is theoretically safe to pass into an SQL statement.
+     * Returns FALSE if the driver does not support quoting in this way.
+     */
+    #[\ReturnTypeWillChange]
+    public function quote($string, $parameter_type = PDO::PARAM_STR)
+    {
+        return $this->pdo->quote($string, $parameter_type);
+    }
+
+    /**
+     * Rolls back a transaction
+     *
+     * @link   http://php.net/manual/en/pdo.rollback.php
+     * @return bool TRUE on success or FALSE on failure.
+     */
+    public function rollBack() : bool
+    {
+        return $this->pdo->rollBack();
+    }
+
+    /**
+     * Set an attribute
+     *
+     * @link   http://php.net/manual/en/pdo.setattribute.php
+     * @param  int $attribute
+     * @param  mixed $value
+     * @return bool TRUE on success or FALSE on failure.
+     */
+    public function setAttribute($attribute, $value) : bool
+    {
+        return $this->pdo->setAttribute($attribute, $value);
+    }
+
+    /**
+     * Profiles a call to a PDO method
+     *
+     * @param  string $method
+     * @param  string $sql
+     * @param  array  $args
+     * @return mixed  The result of the call
+     */
+    #[\ReturnTypeWillChange]
+    protected function profileCall($method, $sql, array $args)
+    {
+        $trace = new TracedStatement($sql);
+        $trace->start();
+
+        $ex = null;
+        try {
+            $result = $this->__call($method, $args);
+        } catch (PDOException $e) {
+            $ex = $e;
+        }
+
+        if ($this->pdo->getAttribute(PDO::ATTR_ERRMODE) !== PDO::ERRMODE_EXCEPTION && $result === false) {
+            $error = $this->pdo->errorInfo();
+            $ex = new PDOException($error[2], $error[0]);
+        }
+
+        $trace->end($ex);
+        $this->addExecutedStatement($trace);
+
+        if ($this->pdo->getAttribute(PDO::ATTR_ERRMODE) === PDO::ERRMODE_EXCEPTION && $ex !== null) {
+            throw $ex;
+        }
+        return $result;
+    }
+
+    /**
+     * Adds an executed TracedStatement
+     *
+     * @param TracedStatement $stmt
+     */
+    public function addExecutedStatement(TracedStatement $stmt) : void
+    {
+        $this->executedStatements[] = $stmt;
+    }
+
+    /**
+     * Returns the accumulated execution time of statements
+     *
+     * @return float
+     */
+    public function getAccumulatedStatementsDuration() : float
+    {
+        return array_reduce($this->executedStatements, function ($v, $s) { return $v + $s->getDuration(); }, 0.0);
+    }
+
+    /**
+     * Returns the peak memory usage while performing statements
+     *
+     * @return int
+     */
+    public function getMemoryUsage() : int
+    {
+        return array_reduce($this->executedStatements, function ($v, $s) { return $v + $s->getMemoryUsage(); }, 0);
+    }
+
+    /**
+     * Returns the peak memory usage while performing statements
+     *
+     * @return int
+     */
+    public function getPeakMemoryUsage() : int
+    {
+        return array_reduce($this->executedStatements, function ($v, $s) { $m = $s->getEndMemory(); return $m > $v ? $m : $v; }, 0);
+    }
+
+    /**
+     * Returns the list of executed statements as TracedStatement objects
+     *
+     * @return TracedStatement[]
+     */
+    public function getExecutedStatements() : array
+    {
+        return $this->executedStatements;
+    }
+
+    /**
+     * Returns the list of failed statements
+     *
+     * @return TracedStatement[]
+     */
+    public function getFailedExecutedStatements() : array
+    {
+        return array_filter($this->executedStatements, function ($s) { return !$s->isSuccess(); });
+    }
+
+    /**
+     * @param $name
+     * @return mixed
+     */
+    public function __get($name)
+    {
+        return $this->pdo->$name;
+    }
+
+    /**
+     * @param $name
+     * @param $value
+     */
+    public function __set($name, $value)
+    {
+        $this->pdo->$name = $value;
+    }
+
+    /**
+     * @param $name
+     * @param $args
+     * @return mixed
+     */
+    public function __call($name, $args)
+    {
+        return call_user_func_array([$this->pdo, $name], $args);
+    }
+}

vendor/maximebf/debugbar/src/DebugBar/DataCollector/PDO/TraceablePDOStatement.php

@@ -0,0 +1,131 @@
+<?php
+
+namespace DebugBar\DataCollector\PDO;
+
+use PDO;
+use PDOException;
+use PDOStatement;
+
+/**
+ * A traceable PDO statement to use with Traceablepdo
+ */
+class TraceablePDOStatement extends PDOStatement
+{
+    /** @var PDO */
+    protected $pdo;
+
+    /** @var array */
+    protected $boundParameters = [];
+
+    /**
+     * TraceablePDOStatement constructor.
+     *
+     * @param TraceablePDO $pdo
+     */
+    protected function __construct(TraceablePDO $pdo)
+    {
+        $this->pdo = $pdo;
+    }
+
+    /**
+     * Bind a column to a PHP variable
+     *
+     * @link   http://php.net/manual/en/pdostatement.bindcolumn.php
+     * @param  mixed $column Number of the column (1-indexed) or name of the column in the result set
+     * @param  mixed $param  Name of the PHP variable to which the column will be bound.
+     * @param  int   $type [optional] Data type of the parameter, specified by the PDO::PARAM_*
+     * constants.
+     * @param  int   $maxlen [optional] A hint for pre-allocation.
+     * @param  mixed $driverdata [optional] Optional parameter(s) for the driver.
+     * @return bool  TRUE on success or FALSE on failure.
+     */
+    #[\ReturnTypeWillChange]
+    public function bindColumn($column, &$param, $type = null, $maxlen = null, $driverdata = null)
+    {
+        $this->boundParameters[$column] = $param;
+        $args = array_merge([$column, &$param], array_slice(func_get_args(), 2));
+        return parent::bindColumn(...$args);
+    }
+
+    /**
+     * Binds a parameter to the specified variable name
+     *
+     * @link   http://php.net/manual/en/pdostatement.bindparam.php
+     * @param  mixed $parameter Parameter identifier. For a prepared statement using named
+     * placeholders, this will be a parameter name of the form :name. For a prepared statement using
+     * question mark placeholders, this will be the 1-indexed position of the parameter.
+     * @param  mixed $variable  Name of the PHP variable to bind to the SQL statement parameter.
+     * @param  int $data_type [optional] Explicit data type for the parameter using the PDO::PARAM_*
+     * constants.
+     * @param  int $length [optional] Length of the data type. To indicate that a parameter is an OUT
+     * parameter from a stored procedure, you must explicitly set the length.
+     * @param  mixed $driver_options [optional]
+     * @return bool TRUE on success or FALSE on failure.
+     */
+    public function bindParam($parameter, &$variable, $data_type = PDO::PARAM_STR, $length = null, $driver_options = null) : bool
+    {
+        $this->boundParameters[$parameter] = $variable;
+        $args = array_merge([$parameter, &$variable], array_slice(func_get_args(), 2));
+        return parent::bindParam(...$args);
+    }
+
+    /**
+     * Binds a value to a parameter
+     *
+     * @link   http://php.net/manual/en/pdostatement.bindvalue.php
+     * @param  mixed $parameter Parameter identifier. For a prepared statement using named
+     * placeholders, this will be a parameter name of the form :name. For a prepared statement using
+     * question mark placeholders, this will be the 1-indexed position of the parameter.
+     * @param  mixed $value The value to bind to the parameter.
+     * @param  int   $data_type [optional] Explicit data type for the parameter using the PDO::PARAM_*
+     * constants.
+     * @return bool TRUE on success or FALSE on failure.
+     */
+    public function bindValue($parameter, $value, $data_type = PDO::PARAM_STR) : bool
+    {
+        $this->boundParameters[$parameter] = $value;
+        return parent::bindValue(...func_get_args());
+    }
+
+    /**
+     * Executes a prepared statement
+     *
+     * @link   http://php.net/manual/en/pdostatement.execute.php
+     * @param  array $input_parameters [optional] An array of values with as many elements as there
+     * are bound parameters in the SQL statement being executed. All values are treated as
+     * PDO::PARAM_STR.
+     * @throws PDOException
+     * @return bool TRUE on success or FALSE on failure.
+     */
+    public function execute($input_parameters = null) : bool
+    {
+        $preparedId = spl_object_hash($this);
+        $boundParameters = $this->boundParameters;
+        if (is_array($input_parameters)) {
+            $boundParameters = array_merge($boundParameters, $input_parameters);
+        }
+
+        $trace = new TracedStatement($this->queryString, $boundParameters, $preparedId);
+        $trace->start();
+
+        $ex = null;
+        try {
+            $result = parent::execute($input_parameters);
+        } catch (PDOException $e) {
+            $ex = $e;
+        }
+
+        if ($this->pdo->getAttribute(PDO::ATTR_ERRMODE) !== PDO::ERRMODE_EXCEPTION && $result === false) {
+            $error = $this->errorInfo();
+            $ex = new PDOException($error[2], (int) $error[0]);
+        }
+
+        $trace->end($ex, $this->rowCount());
+        $this->pdo->addExecutedStatement($trace);
+
+        if ($this->pdo->getAttribute(PDO::ATTR_ERRMODE) === PDO::ERRMODE_EXCEPTION && $ex !== null) {
+            throw $ex;
+        }
+        return $result;
+    }
+}

vendor/maximebf/debugbar/src/DebugBar/DataCollector/PDO/TracedStatement.php

@@ -0,0 +1,277 @@
+<?php
+
+namespace DebugBar\DataCollector\PDO;
+
+/**
+ * Holds information about a statement
+ */
+class TracedStatement
+{
+    protected $sql;
+
+    protected $rowCount;
+
+    protected $parameters;
+
+    protected $startTime;
+
+    protected $endTime;
+
+    protected $duration;
+
+    protected $startMemory;
+
+    protected $endMemory;
+
+    protected $memoryDelta;
+
+    protected $exception;
+
+    protected $preparedId;
+
+    /**
+     * @param string $sql
+     * @param array $params
+     * @param null|string $preparedId
+     */
+    public function __construct(string $sql, array $params = [], ?string $preparedId = null)
+    {
+        $this->sql = $sql;
+        $this->parameters = $this->checkParameters($params);
+        $this->preparedId = $preparedId;
+    }
+
+    /**
+     * @param null $startTime
+     * @param null $startMemory
+     */
+    public function start($startTime = null, $startMemory = null) : void
+    {
+        $this->startTime = $startTime ?: microtime(true);
+        $this->startMemory = $startMemory ?: memory_get_usage(false);
+    }
+
+    /**
+     * @param \Exception|null $exception
+     * @param int $rowCount
+     * @param float $endTime
+     * @param int $endMemory
+     */
+    public function end(\Exception $exception = null, int $rowCount = 0, float $endTime = null, int $endMemory = null) : void
+    {
+        $this->endTime = $endTime ?: microtime(true);
+        $this->duration = $this->endTime - $this->startTime;
+        $this->endMemory = $endMemory ?: memory_get_usage(false);
+        $this->memoryDelta = $this->endMemory - $this->startMemory;
+        $this->exception = $exception;
+        $this->rowCount = $rowCount;
+    }
+
+    /**
+     * Check parameters for illegal (non UTF-8) strings, like Binary data.
+     *
+     * @param array $params
+     * @return array
+     */
+    public function checkParameters(array $params) : array
+    {
+        foreach ($params as &$param) {
+            if (!mb_check_encoding($param ?? '', 'UTF-8')) {
+                $param = '[BINARY DATA]';
+            }
+        }
+        return $params;
+    }
+
+    /**
+     * Returns the SQL string used for the query, without filled parameters
+     *
+     * @return string
+     */
+    public function getSql() : string
+    {
+        return $this->sql;
+    }
+
+    /**
+     * Returns the SQL string with any parameters used embedded
+     *
+     * @param string $quotationChar
+     * @return string
+     */
+    public function getSqlWithParams(string $quotationChar = '<>') : string
+    {
+        if (($l = strlen($quotationChar)) > 1) {
+            $quoteLeft = substr($quotationChar, 0, $l / 2);
+            $quoteRight = substr($quotationChar, $l / 2);
+        } else {
+            $quoteLeft = $quoteRight = $quotationChar;
+        }
+
+        $sql = $this->sql;
+
+        $cleanBackRefCharMap = ['%' => '%%', '$' => '$%', '\\' => '\\%'];
+
+        foreach ($this->parameters as $k => $v) {
+
+            $backRefSafeV = strtr($v, $cleanBackRefCharMap);
+
+            $v = "$quoteLeft$backRefSafeV$quoteRight";
+
+            if (is_numeric($k)) {
+                $marker = "\?";
+            } else {
+                $marker = (preg_match("/^:/", $k)) ? $k : ":" . $k;
+            }
+
+            $matchRule = "/({$marker}(?!\w))(?=(?:[^$quotationChar]|[$quotationChar][^$quotationChar]*[$quotationChar])*$)/";
+            $count = mb_substr_count($sql, $k);
+            if ($count < 1) {
+                $count = mb_substr_count($sql, $matchRule);
+            }
+            for ($i = 0; $i <= $count; $i++) {
+                $sql = preg_replace($matchRule, $v, $sql, 1);
+            }
+        }
+
+        $sql = strtr($sql, array_flip($cleanBackRefCharMap));
+
+        return $sql;
+    }
+
+    /**
+     * Returns the number of rows affected/returned
+     *
+     * @return int
+     */
+    public function getRowCount() : int
+    {
+        return $this->rowCount;
+    }
+
+    /**
+     * Returns an array of parameters used with the query
+     *
+     * @return array
+     */
+    public function getParameters() : array
+    {
+        $params = [];
+        foreach ($this->parameters as $name => $param) {
+            $params[$name] = htmlentities($param?:"", ENT_QUOTES, 'UTF-8', false);
+        }
+        return $params;
+    }
+
+    /**
+     * Returns the prepared statement id
+     *
+     * @return null|string
+     */
+    public function getPreparedId() : ?string
+    {
+        return $this->preparedId;
+    }
+
+    /**
+     * Checks if this is a prepared statement
+     *
+     * @return boolean
+     */
+    public function isPrepared() : bool
+    {
+        return $this->preparedId !== null;
+    }
+
+    /**
+     * @return float
+     */
+    public function getStartTime() : float
+    {
+        return $this->startTime;
+    }
+
+    /**
+     * @return float
+     */
+    public function getEndTime() : float
+    {
+        return $this->endTime;
+    }
+
+    /**
+     * Returns the duration in seconds + microseconds of the execution
+     *
+     * @return float
+     */
+    public function getDuration() : float
+    {
+        return $this->duration;
+    }
+
+    /**
+     * @return int
+     */
+    public function getStartMemory() : int
+    {
+        return $this->startMemory;
+    }
+
+    /**
+     * @return int
+     */
+    public function getEndMemory() : int
+    {
+        return $this->endMemory;
+    }
+
+    /**
+     * Returns the memory usage during the execution
+     *
+     * @return int
+     */
+    public function getMemoryUsage() : int
+    {
+        return $this->memoryDelta;
+    }
+
+    /**
+     * Checks if the statement was successful
+     *
+     * @return boolean
+     */
+    public function isSuccess() : bool
+    {
+        return $this->exception === null;
+    }
+
+    /**
+     * Returns the exception triggered
+     *
+     * @return \Exception
+     */
+    public function getException() : \Exception
+	{
+        return $this->exception;
+    }
+
+    /**
+     * Returns the exception's code
+     *
+     * @return int|string
+     */
+    public function getErrorCode()
+    {
+        return $this->exception !== null ? $this->exception->getCode() : 0;
+    }
+
+    /**
+     * Returns the exception's message
+     *
+     * @return string
+     */
+    public function getErrorMessage() : string
+    {
+        return $this->exception !== null ? $this->exception->getMessage() : '';
+    }
+}

vendor/maximebf/debugbar/src/DebugBar/DataCollector/PhpInfoCollector.php

@@ -0,0 +1,51 @@
+<?php
+/*
+ * This file is part of the DebugBar package.
+ *
+ * (c) 2013 Maxime Bouroumeau-Fuseau
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace DebugBar\DataCollector;
+
+/**
+ * Collects info about PHP
+ */
+class PhpInfoCollector extends DataCollector implements Renderable
+{
+    /**
+     * @return string
+     */
+    public function getName()
+    {
+        return 'php';
+    }
+
+    /**
+     * @return array
+     */
+    public function collect()
+    {
+        return array(
+            'version' => implode('.', [PHP_MAJOR_VERSION, PHP_MINOR_VERSION, PHP_RELEASE_VERSION]),
+            'interface' => PHP_SAPI
+        );
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getWidgets()
+    {
+        return array(
+            "php_version" => array(
+                "icon" => "code",
+                "tooltip" => "PHP Version",
+                "map" => "php.version",
+                "default" => ""
+            ),
+        );
+    }
+}

vendor/maximebf/debugbar/src/DebugBar/DataCollector/Renderable.php

@@ -0,0 +1,25 @@
+<?php
+/*
+ * This file is part of the DebugBar package.
+ *
+ * (c) 2013 Maxime Bouroumeau-Fuseau
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace DebugBar\DataCollector;
+
+/**
+ * Indicates that a DataCollector is renderable using JavascriptRenderer
+ */
+interface Renderable
+{
+    /**
+     * Returns a hash where keys are control names and their values
+     * an array of options as defined in {@see DebugBar\JavascriptRenderer::addControl()}
+     *
+     * @return array
+     */
+    function getWidgets();
+}

vendor/maximebf/debugbar/src/DebugBar/DataCollector/RequestDataCollector.php

@@ -0,0 +1,72 @@
+<?php
+/*
+ * This file is part of the DebugBar package.
+ *
+ * (c) 2013 Maxime Bouroumeau-Fuseau
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace DebugBar\DataCollector;
+
+/**
+ * Collects info about the current request
+ */
+class RequestDataCollector extends DataCollector implements Renderable, AssetProvider
+{
+    /**
+     * @return array
+     */
+    public function collect()
+    {
+        $vars = array('_GET', '_POST', '_SESSION', '_COOKIE');
+        $data = array();
+
+        foreach ($vars as $var) {
+            if (isset($GLOBALS[$var])) {
+                $key = "$" . $var;
+                if ($this->isHtmlVarDumperUsed()) {
+                    $data[$key] = $this->getVarDumper()->renderVar($GLOBALS[$var]);
+                } else {
+                    $data[$key] = $this->getDataFormatter()->formatVar($GLOBALS[$var]);
+                }
+            }
+        }
+
+        return $data;
+    }
+
+    /**
+     * @return string
+     */
+    public function getName()
+    {
+        return 'request';
+    }
+
+    /**
+     * @return array
+     */
+    public function getAssets() {
+        return $this->isHtmlVarDumperUsed() ? $this->getVarDumper()->getAssets() : array();
+    }
+
+    /**
+     * @return array
+     */
+    public function getWidgets()
+    {
+        $widget = $this->isHtmlVarDumperUsed()
+            ? "PhpDebugBar.Widgets.HtmlVariableListWidget"
+            : "PhpDebugBar.Widgets.VariableListWidget";
+        return array(
+            "request" => array(
+                "icon" => "tags",
+                "widget" => $widget,
+                "map" => "request",
+                "default" => "{}"
+            )
+        );
+    }
+}

vendor/maximebf/debugbar/src/DebugBar/DataCollector/TimeDataCollector.php

@@ -0,0 +1,272 @@
+<?php
+/*
+ * This file is part of the DebugBar package.
+ *
+ * (c) 2013 Maxime Bouroumeau-Fuseau
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace DebugBar\DataCollector;
+
+use DebugBar\DebugBarException;
+
+/**
+ * Collects info about the request duration as well as providing
+ * a way to log duration of any operations
+ */
+class TimeDataCollector extends DataCollector implements Renderable
+{
+    /**
+     * @var float
+     */
+    protected $requestStartTime;
+
+    /**
+     * @var float
+     */
+    protected $requestEndTime;
+
+    /**
+     * @var array
+     */
+    protected $startedMeasures = array();
+
+    /**
+     * @var array
+     */
+    protected $measures = array();
+
+    /**
+     * @var bool
+     */
+    protected $memoryMeasure = false;
+
+    /**
+     * @param float $requestStartTime
+     */
+    public function __construct($requestStartTime = null)
+    {
+        if ($requestStartTime === null) {
+            if (isset($_SERVER['REQUEST_TIME_FLOAT'])) {
+                $requestStartTime = $_SERVER['REQUEST_TIME_FLOAT'];
+            } else {
+                $requestStartTime = microtime(true);
+            }
+        }
+        $this->requestStartTime = (float)$requestStartTime;
+        static::getDefaultDataFormatter(); // initializes formatter for lineal timeline
+    }
+
+    /**
+     * Starts memory measuring
+     */
+    public function showMemoryUsage()
+    {
+        $this->memoryMeasure = true;
+    }
+
+    /**
+     * Starts a measure
+     *
+     * @param string $name Internal name, used to stop the measure
+     * @param string|null $label Public name
+     * @param string|null $collector The source of the collector
+     */
+    public function startMeasure($name, $label = null, $collector = null)
+    {
+        $start = microtime(true);
+        $this->startedMeasures[$name] = array(
+            'label' => $label ?: $name,
+            'start' => $start,
+            'memory' => $this->memoryMeasure ? memory_get_usage(false) : null,
+            'collector' => $collector
+        );
+    }
+
+    /**
+     * Check a measure exists
+     *
+     * @param string $name
+     * @return bool
+     */
+    public function hasStartedMeasure($name)
+    {
+        return isset($this->startedMeasures[$name]);
+    }
+
+    /**
+     * Stops a measure
+     *
+     * @param string $name
+     * @param array $params
+     * @throws DebugBarException
+     */
+    public function stopMeasure($name, $params = array())
+    {
+        $end = microtime(true);
+        if (!$this->hasStartedMeasure($name)) {
+            throw new DebugBarException("Failed stopping measure '$name' because it hasn't been started");
+        }
+        if (! is_null($this->startedMeasures[$name]['memory'])) {
+            $params['memoryUsage'] = memory_get_usage(false) - $this->startedMeasures[$name]['memory'];
+        }
+        $this->addMeasure(
+            $this->startedMeasures[$name]['label'],
+            $this->startedMeasures[$name]['start'],
+            $end,
+            $params,
+            $this->startedMeasures[$name]['collector']
+        );
+        unset($this->startedMeasures[$name]);
+    }
+
+    /**
+     * Adds a measure
+     *
+     * @param string $label
+     * @param float $start
+     * @param float $end
+     * @param array $params
+     * @param string|null $collector
+     */
+    public function addMeasure($label, $start, $end, $params = array(), $collector = null)
+    {
+        if (isset($params['memoryUsage'])) {
+            $memory = $this->memoryMeasure ? $params['memoryUsage'] : 0;
+            unset($params['memoryUsage']);
+        }
+
+        $this->measures[] = array(
+            'label' => $label,
+            'start' => $start,
+            'relative_start' => $start - $this->requestStartTime,
+            'end' => $end,
+            'relative_end' => $end - $this->requestEndTime,
+            'duration' => $end - $start,
+            'duration_str' => $this->getDataFormatter()->formatDuration($end - $start),
+            'memory' => $memory ?? 0,
+            'memory_str' => $this->getDataFormatter()->formatBytes($memory ?? 0),
+            'params' => $params,
+            'collector' => $collector
+        );
+    }
+
+    /**
+     * Utility function to measure the execution of a Closure
+     *
+     * @param string $label
+     * @param \Closure $closure
+     * @param string|null $collector
+     * @return mixed
+     */
+    public function measure($label, \Closure $closure, $collector = null)
+    {
+        $name = spl_object_hash($closure);
+        $this->startMeasure($name, $label, $collector);
+        $result = $closure();
+        $params = is_array($result) ? $result : array();
+        $this->stopMeasure($name, $params);
+        return $result;
+    }
+
+    /**
+     * Returns an array of all measures
+     *
+     * @return array
+     */
+    public function getMeasures()
+    {
+        return $this->measures;
+    }
+
+    /**
+     * Returns the request start time
+     *
+     * @return float
+     */
+    public function getRequestStartTime()
+    {
+        return $this->requestStartTime;
+    }
+
+    /**
+     * Returns the request end time
+     *
+     * @return float
+     */
+    public function getRequestEndTime()
+    {
+        return $this->requestEndTime;
+    }
+
+    /**
+     * Returns the duration of a request
+     *
+     * @return float
+     */
+    public function getRequestDuration()
+    {
+        if ($this->requestEndTime !== null) {
+            return $this->requestEndTime - $this->requestStartTime;
+        }
+        return microtime(true) - $this->requestStartTime;
+    }
+
+    /**
+     * @return array
+     * @throws DebugBarException
+     */
+    public function collect()
+    {
+        $this->requestEndTime = microtime(true);
+        foreach (array_keys($this->startedMeasures) as $name) {
+            $this->stopMeasure($name);
+        }
+
+        usort($this->measures, function($a, $b) {
+            if ($a['start'] == $b['start']) {
+                return 0;
+            }
+            return $a['start'] < $b['start'] ? -1 : 1;
+        });
+
+        return array(
+            'start' => $this->requestStartTime,
+            'end' => $this->requestEndTime,
+            'duration' => $this->getRequestDuration(),
+            'duration_str' => $this->getDataFormatter()->formatDuration($this->getRequestDuration()),
+            'measures' => array_values($this->measures)
+        );
+    }
+
+    /**
+     * @return string
+     */
+    public function getName()
+    {
+        return 'time';
+    }
+
+    /**
+     * @return array
+     */
+    public function getWidgets()
+    {
+        return array(
+            "time" => array(
+                "icon" => "clock-o",
+                "tooltip" => "Request Duration",
+                "map" => "time.duration_str",
+                "default" => "'0ms'"
+            ),
+            "timeline" => array(
+                "icon" => "tasks",
+                "widget" => "PhpDebugBar.Widgets.TimelineWidget",
+                "map" => "time",
+                "default" => "{}"
+            )
+        );
+    }
+}