dependabot-composer 0.107.27 → 0.107.28

data/helpers/vendor/seld/jsonlint/src/Seld/JsonLint/Lexer.php

@@ -0,0 +1,217 @@
+<?php
+
+/*
+ * This file is part of the JSON Lint package.
+ *
+ * (c) 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 Seld\JsonLint;
+
+/**
+ * Lexer class
+ *
+ * Ported from https://github.com/zaach/jsonlint
+ */
+class Lexer
+{
+    private $EOF = 1;
+    private $rules = array(
+        0 => '/^\s+/',
+        1 => '/^-?([0-9]|[1-9][0-9]+)(\.[0-9]+)?([eE][+-]?[0-9]+)?\b/',
+        2 => '{^"(?>\\\\["bfnrt/\\\\]|\\\\u[a-fA-F0-9]{4}|[^\0-\x1f\\\\"]++)*+"}',
+        3 => '/^\{/',
+        4 => '/^\}/',
+        5 => '/^\[/',
+        6 => '/^\]/',
+        7 => '/^,/',
+        8 => '/^:/',
+        9 => '/^true\b/',
+        10 => '/^false\b/',
+        11 => '/^null\b/',
+        12 => '/^$/',
+        13 => '/^./',
+    );
+
+    private $conditions = array(
+        "INITIAL" => array(
+            "rules" => array(0,1,2,3,4,5,6,7,8,9,10,11,12,13),
+            "inclusive" => true,
+        ),
+    );
+
+    private $conditionStack;
+    private $input;
+    private $more;
+    private $done;
+    private $matched;
+
+    public $match;
+    public $yylineno;
+    public $yyleng;
+    public $yytext;
+    public $yylloc;
+
+    public function lex()
+    {
+        $r = $this->next();
+        if (!$r instanceof Undefined) {
+            return $r;
+        }
+
+        return $this->lex();
+    }
+
+    public function setInput($input)
+    {
+        $this->input = $input;
+        $this->more = false;
+        $this->done = false;
+        $this->yylineno = $this->yyleng = 0;
+        $this->yytext = $this->matched = $this->match = '';
+        $this->conditionStack = array('INITIAL');
+        $this->yylloc = array('first_line' => 1, 'first_column' => 0, 'last_line' => 1, 'last_column' => 0);
+
+        return $this;
+    }
+
+    public function showPosition()
+    {
+        $pre = str_replace("\n", '', $this->getPastInput());
+        $c = str_repeat('-', max(0, strlen($pre) - 1)); // new Array(pre.length + 1).join("-");
+
+        return $pre . str_replace("\n", '', $this->getUpcomingInput()) . "\n" . $c . "^";
+    }
+
+    public function getPastInput()
+    {
+        $past = substr($this->matched, 0, strlen($this->matched) - strlen($this->match));
+
+        return (strlen($past) > 20 ? '...' : '') . substr($past, -20);
+    }
+
+    public function getUpcomingInput()
+    {
+        $next = $this->match;
+        if (strlen($next) < 20) {
+            $next .= substr($this->input, 0, 20 - strlen($next));
+        }
+
+        return substr($next, 0, 20) . (strlen($next) > 20 ? '...' : '');
+    }
+
+    protected function parseError($str, $hash)
+    {
+        throw new \Exception($str);
+    }
+
+    private function next()
+    {
+        if ($this->done) {
+            return $this->EOF;
+        }
+        if ($this->input === '') {
+            $this->done = true;
+        }
+
+        $token = null;
+        $match = null;
+        $col = null;
+        $lines = null;
+
+        if (!$this->more) {
+            $this->yytext = '';
+            $this->match = '';
+        }
+
+        $rules = $this->getCurrentRules();
+        $rulesLen = count($rules);
+
+        for ($i=0; $i < $rulesLen; $i++) {
+            if (preg_match($this->rules[$rules[$i]], $this->input, $match)) {
+                preg_match_all('/\n.*/', $match[0], $lines);
+                $lines = $lines[0];
+                if ($lines) {
+                    $this->yylineno += count($lines);
+                }
+
+                $this->yylloc = array(
+                    'first_line' => $this->yylloc['last_line'],
+                    'last_line' => $this->yylineno+1,
+                    'first_column' => $this->yylloc['last_column'],
+                    'last_column' => $lines ? strlen($lines[count($lines) - 1]) - 1 : $this->yylloc['last_column'] + strlen($match[0]),
+                );
+                $this->yytext .= $match[0];
+                $this->match .= $match[0];
+                $this->yyleng = strlen($this->yytext);
+                $this->more = false;
+                $this->input = substr($this->input, strlen($match[0]));
+                $this->matched .= $match[0];
+                $token = $this->performAction($rules[$i], $this->conditionStack[count($this->conditionStack)-1]);
+                if ($token) {
+                    return $token;
+                }
+
+                return new Undefined();
+            }
+        }
+
+        if ($this->input === "") {
+            return $this->EOF;
+        }
+
+        $this->parseError(
+            'Lexical error on line ' . ($this->yylineno+1) . ". Unrecognized text.\n" . $this->showPosition(),
+            array(
+                'text' => "",
+                'token' => null,
+                'line' => $this->yylineno,
+            )
+        );
+    }
+
+    private function getCurrentRules()
+    {
+        return $this->conditions[$this->conditionStack[count($this->conditionStack)-1]]['rules'];
+    }
+
+    private function performAction($avoiding_name_collisions, $YY_START)
+    {
+        switch ($avoiding_name_collisions) {
+        case 0:/* skip whitespace */
+            break;
+        case 1:
+            return 6;
+           break;
+        case 2:
+            $this->yytext = substr($this->yytext, 1, $this->yyleng-2);
+
+            return 4;
+        case 3:
+            return 17;
+        case 4:
+            return 18;
+        case 5:
+            return 23;
+        case 6:
+            return 24;
+        case 7:
+            return 22;
+        case 8:
+            return 21;
+        case 9:
+            return 10;
+        case 10:
+            return 11;
+        case 11:
+            return 8;
+        case 12:
+            return 14;
+        case 13:
+            return 'INVALID';
+        }
+    }
+}

