pax_global_header00006660000000000000000000000064126207157650014525gustar00rootroot0000000000000052 comment=913401df809e99e4f47b27cdd781f4a258d58791 recursion-context-1.0.2/000077500000000000000000000000001262071576500152205ustar00rootroot00000000000000recursion-context-1.0.2/.gitignore000066400000000000000000000001611262071576500172060ustar00rootroot00000000000000.idea phpunit.xml composer.lock composer.phar vendor/ cache.properties build/LICENSE build/README.md build/*.tgz recursion-context-1.0.2/.travis.yml000066400000000000000000000004301262071576500173260ustar00rootroot00000000000000language: php php: - 5.3.3 - 5.3 - 5.4 - 5.5 - 5.6 - hhvm sudo: false before_script: - composer self-update - composer install --no-interaction --prefer-source --dev script: ./vendor/bin/phpunit notifications: email: false irc: "irc.freenode.org#phpunit" recursion-context-1.0.2/LICENSE000066400000000000000000000030201262071576500162200ustar00rootroot00000000000000Recursion Context Copyright (c) 2002-2015, 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-1.0.2/README.md000066400000000000000000000006441262071576500165030ustar00rootroot00000000000000# Recursion Context ... ## Installation To add Recursion Context as a local, per-project dependency to your project, simply add a dependency on `sebastian/recursion-context` to your project's `composer.json` file. Here is a minimal example of a `composer.json` file that just defines a dependency on Recursion Context 1.0: { "require": { "sebastian/recursion-context": "~1.0" } } recursion-context-1.0.2/build.xml000066400000000000000000000014631262071576500170450ustar00rootroot00000000000000 recursion-context-1.0.2/composer.json000066400000000000000000000015141262071576500177430ustar00rootroot00000000000000{ "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": ">=5.3.3" }, "require-dev": { "phpunit/phpunit": "~4.4" }, "autoload": { "classmap": [ "src/" ] }, "extra": { "branch-alias": { "dev-master": "1.0.x-dev" } } } recursion-context-1.0.2/phpunit.xml.dist000066400000000000000000000012251262071576500203730ustar00rootroot00000000000000 tests src recursion-context-1.0.2/src/000077500000000000000000000000001262071576500160075ustar00rootroot00000000000000recursion-context-1.0.2/src/Context.php000066400000000000000000000072451262071576500201540ustar00rootroot00000000000000 * * 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); } else if (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); } else if (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; } $this->arrays[] = &$array; return count($this->arrays) - 1; } /** * @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) { $keys = array_keys($this->arrays, $array, true); $hash = '_Key_' . microtime(true); foreach ($keys as $key) { $this->arrays[$key][$hash] = $hash; if (isset($array[$hash]) && $array[$hash] === $hash) { unset($this->arrays[$key][$hash]); return $key; } unset($this->arrays[$key][$hash]); } return false; } /** * @param object $value * @return string|false */ private function containsObject($value) { if ($this->objects->contains($value)) { return spl_object_hash($value); } return false; } } recursion-context-1.0.2/src/Exception.php000066400000000000000000000005121262071576500204540ustar00rootroot00000000000000 * * 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-1.0.2/src/InvalidArgumentException.php000066400000000000000000000006221262071576500234700ustar00rootroot00000000000000 * * 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-1.0.2/tests/000077500000000000000000000000001262071576500163625ustar00rootroot00000000000000recursion-context-1.0.2/tests/ContextTest.php000066400000000000000000000100531262071576500213560ustar00rootroot00000000000000 * * 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 PHPUnit_Framework_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->setExpectedException( 'SebastianBergmann\\RecursionContext\\Exception', '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->setExpectedException( 'SebastianBergmann\\RecursionContext\\Exception', '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)); } }