pax_global_header00006660000000000000000000000064130562057750014524gustar00rootroot0000000000000052 comment=5b0cd723502bac3b006cbf3dbf7a1e3fcefe4fa8 recursion-context-3.0.0/000077500000000000000000000000001305620577500152175ustar00rootroot00000000000000recursion-context-3.0.0/.gitignore000066400000000000000000000000361305620577500172060ustar00rootroot00000000000000/.idea /composer.lock /vendor recursion-context-3.0.0/.travis.yml000066400000000000000000000005471305620577500173360ustar00rootroot00000000000000language: php php: - 7.0 - 7.0snapshot - 7.1 - 7.1snapshot - master sudo: false before_install: - composer self-update - composer clear-cache install: - travis_retry composer update --no-interaction --no-ansi --no-progress --no-suggest --optimize-autoloader --prefer-stable script: - ./vendor/bin/phpunit notifications: email: false recursion-context-3.0.0/LICENSE000066400000000000000000000030201305620577500162170ustar00rootroot00000000000000Recursion Context Copyright (c) 2002-2017, Sebastian Bergmann . All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of Sebastian Bergmann nor the names of his contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. recursion-context-3.0.0/README.md000066400000000000000000000006511305620577500165000ustar00rootroot00000000000000# Recursion Context ... ## Installation You can add this library as a local, per-project dependency to your project using [Composer](https://getcomposer.org/): composer require sebastian/recursion-context If you only need this library during development, for instance to run your project's test suite, then you should add it as a development-time dependency: composer require --dev sebastian/recursion-context recursion-context-3.0.0/build.xml000066400000000000000000000012641305620577500170430ustar00rootroot00000000000000 recursion-context-3.0.0/composer.json000066400000000000000000000015111305620577500177370ustar00rootroot00000000000000{ "name": "sebastian/recursion-context", "description": "Provides functionality to recursively process PHP variables", "homepage": "http://www.github.com/sebastianbergmann/recursion-context", "license": "BSD-3-Clause", "authors": [ { "name": "Sebastian Bergmann", "email": "sebastian@phpunit.de" }, { "name": "Jeff Welch", "email": "whatthejeff@gmail.com" }, { "name": "Adam Harvey", "email": "aharvey@php.net" } ], "require": { "php": "^7.0" }, "require-dev": { "phpunit/phpunit": "^6.0" }, "autoload": { "classmap": [ "src/" ] }, "extra": { "branch-alias": { "dev-master": "3.0.x-dev" } } } recursion-context-3.0.0/phpunit.xml000066400000000000000000000012651305620577500174340ustar00rootroot00000000000000 tests src recursion-context-3.0.0/src/000077500000000000000000000000001305620577500160065ustar00rootroot00000000000000recursion-context-3.0.0/src/Context.php000066400000000000000000000075731305620577500201570ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\RecursionContext; /** * A context containing previously processed arrays and objects * when recursively processing a value. */ final class Context { /** * @var array[] */ private $arrays; /** * @var \SplObjectStorage */ private $objects; /** * Initialises the context */ public function __construct() { $this->arrays = array(); $this->objects = new \SplObjectStorage; } /** * Adds a value to the context. * * @param array|object $value The value to add. * * @return int|string The ID of the stored value, either as a string or integer. * * @throws InvalidArgumentException Thrown if $value is not an array or object */ public function add(&$value) { if (is_array($value)) { return $this->addArray($value); } elseif (is_object($value)) { return $this->addObject($value); } throw new InvalidArgumentException( 'Only arrays and objects are supported' ); } /** * Checks if the given value exists within the context. * * @param array|object $value The value to check. * * @return int|string|false The string or integer ID of the stored value if it has already been seen, or false if the value is not stored. * * @throws InvalidArgumentException Thrown if $value is not an array or object */ public function contains(&$value) { if (is_array($value)) { return $this->containsArray($value); } elseif (is_object($value)) { return $this->containsObject($value); } throw new InvalidArgumentException( 'Only arrays and objects are supported' ); } /** * @param array $array * * @return bool|int */ private function addArray(array &$array) { $key = $this->containsArray($array); if ($key !== false) { return $key; } $key = count($this->arrays); $this->arrays[] = &$array; if (!isset($array[PHP_INT_MAX]) && !isset($array[PHP_INT_MAX - 1])) { $array[] = $key; $array[] = $this->objects; } else { /* cover the improbable case too */ do { $key = random_int(PHP_INT_MIN, PHP_INT_MAX); } while (isset($array[$key])); $array[$key] = $key; do { $key = random_int(PHP_INT_MIN, PHP_INT_MAX); } while (isset($array[$key])); $array[$key] = $this->objects; } return $key; } /** * @param object $object * * @return string */ private function addObject($object) { if (!$this->objects->contains($object)) { $this->objects->attach($object); } return spl_object_hash($object); } /** * @param array $array * * @return int|false */ private function containsArray(array &$array) { $end = array_slice($array, -2); return isset($end[1]) && $end[1] === $this->objects ? $end[0] : false; } /** * @param object $value * * @return string|false */ private function containsObject($value) { if ($this->objects->contains($value)) { return spl_object_hash($value); } return false; } public function __destruct() { foreach ($this->arrays as &$array) { if (is_array($array)) { array_pop($array); array_pop($array); } } } } recursion-context-3.0.0/src/Exception.php000066400000000000000000000005121305620577500204530ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\RecursionContext; /** */ interface Exception { } recursion-context-3.0.0/src/InvalidArgumentException.php000066400000000000000000000006221305620577500234670ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\RecursionContext; /** */ final class InvalidArgumentException extends \InvalidArgumentException implements Exception { } recursion-context-3.0.0/tests/000077500000000000000000000000001305620577500163615ustar00rootroot00000000000000recursion-context-3.0.0/tests/ContextTest.php000066400000000000000000000100351305620577500213550ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace SebastianBergmann\RecursionContext; use PHPUnit\Framework\TestCase; /** * @covers SebastianBergmann\RecursionContext\Context */ class ContextTest extends TestCase { /** * @var \SebastianBergmann\RecursionContext\Context */ private $context; protected function setUp() { $this->context = new Context(); } public function failsProvider() { return array( array(true), array(false), array(null), array('string'), array(1), array(1.5), array(fopen('php://memory', 'r')) ); } public function valuesProvider() { $obj2 = new \stdClass(); $obj2->foo = 'bar'; $obj3 = (object) array(1,2,"Test\r\n",4,5,6,7,8); $obj = new \stdClass(); //@codingStandardsIgnoreStart $obj->null = null; //@codingStandardsIgnoreEnd $obj->boolean = true; $obj->integer = 1; $obj->double = 1.2; $obj->string = '1'; $obj->text = "this\nis\na\nvery\nvery\nvery\nvery\nvery\nvery\rlong\n\rtext"; $obj->object = $obj2; $obj->objectagain = $obj2; $obj->array = array('foo' => 'bar'); $obj->array2 = array(1,2,3,4,5,6); $obj->array3 = array($obj, $obj2, $obj3); $obj->self = $obj; $storage = new \SplObjectStorage(); $storage->attach($obj2); $storage->foo = $obj2; return array( array($obj, spl_object_hash($obj)), array($obj2, spl_object_hash($obj2)), array($obj3, spl_object_hash($obj3)), array($storage, spl_object_hash($storage)), array($obj->array, 0), array($obj->array2, 0), array($obj->array3, 0) ); } /** * @covers SebastianBergmann\RecursionContext\Context::add * @uses SebastianBergmann\RecursionContext\InvalidArgumentException * @dataProvider failsProvider */ public function testAddFails($value) { $this->expectException(Exception::class); $this->expectExceptionMessage('Only arrays and objects are supported'); $this->context->add($value); } /** * @covers SebastianBergmann\RecursionContext\Context::contains * @uses SebastianBergmann\RecursionContext\InvalidArgumentException * @dataProvider failsProvider */ public function testContainsFails($value) { $this->expectException(Exception::class); $this->expectExceptionMessage('Only arrays and objects are supported'); $this->context->contains($value); } /** * @covers SebastianBergmann\RecursionContext\Context::add * @dataProvider valuesProvider */ public function testAdd($value, $key) { $this->assertEquals($key, $this->context->add($value)); // Test we get the same key on subsequent adds $this->assertEquals($key, $this->context->add($value)); } /** * @covers SebastianBergmann\RecursionContext\Context::contains * @uses SebastianBergmann\RecursionContext\Context::add * @depends testAdd * @dataProvider valuesProvider */ public function testContainsFound($value, $key) { $this->context->add($value); $this->assertEquals($key, $this->context->contains($value)); // Test we get the same key on subsequent calls $this->assertEquals($key, $this->context->contains($value)); } /** * @covers SebastianBergmann\RecursionContext\Context::contains * @dataProvider valuesProvider */ public function testContainsNotFound($value) { $this->assertFalse($this->context->contains($value)); } }