data/helpers/vendor/seld/jsonlint/src/Seld/JsonLint/ParsingException.php

@@ -0,0 +1,28 @@
+<?php
+
+/*
+ * This file is part of the JSON Lint package.
+ *
+ * (c) 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 Seld\JsonLint;
+
+class ParsingException extends \Exception
+{
+    protected $details;
+
+    public function __construct($message, $details = array())
+    {
+        $this->details = $details;
+        parent::__construct($message);
+    }
+
+    public function getDetails()
+    {
+        return $this->details;
+    }
+}

data/helpers/vendor/seld/jsonlint/src/Seld/JsonLint/Undefined.php

@@ -0,0 +1,16 @@
+<?php
+
+/*
+ * This file is part of the JSON Lint package.
+ *
+ * (c) 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 Seld\JsonLint;
+
+class Undefined
+{
+}

data/helpers/vendor/seld/jsonlint/tests/JsonParserTest.php

@@ -0,0 +1,230 @@
+<?php
+
+/*
+ * This file is part of the JSON Lint package.
+ *
+ * (c) 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.
+ */
+
+use PHPUnit\Framework\TestCase;
+use Seld\JsonLint\JsonParser;
+use Seld\JsonLint\ParsingException;
+use Seld\JsonLint\DuplicateKeyException;
+
+class JsonParserTest extends TestCase
+{
+    protected $json = array(
+        '42', '42.3', '0.3', '-42', '-42.3', '-0.3',
+        '2e1', '2E1', '-2e1', '-2E1', '2E+2', '2E-2', '-2E+2', '-2E-2',
+        'true', 'false', 'null', '""', '[]', '{}', '"string"',
+        '["a", "sdfsd"]',
+        '{"foo":"bar", "bar":"baz", "":"buz"}',
+        '{"":"foo", "_empty_":"bar"}',
+        '"\u00c9v\u00e9nement"',
+        '"http:\/\/foo.com"',
+        '"zo\\\\mg"',
+        '{"test":"\u00c9v\u00e9nement"}',
+        '["\u00c9v\u00e9nement"]',
+        '"foo/bar"',
+        '{"test":"http:\/\/foo\\\\zomg"}',
+        '["http:\/\/foo\\\\zomg"]',
+        '{"":"foo"}',
+        '{"a":"b", "b":"c"}',
+        '0',
+        '""',
+    );
+
+    /**
+     * @dataProvider provideValidStrings
+     */
+    public function testParsesValidStrings($input)
+    {
+        $parser = new JsonParser();
+        $this->assertEquals(json_decode($input), $parser->parse($input));
+    }
+
+    public function provideValidStrings()
+    {
+        $strings = array();
+        foreach ($this->json as $input) {
+            $strings[] = array($input);
+        }
+
+        return $strings;
+    }
+
+    public function testErrorOnTrailingComma()
+    {
+        $parser = new JsonParser();
+        try {
+            $parser->parse('{
+    "foo":"bar",
+}');
+            $this->fail('Invalid trailing comma should be detected');
+        } catch (ParsingException $e) {
+            $this->assertContains('It appears you have an extra trailing comma', $e->getMessage());
+        }
+    }
+
+    public function testErrorOnInvalidQuotes()
+    {
+        $parser = new JsonParser();
+        try {
+            $parser->parse('{
+    "foo": \'bar\',
+}');
+            $this->fail('Invalid quotes for string should be detected');
+        } catch (ParsingException $e) {
+            $this->assertContains('Invalid string, it appears you used single quotes instead of double quotes', $e->getMessage());
+        }
+    }
+
+    public function testErrorOnUnescapedBackslash()
+    {
+        $parser = new JsonParser();
+        try {
+            $parser->parse('{
+    "foo": "bar\z",
+}');
+            $this->fail('Invalid unescaped string should be detected');
+        } catch (ParsingException $e) {
+            $this->assertContains('Invalid string, it appears you have an unescaped backslash at: \z', $e->getMessage());
+        }
+    }
+
+    public function testErrorOnUnterminatedString()
+    {
+        $parser = new JsonParser();
+        try {
+            $parser->parse('{"bar": "foo}');
+            $this->fail('Invalid unterminated string should be detected');
+        } catch (ParsingException $e) {
+            $this->assertContains('Invalid string, it appears you forgot to terminate a string, or attempted to write a multiline string which is invalid', $e->getMessage());
+        }
+    }
+
+    public function testErrorOnMultilineString()
+    {
+        $parser = new JsonParser();
+        try {
+            $parser->parse('{"bar": "foo
+bar"}');
+            $this->fail('Invalid multi-line string should be detected');
+        } catch (ParsingException $e) {
+            $this->assertContains('Invalid string, it appears you forgot to terminate a string, or attempted to write a multiline string which is invalid', $e->getMessage());
+        }
+    }
+
+    public function testErrorAtBeginning()
+    {
+        $parser = new JsonParser();
+        try {
+            $parser->parse('
+
+');
+            $this->fail('Empty string should be invalid');
+        } catch (ParsingException $e) {
+            $this->assertContains("Parse error on line 1:\n\n^", $e->getMessage());
+        }
+    }
+
+    public function testParsesMultiInARow()
+    {
+        $parser = new JsonParser();
+        foreach ($this->json as $input) {
+            $this->assertEquals(json_decode($input), $parser->parse($input));
+        }
+    }
+
+    public function testDetectsKeyOverrides()
+    {
+        $parser = new JsonParser();
+
+        try {
+            $parser->parse('{"a":"b", "a":"c"}', JsonParser::DETECT_KEY_CONFLICTS);
+            $this->fail('Duplicate keys should not be allowed');
+        } catch (DuplicateKeyException $e) {
+            $this->assertContains('Duplicate key: a', $e->getMessage());
+            $this->assertSame('a', $e->getKey());
+            $this->assertSame(array('line' => 1, 'key' => 'a'), $e->getDetails());
+        }
+    }
+
+    public function testDetectsKeyOverridesWithEmpty()
+    {
+        $parser = new JsonParser();
+
+        if (PHP_VERSION_ID >= 70100) {
+            $this->markTestSkipped('Only for PHP < 7.1');
+        }
+        try {
+            $parser->parse('{"":"b", "_empty_":"a"}', JsonParser::DETECT_KEY_CONFLICTS);
+            $this->fail('Duplicate keys should not be allowed');
+        } catch (DuplicateKeyException $e) {
+            $this->assertContains('Duplicate key: _empty_', $e->getMessage());
+            $this->assertSame('_empty_', $e->getKey());
+            $this->assertSame(array('line' => 1, 'key' => '_empty_'), $e->getDetails());
+        }
+    }
+
+    public function testDuplicateKeys()
+    {
+        $parser = new JsonParser();
+
+        $result = $parser->parse('{"a":"b", "a":"c", "a":"d"}', JsonParser::ALLOW_DUPLICATE_KEYS);
+        $this->assertThat($result,
+            $this->logicalAnd(
+                $this->objectHasAttribute('a'),
+                $this->objectHasAttribute('a.1'),
+                $this->objectHasAttribute('a.2')
+            )
+        );
+    }
+
+    public function testDuplicateKeysWithEmpty()
+    {
+        $parser = new JsonParser();
+
+        if (PHP_VERSION_ID >= 70100) {
+            $this->markTestSkipped('Only for PHP < 7.1');
+        }
+        $result = $parser->parse('{"":"a", "_empty_":"b"}', JsonParser::ALLOW_DUPLICATE_KEYS);
+        $this->assertThat($result,
+            $this->logicalAnd(
+                $this->objectHasAttribute('_empty_'),
+                $this->objectHasAttribute('_empty_.1')
+            )
+        );
+    }
+
+    public function testParseToArray()
+    {
+        $parser = new JsonParser();
+
+        $json = '{"one":"a", "two":{"three": "four"}, "": "empty"}';
+        $result = $parser->parse($json, JsonParser::PARSE_TO_ASSOC);
+        $this->assertSame(json_decode($json, true), $result);
+    }
+
+    public function testFileWithBOM()
+    {
+        try {
+            $parser = new JsonParser();
+            $parser->parse(file_get_contents(dirname(__FILE__) .'/bom.json'));
+            $this->fail('BOM should be detected');
+        } catch (ParsingException $e) {
+            $this->assertContains('BOM detected', $e->getMessage());
+        }
+    }
+
+    public function testLongString()
+    {
+        $parser = new JsonParser();
+
+        $json = '{"k":"' . str_repeat("a\\n",10000) . '"}';
+        $this->assertEquals(json_decode($json), $parser->parse($json));
+    }
+}