dependabot-composer 0.89.5 → 0.90.0

data/helpers/vendor/composer/composer/src/Composer/Json/JsonFormatter.php

@@ -0,0 +1,134 @@
+<?php
+
+/*
+ * This file is part of Composer.
+ *
+ * (c) Nils Adermann <naderman@naderman.de>
+ *     Jordi Boggiano <j.boggiano@seld.be>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Composer\Json;
+
+/**
+ * Formats json strings used for php < 5.4 because the json_encode doesn't
+ * supports the flags JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE
+ * in these versions
+ *
+ * @author Konstantin Kudryashiv <ever.zet@gmail.com>
+ * @author Jordi Boggiano <j.boggiano@seld.be>
+ */
+class JsonFormatter
+{
+    /**
+     * This code is based on the function found at:
+     *  http://recursive-design.com/blog/2008/03/11/format-json-with-php/
+     *
+     * Originally licensed under MIT by Dave Perrett <mail@recursive-design.com>
+     *
+     *
+     * @param  string $json
+     * @param  bool   $unescapeUnicode Un escape unicode
+     * @param  bool   $unescapeSlashes Un escape slashes
+     * @return string
+     */
+    public static function format($json, $unescapeUnicode, $unescapeSlashes)
+    {
+        $result = '';
+        $pos = 0;
+        $strLen = strlen($json);
+        $indentStr = '    ';
+        $newLine = "\n";
+        $outOfQuotes = true;
+        $buffer = '';
+        $noescape = true;
+
+        for ($i = 0; $i < $strLen; $i++) {
+            // Grab the next character in the string
+            $char = substr($json, $i, 1);
+
+            // Are we inside a quoted string?
+            if ('"' === $char && $noescape) {
+                $outOfQuotes = !$outOfQuotes;
+            }
+
+            if (!$outOfQuotes) {
+                $buffer .= $char;
+                $noescape = '\\' === $char ? !$noescape : true;
+                continue;
+            } elseif ('' !== $buffer) {
+                if ($unescapeSlashes) {
+                    $buffer = str_replace('\\/', '/', $buffer);
+                }
+
+                if ($unescapeUnicode && function_exists('mb_convert_encoding')) {
+                    // https://stackoverflow.com/questions/2934563/how-to-decode-unicode-escape-sequences-like-u00ed-to-proper-utf-8-encoded-cha
+                    $buffer = preg_replace_callback('/(\\\\+)u([0-9a-f]{4})/i', function ($match) {
+                        $l = strlen($match[1]);
+
+                        if ($l % 2) {
+                            $code = hexdec($match[2]);
+                            // 0xD800..0xDFFF denotes UTF-16 surrogate pair which won't be unescaped
+                            // see https://github.com/composer/composer/issues/7510
+                            if (0xD800 <= $code && 0xDFFF >= $code) {
+                                return $match[0];
+                            }
+
+                            return str_repeat('\\', $l - 1) . mb_convert_encoding(
+                                pack('H*', $match[2]),
+                                'UTF-8',
+                                'UCS-2BE'
+                            );
+                        }
+
+                        return $match[0];
+                    }, $buffer);
+                }
+
+                $result .= $buffer.$char;
+                $buffer = '';
+                continue;
+            }
+
+            if (':' === $char) {
+                // Add a space after the : character
+                $char .= ' ';
+            } elseif ('}' === $char || ']' === $char) {
+                $pos--;
+                $prevChar = substr($json, $i - 1, 1);
+
+                if ('{' !== $prevChar && '[' !== $prevChar) {
+                    // If this character is the end of an element,
+                    // output a new line and indent the next line
+                    $result .= $newLine;
+                    for ($j = 0; $j < $pos; $j++) {
+                        $result .= $indentStr;
+                    }
+                } else {
+                    // Collapse empty {} and []
+                    $result = rtrim($result);
+                }
+            }
+
+            $result .= $char;
+
+            // If the last character was the beginning of an element,
+            // output a new line and indent the next line
+            if (',' === $char || '{' === $char || '[' === $char) {
+                $result .= $newLine;
+
+                if ('{' === $char || '[' === $char) {
+                    $pos++;
+                }
+
+                for ($j = 0; $j < $pos; $j++) {
+                    $result .= $indentStr;
+                }
+            }
+        }
+
+        return $result;
+    }
+}

