pax_global_header00006660000000000000000000000064135543323330014516gustar00rootroot0000000000000052 comment=e2e5d290e4d2a4f0eb449f510071392e00e10d19 jsonlint-1.7.2/000077500000000000000000000000001355433233300133655ustar00rootroot00000000000000jsonlint-1.7.2/.gitignore000066400000000000000000000000421355433233300153510ustar00rootroot00000000000000vendor composer.lock composer.pharjsonlint-1.7.2/.travis.yml000066400000000000000000000004621355433233300155000ustar00rootroot00000000000000language: php sudo: false dist: trusty php: - 5.4 - 5.5 - 5.6 - 7.0 - 7.1 - 7.2 - 7.3 - 7.4snapshot - nightly matrix: include: - dist: precise php: 5.3 fast_finish: true allow_failures: - php: nightly before_script: - composer update script: vendor/bin/phpunit jsonlint-1.7.2/CHANGELOG.md000066400000000000000000000035751355433233300152100ustar00rootroot00000000000000### 1.7.2 (2019-10-24) * Fixed issue decoding some unicode escaped characters (for " and ') ### 1.7.1 (2018-01-24) * Fixed PHP 5.3 compatibility in bin/jsonlint ### 1.7.0 (2018-01-03) * Added ability to lint multiple files at once using the jsonlint binary ### 1.6.2 (2017-11-30) * No meaningful public changes ### 1.6.1 (2017-06-18) * Fixed parsing of `0` as invalid ### 1.6.0 (2017-03-06) * Added $flags arg to JsonParser::lint() to take the same flag as parse() did * Fixed backtracking performance issues on long strings with a lot of escaped characters ### 1.5.0 (2016-11-14) * Added support for PHP 7.1 (which converts `{"":""}` to an object property called `""` and not `"_empty_"` like 7.0 and below). ### 1.4.0 (2015-11-21) * Added a DuplicateKeyException allowing for more specific error detection and handling ### 1.3.1 (2015-01-04) * Fixed segfault when parsing large JSON strings ### 1.3.0 (2014-09-05) * Added parsing to an associative array via JsonParser::PARSE_TO_ASSOC * Fixed a warning when rendering parse errors on empty lines ### 1.2.0 (2014-07-20) * Added support for linting multiple files at once in bin/jsonlint * Added a -q/--quiet flag to suppress the output * Fixed error output being on STDOUT instead of STDERR * Fixed parameter parsing ### 1.1.2 (2013-11-04) * Fixed handling of Unicode BOMs to give a better failure hint ### 1.1.1 (2013-02-12) * Fixed handling of empty keys in objects in certain cases ### 1.1.0 (2012-12-13) * Added optional parsing of duplicate keys into key.2, key.3, etc via JsonParser::ALLOW_DUPLICATE_KEYS * Improved error reporting for common mistakes ### 1.0.1 (2012-04-03) * Added optional detection and error reporting for duplicate keys via JsonParser::DETECT_KEY_CONFLICTS * Added ability to pipe content through stdin into bin/jsonlint ### 1.0.0 (2012-03-12) * Initial release jsonlint-1.7.2/LICENSE000066400000000000000000000020421355433233300143700ustar00rootroot00000000000000Copyright (c) 2011 Jordi Boggiano Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. jsonlint-1.7.2/README.md000066400000000000000000000047031355433233300146500ustar00rootroot00000000000000JSON Lint ========= [![Build Status](https://secure.travis-ci.org/Seldaek/jsonlint.png)](http://travis-ci.org/Seldaek/jsonlint) Usage ----- ```php use Seld\JsonLint\JsonParser; $parser = new JsonParser(); // returns null if it's valid json, or a ParsingException object. $parser->lint($json); // Call getMessage() on the exception object to get // a well formatted error message error like this // Parse error on line 2: // ... "key": "value" "numbers": [1, 2, 3] // ----------------------^ // Expected one of: 'EOF', '}', ':', ',', ']' // Call getDetails() on the exception to get more info. // returns parsed json, like json_decode() does, but slower, throws // exceptions on failure. $parser->parse($json); ``` You can also pass additional flags to `JsonParser::lint/parse` that tweak the functionality: - `JsonParser::DETECT_KEY_CONFLICTS` throws an exception on duplicate keys. - `JsonParser::ALLOW_DUPLICATE_KEYS` collects duplicate keys. e.g. if you have two `foo` keys they will end up as `foo` and `foo.2`. - `JsonParser::PARSE_TO_ASSOC` parses to associative arrays instead of stdClass objects. Example: ```php $parser = new JsonParser; try { $parser->parse(file_get_contents($jsonFile), JsonParser::DETECT_KEY_CONFLICTS); } catch (DuplicateKeyException $e) { $details = $e->getDetails(); echo 'Key '.$details['key'].' is a duplicate in '.$jsonFile.' at line '.$details['line']; } ``` Installation ------------ For a quick install with Composer use: $ composer require seld/jsonlint JSON Lint can easily be used within another app if you have a [PSR-4](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-4-autoloader.md) autoloader, or it can be installed through [Composer](https://getcomposer.org/) for use as a CLI util. Once installed via Composer you can run the following command to lint a json file or URL: $ bin/jsonlint file.json Requirements ------------ - PHP 5.3+ - [optional] PHPUnit 3.5+ to execute the test suite (phpunit --version) Submitting bugs and feature requests ------------------------------------ Bugs and feature request are tracked on [GitHub](https://github.com/Seldaek/jsonlint/issues) Author ------ Jordi Boggiano - - License ------- JSON Lint is licensed under the MIT License - see the LICENSE file for details Acknowledgements ---------------- This library is a port of the JavaScript [jsonlint](https://github.com/zaach/jsonlint) library. jsonlint-1.7.2/bin/000077500000000000000000000000001355433233300141355ustar00rootroot00000000000000jsonlint-1.7.2/bin/jsonlint000077500000000000000000000056371355433233300157360ustar00rootroot00000000000000#!/usr/bin/env php * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ function includeIfExists($file) { if (file_exists($file)) { return include $file; } } if (!includeIfExists(__DIR__.'/../vendor/autoload.php') && !includeIfExists(__DIR__.'/../../../autoload.php')) { $msg = 'You must set up the project dependencies, run the following commands:'.PHP_EOL. 'curl -sS https://getcomposer.org/installer | php'.PHP_EOL. 'php composer.phar install'.PHP_EOL; fwrite(STDERR, $msg); exit(1); } use Seld\JsonLint\JsonParser; $files = array(); $quiet = false; if (isset($_SERVER['argc']) && $_SERVER['argc'] > 1) { for ($i = 1; $i < $_SERVER['argc']; $i++) { $arg = $_SERVER['argv'][$i]; if ($arg == '-q' || $arg == '--quiet') { $quiet = true; } else { if ($arg == '-h' || $arg == '--help') { showUsage(); } else { $files[] = $arg; } } } } if (!empty($files)) { // file linting $exitCode = 0; foreach ($files as $file) { $result = lintFile($file, $quiet); if ($result === false) { $exitCode = 1; } } exit($exitCode); } else { //stdin linting if ($contents = file_get_contents('php://stdin')) { lint($contents); } else { fwrite(STDERR, 'No file name or json input given' . PHP_EOL); exit(1); } } // stdin lint function function lint($content, $quiet = false) { $parser = new JsonParser(); if ($err = $parser->lint($content)) { fwrite(STDERR, $err->getMessage() . ' (stdin)' . PHP_EOL); exit(1); } if (!$quiet) { echo 'Valid JSON (stdin)' . PHP_EOL; exit(0); } } // file lint function function lintFile($file, $quiet = false) { if (!preg_match('{^https?://}i', $file)) { if (!file_exists($file)) { fwrite(STDERR, 'File not found: ' . $file . PHP_EOL); return false; } if (!is_readable($file)) { fwrite(STDERR, 'File not readable: ' . $file . PHP_EOL); return false; } } $content = file_get_contents($file); $parser = new JsonParser(); if ($err = $parser->lint($content)) { fwrite(STDERR, $file . ': ' . $err->getMessage() . PHP_EOL); return false; } if (!$quiet) { echo 'Valid JSON (' . $file . ')' . PHP_EOL; } return true; } // usage text function function showUsage() { echo 'Usage: jsonlint file [options]'.PHP_EOL; echo PHP_EOL; echo 'Options:'.PHP_EOL; echo ' -q, --quiet Cause jsonlint to be quiet when no errors are found'.PHP_EOL; echo ' -h, --help Show this message'.PHP_EOL; exit(0); } jsonlint-1.7.2/composer.json000066400000000000000000000011131355433233300161030ustar00rootroot00000000000000{ "name": "seld/jsonlint", "description": "JSON Linter", "keywords": ["json", "parser", "linter", "validator"], "type": "library", "license": "MIT", "authors": [ { "name": "Jordi Boggiano", "email": "j.boggiano@seld.be", "homepage": "http://seld.be" } ], "require": { "php": "^5.3 || ^7.0" }, "require-dev": { "phpunit/phpunit": "^4.8.35 || ^5.7 || ^6.0" }, "autoload": { "psr-4": { "Seld\\JsonLint\\": "src/Seld/JsonLint/" } }, "bin": ["bin/jsonlint"] } jsonlint-1.7.2/phpunit.xml.dist000066400000000000000000000012541355433233300165420ustar00rootroot00000000000000 ./tests/ ./src/Seld/JsonLint/ jsonlint-1.7.2/src/000077500000000000000000000000001355433233300141545ustar00rootroot00000000000000jsonlint-1.7.2/src/Seld/000077500000000000000000000000001355433233300150435ustar00rootroot00000000000000jsonlint-1.7.2/src/Seld/JsonLint/000077500000000000000000000000001355433233300166035ustar00rootroot00000000000000jsonlint-1.7.2/src/Seld/JsonLint/DuplicateKeyException.php000066400000000000000000000010701355433233300235540ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace Seld\JsonLint; class DuplicateKeyException extends ParsingException { public function __construct($message, $key, array $details = array()) { $details['key'] = $key; parent::__construct($message, $details); } public function getKey() { return $this->details['key']; } } jsonlint-1.7.2/src/Seld/JsonLint/JsonParser.php000066400000000000000000000502431355433233300214060ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace Seld\JsonLint; use stdClass; /** * Parser class * * Example: * * $parser = new JsonParser(); * // returns null if it's valid json, or an error object * $parser->lint($json); * // returns parsed json, like json_decode does, but slower, throws exceptions on failure. * $parser->parse($json); * * Ported from https://github.com/zaach/jsonlint */ class JsonParser { const DETECT_KEY_CONFLICTS = 1; const ALLOW_DUPLICATE_KEYS = 2; const PARSE_TO_ASSOC = 4; private $lexer; private $flags; private $stack; private $vstack; // semantic value stack private $lstack; // location stack private $symbols = array( 'error' => 2, 'JSONString' => 3, 'STRING' => 4, 'JSONNumber' => 5, 'NUMBER' => 6, 'JSONNullLiteral' => 7, 'NULL' => 8, 'JSONBooleanLiteral' => 9, 'TRUE' => 10, 'FALSE' => 11, 'JSONText' => 12, 'JSONValue' => 13, 'EOF' => 14, 'JSONObject' => 15, 'JSONArray' => 16, '{' => 17, '}' => 18, 'JSONMemberList' => 19, 'JSONMember' => 20, ':' => 21, ',' => 22, '[' => 23, ']' => 24, 'JSONElementList' => 25, '$accept' => 0, '$end' => 1, ); private $terminals_ = array( 2 => "error", 4 => "STRING", 6 => "NUMBER", 8 => "NULL", 10 => "TRUE", 11 => "FALSE", 14 => "EOF", 17 => "{", 18 => "}", 21 => ":", 22 => ",", 23 => "[", 24 => "]", ); private $productions_ = array( 0, array(3, 1), array(5, 1), array(7, 1), array(9, 1), array(9, 1), array(12, 2), array(13, 1), array(13, 1), array(13, 1), array(13, 1), array(13, 1), array(13, 1), array(15, 2), array(15, 3), array(20, 3), array(19, 1), array(19, 3), array(16, 2), array(16, 3), array(25, 1), array(25, 3) ); private $table = array(array(3 => 5, 4 => array(1,12), 5 => 6, 6 => array(1,13), 7 => 3, 8 => array(1,9), 9 => 4, 10 => array(1,10), 11 => array(1,11), 12 => 1, 13 => 2, 15 => 7, 16 => 8, 17 => array(1,14), 23 => array(1,15)), array( 1 => array(3)), array( 14 => array(1,16)), array( 14 => array(2,7), 18 => array(2,7), 22 => array(2,7), 24 => array(2,7)), array( 14 => array(2,8), 18 => array(2,8), 22 => array(2,8), 24 => array(2,8)), array( 14 => array(2,9), 18 => array(2,9), 22 => array(2,9), 24 => array(2,9)), array( 14 => array(2,10), 18 => array(2,10), 22 => array(2,10), 24 => array(2,10)), array( 14 => array(2,11), 18 => array(2,11), 22 => array(2,11), 24 => array(2,11)), array( 14 => array(2,12), 18 => array(2,12), 22 => array(2,12), 24 => array(2,12)), array( 14 => array(2,3), 18 => array(2,3), 22 => array(2,3), 24 => array(2,3)), array( 14 => array(2,4), 18 => array(2,4), 22 => array(2,4), 24 => array(2,4)), array( 14 => array(2,5), 18 => array(2,5), 22 => array(2,5), 24 => array(2,5)), array( 14 => array(2,1), 18 => array(2,1), 21 => array(2,1), 22 => array(2,1), 24 => array(2,1)), array( 14 => array(2,2), 18 => array(2,2), 22 => array(2,2), 24 => array(2,2)), array( 3 => 20, 4 => array(1,12), 18 => array(1,17), 19 => 18, 20 => 19 ), array( 3 => 5, 4 => array(1,12), 5 => 6, 6 => array(1,13), 7 => 3, 8 => array(1,9), 9 => 4, 10 => array(1,10), 11 => array(1,11), 13 => 23, 15 => 7, 16 => 8, 17 => array(1,14), 23 => array(1,15), 24 => array(1,21), 25 => 22 ), array( 1 => array(2,6)), array( 14 => array(2,13), 18 => array(2,13), 22 => array(2,13), 24 => array(2,13)), array( 18 => array(1,24), 22 => array(1,25)), array( 18 => array(2,16), 22 => array(2,16)), array( 21 => array(1,26)), array( 14 => array(2,18), 18 => array(2,18), 22 => array(2,18), 24 => array(2,18)), array( 22 => array(1,28), 24 => array(1,27)), array( 22 => array(2,20), 24 => array(2,20)), array( 14 => array(2,14), 18 => array(2,14), 22 => array(2,14), 24 => array(2,14)), array( 3 => 20, 4 => array(1,12), 20 => 29 ), array( 3 => 5, 4 => array(1,12), 5 => 6, 6 => array(1,13), 7 => 3, 8 => array(1,9), 9 => 4, 10 => array(1,10), 11 => array(1,11), 13 => 30, 15 => 7, 16 => 8, 17 => array(1,14), 23 => array(1,15)), array( 14 => array(2,19), 18 => array(2,19), 22 => array(2,19), 24 => array(2,19)), array( 3 => 5, 4 => array(1,12), 5 => 6, 6 => array(1,13), 7 => 3, 8 => array(1,9), 9 => 4, 10 => array(1,10), 11 => array(1,11), 13 => 31, 15 => 7, 16 => 8, 17 => array(1,14), 23 => array(1,15)), array( 18 => array(2,17), 22 => array(2,17)), array( 18 => array(2,15), 22 => array(2,15)), array( 22 => array(2,21), 24 => array(2,21)), ); private $defaultActions = array( 16 => array(2, 6) ); /** * @param string $input JSON string * @param int $flags Bitmask of parse/lint options (see constants of this class) * @return null|ParsingException null if no error is found, a ParsingException containing all details otherwise */ public function lint($input, $flags = 0) { try { $this->parse($input, $flags); } catch (ParsingException $e) { return $e; } } /** * @param string $input JSON string * @param int $flags Bitmask of parse/lint options (see constants of this class) * @return mixed * @throws ParsingException */ public function parse($input, $flags = 0) { $this->failOnBOM($input); $this->flags = $flags; $this->stack = array(0); $this->vstack = array(null); $this->lstack = array(); $yytext = ''; $yylineno = 0; $yyleng = 0; $recovering = 0; $TERROR = 2; $EOF = 1; $this->lexer = new Lexer(); $this->lexer->setInput($input); $yyloc = $this->lexer->yylloc; $this->lstack[] = $yyloc; $symbol = null; $preErrorSymbol = null; $state = null; $action = null; $a = null; $r = null; $yyval = new stdClass; $p = null; $len = null; $newState = null; $expected = null; $errStr = null; while (true) { // retrieve state number from top of stack $state = $this->stack[count($this->stack)-1]; // use default actions if available if (isset($this->defaultActions[$state])) { $action = $this->defaultActions[$state]; } else { if ($symbol == null) { $symbol = $this->lex(); } // read action for current state and first input $action = isset($this->table[$state][$symbol]) ? $this->table[$state][$symbol] : false; } // handle parse error if (!$action || !$action[0]) { if (!$recovering) { // Report error $expected = array(); foreach ($this->table[$state] as $p => $ignore) { if (isset($this->terminals_[$p]) && $p > 2) { $expected[] = "'" . $this->terminals_[$p] . "'"; } } $message = null; if (in_array("'STRING'", $expected) && in_array(substr($this->lexer->match, 0, 1), array('"', "'"))) { $message = "Invalid string"; if ("'" === substr($this->lexer->match, 0, 1)) { $message .= ", it appears you used single quotes instead of double quotes"; } elseif (preg_match('{".+?(\\\\[^"bfnrt/\\\\u])}', $this->lexer->getUpcomingInput(), $match)) { $message .= ", it appears you have an unescaped backslash at: ".$match[1]; } elseif (preg_match('{"(?:[^"]+|\\\\")*$}m', $this->lexer->getUpcomingInput())) { $message .= ", it appears you forgot to terminate a string, or attempted to write a multiline string which is invalid"; } } $errStr = 'Parse error on line ' . ($yylineno+1) . ":\n"; $errStr .= $this->lexer->showPosition() . "\n"; if ($message) { $errStr .= $message; } else { $errStr .= (count($expected) > 1) ? "Expected one of: " : "Expected: "; $errStr .= implode(', ', $expected); } if (',' === substr(trim($this->lexer->getPastInput()), -1)) { $errStr .= " - It appears you have an extra trailing comma"; } $this->parseError($errStr, array( 'text' => $this->lexer->match, 'token' => !empty($this->terminals_[$symbol]) ? $this->terminals_[$symbol] : $symbol, 'line' => $this->lexer->yylineno, 'loc' => $yyloc, 'expected' => $expected, )); } // just recovered from another error if ($recovering == 3) { if ($symbol == $EOF) { throw new ParsingException($errStr ?: 'Parsing halted.'); } // discard current lookahead and grab another $yyleng = $this->lexer->yyleng; $yytext = $this->lexer->yytext; $yylineno = $this->lexer->yylineno; $yyloc = $this->lexer->yylloc; $symbol = $this->lex(); } // try to recover from error while (true) { // check for error recovery rule in this state if (array_key_exists($TERROR, $this->table[$state])) { break; } if ($state == 0) { throw new ParsingException($errStr ?: 'Parsing halted.'); } $this->popStack(1); $state = $this->stack[count($this->stack)-1]; } $preErrorSymbol = $symbol; // save the lookahead token $symbol = $TERROR; // insert generic error symbol as new lookahead $state = $this->stack[count($this->stack)-1]; $action = isset($this->table[$state][$TERROR]) ? $this->table[$state][$TERROR] : false; $recovering = 3; // allow 3 real symbols to be shifted before reporting a new error } // this shouldn't happen, unless resolve defaults are off if (is_array($action[0]) && count($action) > 1) { throw new ParsingException('Parse Error: multiple actions possible at state: ' . $state . ', token: ' . $symbol); } switch ($action[0]) { case 1: // shift $this->stack[] = $symbol; $this->vstack[] = $this->lexer->yytext; $this->lstack[] = $this->lexer->yylloc; $this->stack[] = $action[1]; // push state $symbol = null; if (!$preErrorSymbol) { // normal execution/no error $yyleng = $this->lexer->yyleng; $yytext = $this->lexer->yytext; $yylineno = $this->lexer->yylineno; $yyloc = $this->lexer->yylloc; if ($recovering > 0) { $recovering--; } } else { // error just occurred, resume old lookahead f/ before error $symbol = $preErrorSymbol; $preErrorSymbol = null; } break; case 2: // reduce $len = $this->productions_[$action[1]][1]; // perform semantic action $yyval->token = $this->vstack[count($this->vstack) - $len]; // default to $$ = $1 // default location, uses first token for firsts, last for lasts $yyval->store = array( // _$ = store 'first_line' => $this->lstack[count($this->lstack) - ($len ?: 1)]['first_line'], 'last_line' => $this->lstack[count($this->lstack) - 1]['last_line'], 'first_column' => $this->lstack[count($this->lstack) - ($len ?: 1)]['first_column'], 'last_column' => $this->lstack[count($this->lstack) - 1]['last_column'], ); $r = $this->performAction($yyval, $yytext, $yyleng, $yylineno, $action[1], $this->vstack, $this->lstack); if (!$r instanceof Undefined) { return $r; } if ($len) { $this->popStack($len); } $this->stack[] = $this->productions_[$action[1]][0]; // push nonterminal (reduce) $this->vstack[] = $yyval->token; $this->lstack[] = $yyval->store; $newState = $this->table[$this->stack[count($this->stack)-2]][$this->stack[count($this->stack)-1]]; $this->stack[] = $newState; break; case 3: // accept return true; } } return true; } protected function parseError($str, $hash) { throw new ParsingException($str, $hash); } // $$ = $tokens // needs to be passed by ref? // $ = $token // _$ removed, useless? private function performAction(stdClass $yyval, $yytext, $yyleng, $yylineno, $yystate, &$tokens) { // $0 = $len $len = count($tokens) - 1; switch ($yystate) { case 1: $yytext = preg_replace_callback('{(?:\\\\["bfnrt/\\\\]|\\\\u[a-fA-F0-9]{4})}', array($this, 'stringInterpolation'), $yytext); $yyval->token = $yytext; break; case 2: if (strpos($yytext, 'e') !== false || strpos($yytext, 'E') !== false) { $yyval->token = floatval($yytext); } else { $yyval->token = strpos($yytext, '.') === false ? intval($yytext) : floatval($yytext); } break; case 3: $yyval->token = null; break; case 4: $yyval->token = true; break; case 5: $yyval->token = false; break; case 6: return $yyval->token = $tokens[$len-1]; case 13: if ($this->flags & self::PARSE_TO_ASSOC) { $yyval->token = array(); } else { $yyval->token = new stdClass; } break; case 14: $yyval->token = $tokens[$len-1]; break; case 15: $yyval->token = array($tokens[$len-2], $tokens[$len]); break; case 16: if (PHP_VERSION_ID < 70100) { $property = $tokens[$len][0] === '' ? '_empty_' : $tokens[$len][0]; } else { $property = $tokens[$len][0]; } if ($this->flags & self::PARSE_TO_ASSOC) { $yyval->token = array(); $yyval->token[$property] = $tokens[$len][1]; } else { $yyval->token = new stdClass; $yyval->token->$property = $tokens[$len][1]; } break; case 17: if ($this->flags & self::PARSE_TO_ASSOC) { $yyval->token =& $tokens[$len-2]; $key = $tokens[$len][0]; if (($this->flags & self::DETECT_KEY_CONFLICTS) && isset($tokens[$len-2][$key])) { $errStr = 'Parse error on line ' . ($yylineno+1) . ":\n"; $errStr .= $this->lexer->showPosition() . "\n"; $errStr .= "Duplicate key: ".$tokens[$len][0]; throw new DuplicateKeyException($errStr, $tokens[$len][0], array('line' => $yylineno+1)); } elseif (($this->flags & self::ALLOW_DUPLICATE_KEYS) && isset($tokens[$len-2][$key])) { $duplicateCount = 1; do { $duplicateKey = $key . '.' . $duplicateCount++; } while (isset($tokens[$len-2][$duplicateKey])); $key = $duplicateKey; } $tokens[$len-2][$key] = $tokens[$len][1]; } else { $yyval->token = $tokens[$len-2]; if (PHP_VERSION_ID < 70100) { $key = $tokens[$len][0] === '' ? '_empty_' : $tokens[$len][0]; } else { $key = $tokens[$len][0]; } if (($this->flags & self::DETECT_KEY_CONFLICTS) && isset($tokens[$len-2]->{$key})) { $errStr = 'Parse error on line ' . ($yylineno+1) . ":\n"; $errStr .= $this->lexer->showPosition() . "\n"; $errStr .= "Duplicate key: ".$tokens[$len][0]; throw new DuplicateKeyException($errStr, $tokens[$len][0], array('line' => $yylineno+1)); } elseif (($this->flags & self::ALLOW_DUPLICATE_KEYS) && isset($tokens[$len-2]->{$key})) { $duplicateCount = 1; do { $duplicateKey = $key . '.' . $duplicateCount++; } while (isset($tokens[$len-2]->$duplicateKey)); $key = $duplicateKey; } $tokens[$len-2]->$key = $tokens[$len][1]; } break; case 18: $yyval->token = array(); break; case 19: $yyval->token = $tokens[$len-1]; break; case 20: $yyval->token = array($tokens[$len]); break; case 21: $tokens[$len-2][] = $tokens[$len]; $yyval->token = $tokens[$len-2]; break; } return new Undefined(); } private function stringInterpolation($match) { switch ($match[0]) { case '\\\\': return '\\'; case '\"': return '"'; case '\b': return chr(8); case '\f': return chr(12); case '\n': return "\n"; case '\r': return "\r"; case '\t': return "\t"; case '\/': return "/"; default: return html_entity_decode('&#x'.ltrim(substr($match[0], 2), '0').';', ENT_QUOTES, 'UTF-8'); } } private function popStack($n) { $this->stack = array_slice($this->stack, 0, - (2 * $n)); $this->vstack = array_slice($this->vstack, 0, - $n); $this->lstack = array_slice($this->lstack, 0, - $n); } private function lex() { $token = $this->lexer->lex() ?: 1; // $end = 1 // if token isn't its numeric value, convert if (!is_numeric($token)) { $token = isset($this->symbols[$token]) ? $this->symbols[$token] : $token; } return $token; } private function failOnBOM($input) { // UTF-8 ByteOrderMark sequence $bom = "\xEF\xBB\xBF"; if (substr($input, 0, 3) === $bom) { $this->parseError("BOM detected, make sure your input does not include a Unicode Byte-Order-Mark", array()); } } } jsonlint-1.7.2/src/Seld/JsonLint/Lexer.php000066400000000000000000000131451355433233300203770ustar00rootroot00000000000000 * * 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'; } } } jsonlint-1.7.2/src/Seld/JsonLint/ParsingException.php000066400000000000000000000010601355433233300225730ustar00rootroot00000000000000 * * 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; } } jsonlint-1.7.2/src/Seld/JsonLint/Undefined.php000066400000000000000000000004341355433233300212160ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace Seld\JsonLint; class Undefined { } jsonlint-1.7.2/tests/000077500000000000000000000000001355433233300145275ustar00rootroot00000000000000jsonlint-1.7.2/tests/JsonParserTest.php000066400000000000000000000162231355433233300201720ustar00rootroot00000000000000 * * 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', '""', '"\u0022"', '"Argument \u0022input\u0022 has an invalid value: ..."', '"👻"', '"\u1f47d"', ); /** * @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)); } } jsonlint-1.7.2/tests/bom.json000066400000000000000000000001331355433233300161740ustar00rootroot00000000000000{ "name": "staabm/xhprof.io", "autoload": { "classmap": ["xhprof/classes"] } }jsonlint-1.7.2/tests/bootstrap.php000066400000000000000000000005201355433233300172520ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ $loader = require __DIR__.'/../vendor/autoload.php'; $loader->add('Seld\JsonLint\Test', __DIR__);