data/helpers/vendor/composer/composer/src/Composer/Json/JsonManipulator.php

@@ -0,0 +1,521 @@
+<?php
+
+/*
+ * This file is part of Composer.
+ *
+ * (c) Nils Adermann <naderman@naderman.de>
+ *     Jordi Boggiano <j.boggiano@seld.be>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Composer\Json;
+
+use Composer\Repository\PlatformRepository;
+
+/**
+ * @author Jordi Boggiano <j.boggiano@seld.be>
+ */
+class JsonManipulator
+{
+    private static $DEFINES = '(?(DEFINE)
+       (?<number>   -? (?= [1-9]|0(?!\d) ) \d+ (\.\d+)? ([eE] [+-]? \d+)? )
+       (?<boolean>   true | false | null )
+       (?<string>    " ([^"\\\\]* | \\\\ ["\\\\bfnrt\/] | \\\\ u [0-9a-f]{4} )* " )
+       (?<array>     \[  (?:  (?&json) \s* (?: , (?&json) \s* )*  )?  \s* \] )
+       (?<pair>      \s* (?&string) \s* : (?&json) \s* )
+       (?<object>    \{  (?:  (?&pair)  (?: , (?&pair)  )*  )?  \s* \} )
+       (?<json>   \s* (?: (?&number) | (?&boolean) | (?&string) | (?&array) | (?&object) ) )
+    )';
+
+    private $contents;
+    private $newline;
+    private $indent;
+
+    public function __construct($contents)
+    {
+        $contents = trim($contents);
+        if ($contents === '') {
+            $contents = '{}';
+        }
+        if (!$this->pregMatch('#^\{(.*)\}$#s', $contents)) {
+            throw new \InvalidArgumentException('The json file must be an object ({})');
+        }
+        $this->newline = false !== strpos($contents, "\r\n") ? "\r\n" : "\n";
+        $this->contents = $contents === '{}' ? '{' . $this->newline . '}' : $contents;
+        $this->detectIndenting();
+    }
+
+    public function getContents()
+    {
+        return $this->contents . $this->newline;
+    }
+
+    public function addLink($type, $package, $constraint, $sortPackages = false)
+    {
+        $decoded = JsonFile::parseJson($this->contents);
+
+        // no link of that type yet
+        if (!isset($decoded[$type])) {
+            return $this->addMainKey($type, array($package => $constraint));
+        }
+
+        $regex = '{'.self::$DEFINES.'^(?P<start>\s*\{\s*(?:(?&string)\s*:\s*(?&json)\s*,\s*)*?)'.
+            '(?P<property>'.preg_quote(JsonFile::encode($type)).'\s*:\s*)(?P<value>(?&json))(?P<end>.*)}sx';
+        if (!$this->pregMatch($regex, $this->contents, $matches)) {
+            return false;
+        }
+
+        $links = $matches['value'];
+
+        // try to find existing link
+        $packageRegex = str_replace('/', '\\\\?/', preg_quote($package));
+        $regex = '{'.self::$DEFINES.'"(?P<package>'.$packageRegex.')"(\s*:\s*)(?&string)}ix';
+        if ($this->pregMatch($regex, $links, $packageMatches)) {
+            // update existing link
+            $existingPackage = $packageMatches['package'];
+            $packageRegex = str_replace('/', '\\\\?/', preg_quote($existingPackage));
+            $links = preg_replace_callback('{'.self::$DEFINES.'"'.$packageRegex.'"(?P<separator>\s*:\s*)(?&string)}ix', function ($m) use ($existingPackage, $constraint) {
+                return JsonFile::encode(str_replace('\\/', '/', $existingPackage)) . $m['separator'] . '"' . $constraint . '"';
+            }, $links);
+        } else {
+            if ($this->pregMatch('#^\s*\{\s*\S+.*?(\s*\}\s*)$#s', $links, $match)) {
+                // link missing but non empty links
+                $links = preg_replace(
+                    '{'.preg_quote($match[1]).'$}',
+                    // addcslashes is used to double up backslashes/$ since preg_replace resolves them as back references otherwise, see #1588
+                    addcslashes(',' . $this->newline . $this->indent . $this->indent . JsonFile::encode($package).': '.JsonFile::encode($constraint) . $match[1], '\\$'),
+                    $links
+                );
+            } else {
+                // links empty
+                $links = '{' . $this->newline .
+                    $this->indent . $this->indent . JsonFile::encode($package).': '.JsonFile::encode($constraint) . $this->newline .
+                    $this->indent . '}';
+            }
+        }
+
+        if (true === $sortPackages) {
+            $requirements = json_decode($links, true);
+            $this->sortPackages($requirements);
+            $links = $this->format($requirements);
+        }
+
+        $this->contents = $matches['start'] . $matches['property'] . $links . $matches['end'];
+
+        return true;
+    }
+
+    /**
+     * Sorts packages by importance (platform packages first, then PHP dependencies) and alphabetically.
+     *
+     * @link https://getcomposer.org/doc/02-libraries.md#platform-packages
+     *
+     * @param array $packages
+     */
+    private function sortPackages(array &$packages = array())
+    {
+        $prefix = function ($requirement) {
+            if (preg_match(PlatformRepository::PLATFORM_PACKAGE_REGEX, $requirement)) {
+                return preg_replace(
+                    array(
+                        '/^php/',
+                        '/^hhvm/',
+                        '/^ext/',
+                        '/^lib/',
+                        '/^\D/',
+                    ),
+                    array(
+                        '0-$0',
+                        '1-$0',
+                        '2-$0',
+                        '3-$0',
+                        '4-$0',
+                    ),
+                    $requirement
+                );
+            }
+
+            return '5-'.$requirement;
+        };
+
+        uksort($packages, function ($a, $b) use ($prefix) {
+            return strnatcmp($prefix($a), $prefix($b));
+        });
+    }
+
+    public function addRepository($name, $config)
+    {
+        return $this->addSubNode('repositories', $name, $config);
+    }
+
+    public function removeRepository($name)
+    {
+        return $this->removeSubNode('repositories', $name);
+    }
+
+    public function addConfigSetting($name, $value)
+    {
+        return $this->addSubNode('config', $name, $value);
+    }
+
+    public function removeConfigSetting($name)
+    {
+        return $this->removeSubNode('config', $name);
+    }
+
+    public function addProperty($name, $value)
+    {
+        if (substr($name, 0, 6) === 'extra.') {
+            return $this->addSubNode('extra', substr($name, 6), $value);
+        }
+
+        if (substr($name, 0, 8) === 'scripts.') {
+            return $this->addSubNode('scripts', substr($name, 8), $value);
+        }
+
+        return $this->addMainKey($name, $value);
+    }
+
+    public function removeProperty($name)
+    {
+        if (substr($name, 0, 6) === 'extra.') {
+            return $this->removeSubNode('extra', substr($name, 6));
+        }
+
+        if (substr($name, 0, 8) === 'scripts.') {
+            return $this->removeSubNode('scripts', substr($name, 8));
+        }
+
+        return $this->removeMainKey($name);
+    }
+
+    public function addSubNode($mainNode, $name, $value)
+    {
+        $decoded = JsonFile::parseJson($this->contents);
+
+        $subName = null;
+        if (in_array($mainNode, array('config', 'extra', 'scripts')) && false !== strpos($name, '.')) {
+            list($name, $subName) = explode('.', $name, 2);
+        }
+
+        // no main node yet
+        if (!isset($decoded[$mainNode])) {
+            if ($subName !== null) {
+                $this->addMainKey($mainNode, array($name => array($subName => $value)));
+            } else {
+                $this->addMainKey($mainNode, array($name => $value));
+            }
+
+            return true;
+        }
+
+        // main node content not match-able
+        $nodeRegex = '{'.self::$DEFINES.'^(?P<start> \s* \{ \s* (?: (?&string) \s* : (?&json) \s* , \s* )*?'.
+            preg_quote(JsonFile::encode($mainNode)).'\s*:\s*)(?P<content>(?&object))(?P<end>.*)}sx';
+
+        try {
+            if (!$this->pregMatch($nodeRegex, $this->contents, $match)) {
+                return false;
+            }
+        } catch (\RuntimeException $e) {
+            if ($e->getCode() === PREG_BACKTRACK_LIMIT_ERROR) {
+                return false;
+            }
+            throw $e;
+        }
+
+        $children = $match['content'];
+        // invalid match due to un-regexable content, abort
+        if (!@json_decode($children)) {
+            return false;
+        }
+
+        $that = $this;
+
+        // child exists
+        $childRegex = '{'.self::$DEFINES.'(?P<start>"'.preg_quote($name).'"\s*:\s*)(?P<content>(?&json))(?P<end>,?)}x';
+        if ($this->pregMatch($childRegex, $children, $matches)) {
+            $children = preg_replace_callback($childRegex, function ($matches) use ($subName, $value, $that) {
+                if ($subName !== null) {
+                    $curVal = json_decode($matches['content'], true);
+                    if (!is_array($curVal)) {
+                        $curVal = array();
+                    }
+                    $curVal[$subName] = $value;
+                    $value = $curVal;
+                }
+
+                return $matches['start'] . $that->format($value, 1) . $matches['end'];
+            }, $children);
+        } else {
+            $this->pregMatch('#^{ \s*? (?P<content>\S+.*?)? (?P<trailingspace>\s*) }$#sx', $children, $match);
+
+            $whitespace = '';
+            if (!empty($match['trailingspace'])) {
+                $whitespace = $match['trailingspace'];
+            }
+
+            if (!empty($match['content'])) {
+                if ($subName !== null) {
+                    $value = array($subName => $value);
+                }
+
+                // child missing but non empty children
+                $children = preg_replace(
+                    '#'.$whitespace.'}$#',
+                    addcslashes(',' . $this->newline . $this->indent . $this->indent . JsonFile::encode($name).': '.$this->format($value, 1) . $whitespace . '}', '\\$'),
+                    $children
+                );
+            } else {
+                if ($subName !== null) {
+                    $value = array($subName => $value);
+                }
+
+                // children present but empty
+                $children = '{' . $this->newline . $this->indent . $this->indent . JsonFile::encode($name).': '.$this->format($value, 1) . $whitespace . '}';
+            }
+        }
+
+        $this->contents = preg_replace_callback($nodeRegex, function ($m) use ($children) {
+            return $m['start'] . $children . $m['end'];
+        }, $this->contents);
+
+        return true;
+    }
+
+    public function removeSubNode($mainNode, $name)
+    {
+        $decoded = JsonFile::parseJson($this->contents);
+
+        // no node or empty node
+        if (empty($decoded[$mainNode])) {
+            return true;
+        }
+
+        // no node content match-able
+        $nodeRegex = '{'.self::$DEFINES.'^(?P<start> \s* \{ \s* (?: (?&string) \s* : (?&json) \s* , \s* )*?'.
+            preg_quote(JsonFile::encode($mainNode)).'\s*:\s*)(?P<content>(?&object))(?P<end>.*)}sx';
+        try {
+            if (!$this->pregMatch($nodeRegex, $this->contents, $match)) {
+                return false;
+            }
+        } catch (\RuntimeException $e) {
+            if ($e->getCode() === PREG_BACKTRACK_LIMIT_ERROR) {
+                return false;
+            }
+            throw $e;
+        }
+
+        $children = $match['content'];
+
+        // invalid match due to un-regexable content, abort
+        if (!@json_decode($children, true)) {
+            return false;
+        }
+
+        $subName = null;
+        if (in_array($mainNode, array('config', 'extra', 'scripts')) && false !== strpos($name, '.')) {
+            list($name, $subName) = explode('.', $name, 2);
+        }
+
+        // no node to remove
+        if (!isset($decoded[$mainNode][$name]) || ($subName && !isset($decoded[$mainNode][$name][$subName]))) {
+            return true;
+        }
+
+        // try and find a match for the subkey
+        if ($this->pregMatch('{"'.preg_quote($name).'"\s*:}i', $children)) {
+            // find best match for the value of "name"
+            if (preg_match_all('{'.self::$DEFINES.'"'.preg_quote($name).'"\s*:\s*(?:(?&json))}x', $children, $matches)) {
+                $bestMatch = '';
+                foreach ($matches[0] as $match) {
+                    if (strlen($bestMatch) < strlen($match)) {
+                        $bestMatch = $match;
+                    }
+                }
+                $childrenClean = preg_replace('{,\s*'.preg_quote($bestMatch).'}i', '', $children, -1, $count);
+                if (1 !== $count) {
+                    $childrenClean = preg_replace('{'.preg_quote($bestMatch).'\s*,?\s*}i', '', $childrenClean, -1, $count);
+                    if (1 !== $count) {
+                        return false;
+                    }
+                }
+            }
+        } else {
+            $childrenClean = $children;
+        }
+
+        // no child data left, $name was the only key in
+        $this->pregMatch('#^{ \s*? (?P<content>\S+.*?)? (?P<trailingspace>\s*) }$#sx', $childrenClean, $match);
+        if (empty($match['content'])) {
+            $newline = $this->newline;
+            $indent = $this->indent;
+
+            $this->contents = preg_replace_callback($nodeRegex, function ($matches) use ($indent, $newline) {
+                return $matches['start'] . '{' . $newline . $indent . '}' . $matches['end'];
+            }, $this->contents);
+
+            // we have a subname, so we restore the rest of $name
+            if ($subName !== null) {
+                $curVal = json_decode($children, true);
+                unset($curVal[$name][$subName]);
+                $this->addSubNode($mainNode, $name, $curVal[$name]);
+            }
+
+            return true;
+        }
+
+        $that = $this;
+        $this->contents = preg_replace_callback($nodeRegex, function ($matches) use ($that, $name, $subName, $childrenClean) {
+            if ($subName !== null) {
+                $curVal = json_decode($matches['content'], true);
+                unset($curVal[$name][$subName]);
+                $childrenClean = $that->format($curVal, 0);
+            }
+
+            return $matches['start'] . $childrenClean . $matches['end'];
+        }, $this->contents);
+
+        return true;
+    }
+
+    public function addMainKey($key, $content)
+    {
+        $decoded = JsonFile::parseJson($this->contents);
+        $content = $this->format($content);
+
+        // key exists already
+        $regex = '{'.self::$DEFINES.'^(?P<start>\s*\{\s*(?:(?&string)\s*:\s*(?&json)\s*,\s*)*?)'.
+            '(?P<key>'.preg_quote(JsonFile::encode($key)).'\s*:\s*(?&json))(?P<end>.*)}sx';
+        if (isset($decoded[$key]) && $this->pregMatch($regex, $this->contents, $matches)) {
+            // invalid match due to un-regexable content, abort
+            if (!@json_decode('{'.$matches['key'].'}')) {
+                return false;
+            }
+
+            $this->contents = $matches['start'] . JsonFile::encode($key).': '.$content . $matches['end'];
+
+            return true;
+        }
+
+        // append at the end of the file and keep whitespace
+        if ($this->pregMatch('#[^{\s](\s*)\}$#', $this->contents, $match)) {
+            $this->contents = preg_replace(
+                '#'.$match[1].'\}$#',
+                addcslashes(',' . $this->newline . $this->indent . JsonFile::encode($key). ': '. $content . $this->newline . '}', '\\$'),
+                $this->contents
+            );
+
+            return true;
+        }
+
+        // append at the end of the file
+        $this->contents = preg_replace(
+            '#\}$#',
+            addcslashes($this->indent . JsonFile::encode($key). ': '.$content . $this->newline . '}', '\\$'),
+            $this->contents
+        );
+
+        return true;
+    }
+
+    public function removeMainKey($key)
+    {
+        $decoded = JsonFile::parseJson($this->contents);
+
+        if (!array_key_exists($key, $decoded)) {
+            return true;
+        }
+
+        // key exists already
+        $regex = '{'.self::$DEFINES.'^(?P<start>\s*\{\s*(?:(?&string)\s*:\s*(?&json)\s*,\s*)*?)'.
+            '(?P<removal>'.preg_quote(JsonFile::encode($key)).'\s*:\s*(?&json))\s*,?\s*(?P<end>.*)}sx';
+        if ($this->pregMatch($regex, $this->contents, $matches)) {
+            // invalid match due to un-regexable content, abort
+            if (!@json_decode('{'.$matches['removal'].'}')) {
+                return false;
+            }
+
+            // check that we are not leaving a dangling comma on the previous line if the last line was removed
+            if (preg_match('#,\s*$#', $matches['start']) && preg_match('#^\}$#', $matches['end'])) {
+                $matches['start'] = rtrim(preg_replace('#,(\s*)$#', '$1', $matches['start']), $this->indent);
+            }
+
+            $this->contents = $matches['start'] . $matches['end'];
+            if (preg_match('#^\{\s*\}\s*$#', $this->contents)) {
+                $this->contents = "{\n}";
+            }
+
+            return true;
+        }
+
+        return false;
+    }
+
+    public function format($data, $depth = 0)
+    {
+        if (is_array($data)) {
+            reset($data);
+
+            if (is_numeric(key($data))) {
+                foreach ($data as $key => $val) {
+                    $data[$key] = $this->format($val, $depth + 1);
+                }
+
+                return '['.implode(', ', $data).']';
+            }
+
+            $out = '{' . $this->newline;
+            $elems = array();
+            foreach ($data as $key => $val) {
+                $elems[] = str_repeat($this->indent, $depth + 2) . JsonFile::encode($key). ': '.$this->format($val, $depth + 1);
+            }
+
+            return $out . implode(','.$this->newline, $elems) . $this->newline . str_repeat($this->indent, $depth + 1) . '}';
+        }
+
+        return JsonFile::encode($data);
+    }
+
+    protected function detectIndenting()
+    {
+        if ($this->pregMatch('{^([ \t]+)"}m', $this->contents, $match)) {
+            $this->indent = $match[1];
+        } else {
+            $this->indent = '    ';
+        }
+    }
+
+    protected function pregMatch($re, $str, &$matches = array())
+    {
+        $count = preg_match($re, $str, $matches);
+
+        if ($count === false) {
+            switch (preg_last_error()) {
+                case PREG_NO_ERROR:
+                    throw new \RuntimeException('Failed to execute regex: PREG_NO_ERROR', PREG_NO_ERROR);
+                case PREG_INTERNAL_ERROR:
+                    throw new \RuntimeException('Failed to execute regex: PREG_INTERNAL_ERROR', PREG_INTERNAL_ERROR);
+                case PREG_BACKTRACK_LIMIT_ERROR:
+                    throw new \RuntimeException('Failed to execute regex: PREG_BACKTRACK_LIMIT_ERROR', PREG_BACKTRACK_LIMIT_ERROR);
+                case PREG_RECURSION_LIMIT_ERROR:
+                    throw new \RuntimeException('Failed to execute regex: PREG_RECURSION_LIMIT_ERROR', PREG_RECURSION_LIMIT_ERROR);
+                case PREG_BAD_UTF8_ERROR:
+                    throw new \RuntimeException('Failed to execute regex: PREG_BAD_UTF8_ERROR', PREG_BAD_UTF8_ERROR);
+                case PREG_BAD_UTF8_OFFSET_ERROR:
+                    throw new \RuntimeException('Failed to execute regex: PREG_BAD_UTF8_OFFSET_ERROR', PREG_BAD_UTF8_OFFSET_ERROR);
+                case 6: // PREG_JIT_STACKLIMIT_ERROR
+                    if (PHP_VERSION_ID > 70000) {
+                        throw new \RuntimeException('Failed to execute regex: PREG_JIT_STACKLIMIT_ERROR', 6);
+                    }
+                    // no break
+                default:
+                    throw new \RuntimeException('Failed to execute regex: Unknown error');
+            }
+        }
+
+        return $count;
+    }
+}