diff --git a/README.md b/README.md index 7c78457..10819b6 100644 --- a/README.md +++ b/README.md @@ -32,13 +32,11 @@ echo Respect\Stringifier\stringify($value); ### Using as an object ```php -$stringify = Respect\Stringifier\Stringify::createDefault(); +use Respect\Stringifier\HandlerStringifier; -// with the `value` method -echo $stringify->value($value); +$stringifier = HandlerStringifier::create(); -// with the `__invoke` method -echo $stringify($value); +echo $stringifier->stringify($value); ``` ### Examples diff --git a/phpcs.xml.dist b/phpcs.xml.dist index 0ead2f2..7bb74ac 100644 --- a/phpcs.xml.dist +++ b/phpcs.xml.dist @@ -18,7 +18,7 @@ tests/fixtures/ - tests/unit/Stringifiers/CallableStringifierTest.php + tests/unit/Handlers/CallableHandlerTest.php tests/integration/lib/helpers.php @@ -34,6 +34,6 @@ tests/integration - tests/unit/Stringifiers/CallableStringifierTest.php + tests/unit/Handlers/CallableHandlerTest.php diff --git a/src/DumpStringifier.php b/src/DumpStringifier.php new file mode 100644 index 0000000..95d4e48 --- /dev/null +++ b/src/DumpStringifier.php @@ -0,0 +1,21 @@ + + * SPDX-License-Identifier: MIT + */ + +declare(strict_types=1); + +namespace Respect\Stringifier; + +use function print_r; + +final class DumpStringifier implements Stringifier +{ + public function stringify(mixed $raw): string + { + return print_r($raw, true); + } +} diff --git a/src/Handler.php b/src/Handler.php new file mode 100644 index 0000000..2308f19 --- /dev/null +++ b/src/Handler.php @@ -0,0 +1,21 @@ + + * SPDX-License-Identifier: MIT + */ + +declare(strict_types=1); + +namespace Respect\Stringifier; + +interface Handler +{ + /** + * Attempts to stringify the given value. + * + * @return string|null The stringified value, or null if this handler cannot handle the type + */ + public function handle(mixed $raw, int $depth): string|null; +} diff --git a/src/HandlerStringifier.php b/src/HandlerStringifier.php new file mode 100644 index 0000000..f12faba --- /dev/null +++ b/src/HandlerStringifier.php @@ -0,0 +1,32 @@ + + * SPDX-License-Identifier: MIT + */ + +declare(strict_types=1); + +namespace Respect\Stringifier; + +use Respect\Stringifier\Handlers\CompositeHandler; + +final class HandlerStringifier implements Stringifier +{ + public function __construct( + private readonly Handler $handler, + private readonly Stringifier $fallback, + ) { + } + + public static function create(): self + { + return new self(CompositeHandler::create(), new DumpStringifier()); + } + + public function stringify(mixed $raw): string + { + return $this->handler->handle($raw, 0) ?? $this->fallback->stringify($raw); + } +} diff --git a/src/Stringifiers/ArrayStringifier.php b/src/Handlers/ArrayHandler.php similarity index 78% rename from src/Stringifiers/ArrayStringifier.php rename to src/Handlers/ArrayHandler.php index 9c85f52..b9ae54d 100644 --- a/src/Stringifiers/ArrayStringifier.php +++ b/src/Handlers/ArrayHandler.php @@ -8,10 +8,10 @@ declare(strict_types=1); -namespace Respect\Stringifier\Stringifiers; +namespace Respect\Stringifier\Handlers; +use Respect\Stringifier\Handler; use Respect\Stringifier\Quoter; -use Respect\Stringifier\Stringifier; use function array_keys; use function count; @@ -20,19 +20,19 @@ use function range; use function sprintf; -final class ArrayStringifier implements Stringifier +final class ArrayHandler implements Handler { private const string LIMIT_EXCEEDED_PLACEHOLDER = '...'; public function __construct( - private readonly Stringifier $stringifier, + private readonly Handler $handler, private readonly Quoter $quoter, private readonly int $maximumDepth, private readonly int $maximumNumberOfItems, ) { } - public function stringify(mixed $raw, int $depth): string|null + public function handle(mixed $raw, int $depth): string|null { if (!is_array($raw)) { return null; @@ -60,7 +60,7 @@ public function stringify(mixed $raw, int $depth): string|null continue; } - $items[] = sprintf('%s: %s', $this->stringifier->stringify($key, $depth + 1), $stringifiedValue); + $items[] = sprintf('%s: %s', $this->handler->handle($key, $depth + 1), $stringifiedValue); } return $this->quoter->quote(sprintf('[%s]', implode(', ', $items)), $depth); @@ -69,10 +69,10 @@ public function stringify(mixed $raw, int $depth): string|null private function stringifyKeyValue(mixed $value, int $depth): string|null { if (is_array($value)) { - return $this->stringify($value, $depth); + return $this->handle($value, $depth); } - return $this->stringifier->stringify($value, $depth); + return $this->handler->handle($value, $depth); } /** @param mixed[] $array */ diff --git a/src/Stringifiers/ArrayObjectStringifier.php b/src/Handlers/ArrayObjectHandler.php similarity index 59% rename from src/Stringifiers/ArrayObjectStringifier.php rename to src/Handlers/ArrayObjectHandler.php index bfec6bd..1e57225 100644 --- a/src/Stringifiers/ArrayObjectStringifier.php +++ b/src/Handlers/ArrayObjectHandler.php @@ -8,31 +8,31 @@ declare(strict_types=1); -namespace Respect\Stringifier\Stringifiers; +namespace Respect\Stringifier\Handlers; use ArrayObject; +use Respect\Stringifier\Handler; use Respect\Stringifier\Helpers\ObjectHelper; use Respect\Stringifier\Quoter; -use Respect\Stringifier\Stringifier; -final class ArrayObjectStringifier implements Stringifier +final class ArrayObjectHandler implements Handler { use ObjectHelper; public function __construct( - private readonly Stringifier $stringifier, + private readonly Handler $handler, private readonly Quoter $quoter, ) { } - public function stringify(mixed $raw, int $depth): string|null + public function handle(mixed $raw, int $depth): string|null { if (!$raw instanceof ArrayObject) { return null; } return $this->quoter->quote( - $this->format($raw, 'getArrayCopy() =>', $this->stringifier->stringify($raw->getArrayCopy(), $depth + 1)), + $this->format($raw, 'getArrayCopy() =>', $this->handler->handle($raw->getArrayCopy(), $depth + 1)), $depth, ); } diff --git a/src/Stringifiers/BoolStringifier.php b/src/Handlers/BoolHandler.php similarity index 70% rename from src/Stringifiers/BoolStringifier.php rename to src/Handlers/BoolHandler.php index 323920d..773377b 100644 --- a/src/Stringifiers/BoolStringifier.php +++ b/src/Handlers/BoolHandler.php @@ -8,21 +8,21 @@ declare(strict_types=1); -namespace Respect\Stringifier\Stringifiers; +namespace Respect\Stringifier\Handlers; +use Respect\Stringifier\Handler; use Respect\Stringifier\Quoter; -use Respect\Stringifier\Stringifier; use function is_bool; -final class BoolStringifier implements Stringifier +final class BoolHandler implements Handler { public function __construct( private readonly Quoter $quoter, ) { } - public function stringify(mixed $raw, int $depth): string|null + public function handle(mixed $raw, int $depth): string|null { if (!is_bool($raw)) { return null; diff --git a/src/Stringifiers/CallableStringifier.php b/src/Handlers/CallableHandler.php similarity index 93% rename from src/Stringifiers/CallableStringifier.php rename to src/Handlers/CallableHandler.php index 2725abc..5787936 100644 --- a/src/Stringifiers/CallableStringifier.php +++ b/src/Handlers/CallableHandler.php @@ -8,7 +8,7 @@ declare(strict_types=1); -namespace Respect\Stringifier\Stringifiers; +namespace Respect\Stringifier\Handlers; use Closure; use ReflectionFunction; @@ -19,9 +19,9 @@ use ReflectionParameter; use ReflectionType; use ReflectionUnionType; +use Respect\Stringifier\Handler; use Respect\Stringifier\Helpers\ObjectHelper; use Respect\Stringifier\Quoter; -use Respect\Stringifier\Stringifier; use function array_keys; use function array_map; @@ -37,18 +37,18 @@ use function strstr; use function substr; -final class CallableStringifier implements Stringifier +final class CallableHandler implements Handler { use ObjectHelper; public function __construct( - private readonly Stringifier $stringifier, + private readonly Handler $handler, private readonly Quoter $quoter, private readonly bool $closureOnly = true, ) { } - public function stringify(mixed $raw, int $depth): string|null + public function handle(mixed $raw, int $depth): string|null { if ($raw instanceof Closure) { return $this->buildFunction(new ReflectionFunction($raw), $depth); @@ -170,14 +170,14 @@ private function buildParameter(ReflectionParameter $reflectionParameter, int $d private function buildValue(ReflectionParameter $reflectionParameter, int $depth): string|null { if (!$reflectionParameter->isDefaultValueAvailable()) { - return $this->stringifier->stringify(null, $depth); + return $this->handler->handle(null, $depth); } if ($reflectionParameter->isDefaultValueConstant()) { return $reflectionParameter->getDefaultValueConstantName(); } - return $this->stringifier->stringify($reflectionParameter->getDefaultValue(), $depth); + return $this->handler->handle($reflectionParameter->getDefaultValue(), $depth); } private function buildType(ReflectionType $raw, int $depth): string diff --git a/src/Handlers/CompositeHandler.php b/src/Handlers/CompositeHandler.php new file mode 100644 index 0000000..f0ef261 --- /dev/null +++ b/src/Handlers/CompositeHandler.php @@ -0,0 +1,97 @@ + + * SPDX-License-Identifier: MIT + */ + +declare(strict_types=1); + +namespace Respect\Stringifier\Handlers; + +use DateTimeInterface; +use Respect\Stringifier\Handler; +use Respect\Stringifier\Quoters\StandardQuoter; + +use function array_unshift; + +final class CompositeHandler implements Handler +{ + private const int MAXIMUM_DEPTH = 3; + private const int MAXIMUM_NUMBER_OF_ITEMS = 5; + private const int MAXIMUM_NUMBER_OF_PROPERTIES = self::MAXIMUM_NUMBER_OF_ITEMS; + private const int MAXIMUM_LENGTH = 120; + + /** @var array */ + private array $handlers = []; + + public function __construct(Handler ...$handlers) + { + $this->handlers = $handlers; + } + + public static function create(): self + { + $quoter = new StandardQuoter(self::MAXIMUM_LENGTH); + + $handler = new self( + new InfiniteNumberHandler($quoter), + new NotANumberHandler($quoter), + new ResourceHandler($quoter), + new BoolHandler($quoter), + new NullHandler($quoter), + new DeclaredHandler($quoter), + $jsonEncodableHandler = new JsonEncodableHandler(), + ); + $handler->prependHandler( + $arrayHandler = new ArrayHandler( + $handler, + $quoter, + self::MAXIMUM_DEPTH, + self::MAXIMUM_NUMBER_OF_ITEMS, + ), + ); + $handler->prependHandler( + new ObjectHandler( + $handler, + $quoter, + self::MAXIMUM_DEPTH, + self::MAXIMUM_NUMBER_OF_PROPERTIES, + ), + ); + $handler->prependHandler(new CallableHandler($handler, $quoter)); + $handler->prependHandler( + new FiberObjectHandler(new CallableHandler($handler, $quoter, closureOnly: false), $quoter), + ); + $handler->prependHandler(new EnumerationHandler($quoter)); + $handler->prependHandler(new ObjectWithDebugInfoHandler($arrayHandler, $quoter)); + $handler->prependHandler(new ArrayObjectHandler($arrayHandler, $quoter)); + $handler->prependHandler(new JsonSerializableObjectHandler($jsonEncodableHandler, $quoter)); + $handler->prependHandler(new StringableObjectHandler($jsonEncodableHandler, $quoter)); + $handler->prependHandler(new ThrowableObjectHandler($jsonEncodableHandler, $quoter)); + $handler->prependHandler(new DateTimeHandler($quoter, DateTimeInterface::ATOM)); + $handler->prependHandler(new IteratorObjectHandler($handler, $quoter)); + + return $handler; + } + + public function prependHandler(Handler $handler): void + { + array_unshift($this->handlers, $handler); + } + + public function handle(mixed $raw, int $depth): string|null + { + foreach ($this->handlers as $handler) { + $string = $handler->handle($raw, $depth); + if ($string === null) { + continue; + } + + return $string; + } + + return null; + } +} diff --git a/src/Stringifiers/DateTimeStringifier.php b/src/Handlers/DateTimeHandler.php similarity index 75% rename from src/Stringifiers/DateTimeStringifier.php rename to src/Handlers/DateTimeHandler.php index 926d088..370c0f2 100644 --- a/src/Stringifiers/DateTimeStringifier.php +++ b/src/Handlers/DateTimeHandler.php @@ -8,14 +8,14 @@ declare(strict_types=1); -namespace Respect\Stringifier\Stringifiers; +namespace Respect\Stringifier\Handlers; use DateTimeInterface; +use Respect\Stringifier\Handler; use Respect\Stringifier\Helpers\ObjectHelper; use Respect\Stringifier\Quoter; -use Respect\Stringifier\Stringifier; -final class DateTimeStringifier implements Stringifier +final class DateTimeHandler implements Handler { use ObjectHelper; @@ -25,7 +25,7 @@ public function __construct( ) { } - public function stringify(mixed $raw, int $depth): string|null + public function handle(mixed $raw, int $depth): string|null { if (!$raw instanceof DateTimeInterface) { return null; diff --git a/src/Stringifiers/DeclaredStringifier.php b/src/Handlers/DeclaredHandler.php similarity index 79% rename from src/Stringifiers/DeclaredStringifier.php rename to src/Handlers/DeclaredHandler.php index 39b59c9..d88720d 100644 --- a/src/Stringifiers/DeclaredStringifier.php +++ b/src/Handlers/DeclaredHandler.php @@ -8,10 +8,10 @@ declare(strict_types=1); -namespace Respect\Stringifier\Stringifiers; +namespace Respect\Stringifier\Handlers; +use Respect\Stringifier\Handler; use Respect\Stringifier\Quoter; -use Respect\Stringifier\Stringifier; use function class_exists; use function enum_exists; @@ -19,14 +19,14 @@ use function is_string; use function trait_exists; -final class DeclaredStringifier implements Stringifier +final class DeclaredHandler implements Handler { public function __construct( private readonly Quoter $quoter, ) { } - public function stringify(mixed $raw, int $depth): string|null + public function handle(mixed $raw, int $depth): string|null { if (!is_string($raw) || $this->isNotDeclared($raw)) { return null; diff --git a/src/Stringifiers/EnumerationStringifier.php b/src/Handlers/EnumerationHandler.php similarity index 71% rename from src/Stringifiers/EnumerationStringifier.php rename to src/Handlers/EnumerationHandler.php index f56c63a..0a2cdc0 100644 --- a/src/Stringifiers/EnumerationStringifier.php +++ b/src/Handlers/EnumerationHandler.php @@ -8,22 +8,22 @@ declare(strict_types=1); -namespace Respect\Stringifier\Stringifiers; +namespace Respect\Stringifier\Handlers; +use Respect\Stringifier\Handler; use Respect\Stringifier\Quoter; -use Respect\Stringifier\Stringifier; use UnitEnum; use function sprintf; -final class EnumerationStringifier implements Stringifier +final class EnumerationHandler implements Handler { public function __construct( private readonly Quoter $quoter, ) { } - public function stringify(mixed $raw, int $depth): string|null + public function handle(mixed $raw, int $depth): string|null { if (!$raw instanceof UnitEnum) { return null; diff --git a/src/Stringifiers/FiberObjectStringifier.php b/src/Handlers/FiberObjectHandler.php similarity index 61% rename from src/Stringifiers/FiberObjectStringifier.php rename to src/Handlers/FiberObjectHandler.php index 353396d..241ca4a 100644 --- a/src/Stringifiers/FiberObjectStringifier.php +++ b/src/Handlers/FiberObjectHandler.php @@ -8,24 +8,24 @@ declare(strict_types=1); -namespace Respect\Stringifier\Stringifiers; +namespace Respect\Stringifier\Handlers; use Fiber; use ReflectionFiber; +use Respect\Stringifier\Handler; use Respect\Stringifier\Quoter; -use Respect\Stringifier\Stringifier; use function sprintf; -final class FiberObjectStringifier implements Stringifier +final class FiberObjectHandler implements Handler { public function __construct( - private readonly Stringifier $stringifier, + private readonly Handler $handler, private readonly Quoter $quoter, ) { } - public function stringify(mixed $raw, int $depth): string|null + public function handle(mixed $raw, int $depth): string|null { if (!$raw instanceof Fiber) { return null; @@ -34,7 +34,7 @@ public function stringify(mixed $raw, int $depth): string|null return $this->quoter->quote( sprintf( 'Fiber { %s }', - $this->stringifier->stringify((new ReflectionFiber($raw))->getCallable(), $depth + 1), + $this->handler->handle((new ReflectionFiber($raw))->getCallable(), $depth + 1), ), $depth, ); diff --git a/src/Stringifiers/InfiniteNumberStringifier.php b/src/Handlers/InfiniteNumberHandler.php similarity index 73% rename from src/Stringifiers/InfiniteNumberStringifier.php rename to src/Handlers/InfiniteNumberHandler.php index 39ec918..38059a4 100644 --- a/src/Stringifiers/InfiniteNumberStringifier.php +++ b/src/Handlers/InfiniteNumberHandler.php @@ -8,22 +8,22 @@ declare(strict_types=1); -namespace Respect\Stringifier\Stringifiers; +namespace Respect\Stringifier\Handlers; +use Respect\Stringifier\Handler; use Respect\Stringifier\Quoter; -use Respect\Stringifier\Stringifier; use function is_float; use function is_infinite; -final class InfiniteNumberStringifier implements Stringifier +final class InfiniteNumberHandler implements Handler { public function __construct( private readonly Quoter $quoter, ) { } - public function stringify(mixed $raw, int $depth): string|null + public function handle(mixed $raw, int $depth): string|null { if (!is_float($raw)) { return null; diff --git a/src/Stringifiers/IteratorObjectStringifier.php b/src/Handlers/IteratorObjectHandler.php similarity index 62% rename from src/Stringifiers/IteratorObjectStringifier.php rename to src/Handlers/IteratorObjectHandler.php index de578af..7eee7b4 100644 --- a/src/Stringifiers/IteratorObjectStringifier.php +++ b/src/Handlers/IteratorObjectHandler.php @@ -8,24 +8,24 @@ declare(strict_types=1); -namespace Respect\Stringifier\Stringifiers; +namespace Respect\Stringifier\Handlers; use Iterator; +use Respect\Stringifier\Handler; use Respect\Stringifier\Helpers\ObjectHelper; use Respect\Stringifier\Quoter; -use Respect\Stringifier\Stringifier; -final class IteratorObjectStringifier implements Stringifier +final class IteratorObjectHandler implements Handler { use ObjectHelper; public function __construct( - private readonly Stringifier $stringifier, + private readonly Handler $handler, private readonly Quoter $quoter, ) { } - public function stringify(mixed $raw, int $depth): string|null + public function handle(mixed $raw, int $depth): string|null { if (!$raw instanceof Iterator) { return null; @@ -36,7 +36,7 @@ public function stringify(mixed $raw, int $depth): string|null } return $this->quoter->quote( - $this->format($raw, 'current() =>', $this->stringifier->stringify($raw->current(), $depth + 1)), + $this->format($raw, 'current() =>', $this->handler->handle($raw->current(), $depth + 1)), $depth, ); } diff --git a/src/Stringifiers/JsonEncodableStringifier.php b/src/Handlers/JsonEncodableHandler.php similarity index 72% rename from src/Stringifiers/JsonEncodableStringifier.php rename to src/Handlers/JsonEncodableHandler.php index 36e5c77..eb0ee09 100644 --- a/src/Stringifiers/JsonEncodableStringifier.php +++ b/src/Handlers/JsonEncodableHandler.php @@ -8,9 +8,9 @@ declare(strict_types=1); -namespace Respect\Stringifier\Stringifiers; +namespace Respect\Stringifier\Handlers; -use Respect\Stringifier\Stringifier; +use Respect\Stringifier\Handler; use function json_encode; @@ -18,9 +18,9 @@ use const JSON_UNESCAPED_SLASHES; use const JSON_UNESCAPED_UNICODE; -final class JsonEncodableStringifier implements Stringifier +final class JsonEncodableHandler implements Handler { - public function stringify(mixed $raw, int $depth): string|null + public function handle(mixed $raw, int $depth): string|null { $string = json_encode($raw, (JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES | JSON_PRESERVE_ZERO_FRACTION)); if ($string === false) { diff --git a/src/Stringifiers/JsonSerializableObjectStringifier.php b/src/Handlers/JsonSerializableObjectHandler.php similarity index 58% rename from src/Stringifiers/JsonSerializableObjectStringifier.php rename to src/Handlers/JsonSerializableObjectHandler.php index a20eced..50f1efb 100644 --- a/src/Stringifiers/JsonSerializableObjectStringifier.php +++ b/src/Handlers/JsonSerializableObjectHandler.php @@ -8,31 +8,31 @@ declare(strict_types=1); -namespace Respect\Stringifier\Stringifiers; +namespace Respect\Stringifier\Handlers; use JsonSerializable; +use Respect\Stringifier\Handler; use Respect\Stringifier\Helpers\ObjectHelper; use Respect\Stringifier\Quoter; -use Respect\Stringifier\Stringifier; -final class JsonSerializableObjectStringifier implements Stringifier +final class JsonSerializableObjectHandler implements Handler { use ObjectHelper; public function __construct( - private readonly Stringifier $stringifier, + private readonly Handler $handler, private readonly Quoter $quoter, ) { } - public function stringify(mixed $raw, int $depth): string|null + public function handle(mixed $raw, int $depth): string|null { if (!$raw instanceof JsonSerializable) { return null; } return $this->quoter->quote( - $this->format($raw, 'jsonSerialize() =>', $this->stringifier->stringify($raw->jsonSerialize(), $depth + 1)), + $this->format($raw, 'jsonSerialize() =>', $this->handler->handle($raw->jsonSerialize(), $depth + 1)), $depth, ); } diff --git a/src/Stringifiers/NotANumberStringifier.php b/src/Handlers/NotANumberHandler.php similarity index 72% rename from src/Stringifiers/NotANumberStringifier.php rename to src/Handlers/NotANumberHandler.php index 63d1f52..ad1cd26 100644 --- a/src/Stringifiers/NotANumberStringifier.php +++ b/src/Handlers/NotANumberHandler.php @@ -8,22 +8,22 @@ declare(strict_types=1); -namespace Respect\Stringifier\Stringifiers; +namespace Respect\Stringifier\Handlers; +use Respect\Stringifier\Handler; use Respect\Stringifier\Quoter; -use Respect\Stringifier\Stringifier; use function is_float; use function is_nan; -final class NotANumberStringifier implements Stringifier +final class NotANumberHandler implements Handler { public function __construct( private readonly Quoter $quoter, ) { } - public function stringify(mixed $raw, int $depth): string|null + public function handle(mixed $raw, int $depth): string|null { if (!is_float($raw)) { return null; diff --git a/src/Stringifiers/NullStringifier.php b/src/Handlers/NullHandler.php similarity index 68% rename from src/Stringifiers/NullStringifier.php rename to src/Handlers/NullHandler.php index a110e34..b6370f5 100644 --- a/src/Stringifiers/NullStringifier.php +++ b/src/Handlers/NullHandler.php @@ -8,19 +8,19 @@ declare(strict_types=1); -namespace Respect\Stringifier\Stringifiers; +namespace Respect\Stringifier\Handlers; +use Respect\Stringifier\Handler; use Respect\Stringifier\Quoter; -use Respect\Stringifier\Stringifier; -final class NullStringifier implements Stringifier +final class NullHandler implements Handler { public function __construct( private readonly Quoter $quoter, ) { } - public function stringify(mixed $raw, int $depth): string|null + public function handle(mixed $raw, int $depth): string|null { if ($raw !== null) { return null; diff --git a/src/Stringifiers/ObjectStringifier.php b/src/Handlers/ObjectHandler.php similarity index 88% rename from src/Stringifiers/ObjectStringifier.php rename to src/Handlers/ObjectHandler.php index 50d9dc8..3d34822 100644 --- a/src/Stringifiers/ObjectStringifier.php +++ b/src/Handlers/ObjectHandler.php @@ -8,34 +8,34 @@ declare(strict_types=1); -namespace Respect\Stringifier\Stringifiers; +namespace Respect\Stringifier\Handlers; use ReflectionObject; use ReflectionProperty; +use Respect\Stringifier\Handler; use Respect\Stringifier\Helpers\ObjectHelper; use Respect\Stringifier\Quoter; -use Respect\Stringifier\Stringifier; use function count; use function is_object; use function sprintf; use function trim; -final class ObjectStringifier implements Stringifier +final class ObjectHandler implements Handler { use ObjectHelper; private const string LIMIT_EXCEEDED_PLACEHOLDER = '...'; public function __construct( - private readonly Stringifier $stringifier, + private readonly Handler $handler, private readonly Quoter $quoter, private readonly int $maximumDepth, private readonly int $maximumNumberOfProperties, ) { } - public function stringify(mixed $raw, int $depth): string|null + public function handle(mixed $raw, int $depth): string|null { if (!is_object($raw)) { return null; @@ -97,9 +97,9 @@ private function getPropertyValue(ReflectionProperty $reflectionProperty, object $value = $reflectionProperty->getValue($object); if (is_object($value)) { - return $this->stringify($value, $depth); + return $this->handle($value, $depth); } - return $this->stringifier->stringify($value, $depth); + return $this->handler->handle($value, $depth); } } diff --git a/src/Stringifiers/ObjectWithDebugInfoStringifier.php b/src/Handlers/ObjectWithDebugInfoHandler.php similarity index 61% rename from src/Stringifiers/ObjectWithDebugInfoStringifier.php rename to src/Handlers/ObjectWithDebugInfoHandler.php index f1cca8a..09224db 100644 --- a/src/Stringifiers/ObjectWithDebugInfoStringifier.php +++ b/src/Handlers/ObjectWithDebugInfoHandler.php @@ -8,33 +8,33 @@ declare(strict_types=1); -namespace Respect\Stringifier\Stringifiers; +namespace Respect\Stringifier\Handlers; +use Respect\Stringifier\Handler; use Respect\Stringifier\Helpers\ObjectHelper; use Respect\Stringifier\Quoter; -use Respect\Stringifier\Stringifier; use function is_object; use function method_exists; -final class ObjectWithDebugInfoStringifier implements Stringifier +final class ObjectWithDebugInfoHandler implements Handler { use ObjectHelper; public function __construct( - private readonly Stringifier $stringifier, + private readonly Handler $handler, private readonly Quoter $quoter, ) { } - public function stringify(mixed $raw, int $depth): string|null + public function handle(mixed $raw, int $depth): string|null { if (!(is_object($raw) && method_exists($raw, '__debugInfo'))) { return null; } return $this->quoter->quote( - $this->format($raw, '__debugInfo() =>', $this->stringifier->stringify($raw->__debugInfo(), $depth + 1)), + $this->format($raw, '__debugInfo() =>', $this->handler->handle($raw->__debugInfo(), $depth + 1)), $depth, ); } diff --git a/src/Stringifiers/ResourceStringifier.php b/src/Handlers/ResourceHandler.php similarity index 73% rename from src/Stringifiers/ResourceStringifier.php rename to src/Handlers/ResourceHandler.php index 0f55406..128a820 100644 --- a/src/Stringifiers/ResourceStringifier.php +++ b/src/Handlers/ResourceHandler.php @@ -8,23 +8,23 @@ declare(strict_types=1); -namespace Respect\Stringifier\Stringifiers; +namespace Respect\Stringifier\Handlers; +use Respect\Stringifier\Handler; use Respect\Stringifier\Quoter; -use Respect\Stringifier\Stringifier; use function get_resource_type; use function is_resource; use function sprintf; -final class ResourceStringifier implements Stringifier +final class ResourceHandler implements Handler { public function __construct( private readonly Quoter $quoter, ) { } - public function stringify(mixed $raw, int $depth): string|null + public function handle(mixed $raw, int $depth): string|null { if (!is_resource($raw)) { return null; diff --git a/src/Stringifiers/StringableObjectStringifier.php b/src/Handlers/StringableObjectHandler.php similarity index 59% rename from src/Stringifiers/StringableObjectStringifier.php rename to src/Handlers/StringableObjectHandler.php index 121e9dc..4c23262 100644 --- a/src/Stringifiers/StringableObjectStringifier.php +++ b/src/Handlers/StringableObjectHandler.php @@ -8,31 +8,31 @@ declare(strict_types=1); -namespace Respect\Stringifier\Stringifiers; +namespace Respect\Stringifier\Handlers; +use Respect\Stringifier\Handler; use Respect\Stringifier\Helpers\ObjectHelper; use Respect\Stringifier\Quoter; -use Respect\Stringifier\Stringifier; use Stringable; -final class StringableObjectStringifier implements Stringifier +final class StringableObjectHandler implements Handler { use ObjectHelper; public function __construct( - private readonly Stringifier $stringifier, + private readonly Handler $handler, private readonly Quoter $quoter, ) { } - public function stringify(mixed $raw, int $depth): string|null + public function handle(mixed $raw, int $depth): string|null { if (!$raw instanceof Stringable) { return null; } return $this->quoter->quote( - $this->format($raw, '__toString() =>', $this->stringifier->stringify($raw->__toString(), $depth + 1)), + $this->format($raw, '__toString() =>', $this->handler->handle($raw->__toString(), $depth + 1)), $depth, ); } diff --git a/src/Stringifiers/ThrowableObjectStringifier.php b/src/Handlers/ThrowableObjectHandler.php similarity index 75% rename from src/Stringifiers/ThrowableObjectStringifier.php rename to src/Handlers/ThrowableObjectHandler.php index 9e4a2f8..cdacefe 100644 --- a/src/Stringifiers/ThrowableObjectStringifier.php +++ b/src/Handlers/ThrowableObjectHandler.php @@ -8,27 +8,27 @@ declare(strict_types=1); -namespace Respect\Stringifier\Stringifiers; +namespace Respect\Stringifier\Handlers; +use Respect\Stringifier\Handler; use Respect\Stringifier\Helpers\ObjectHelper; use Respect\Stringifier\Quoter; -use Respect\Stringifier\Stringifier; use Throwable; use function getcwd; use function str_replace; -final class ThrowableObjectStringifier implements Stringifier +final class ThrowableObjectHandler implements Handler { use ObjectHelper; public function __construct( - private readonly Stringifier $stringifier, + private readonly Handler $handler, private readonly Quoter $quoter, ) { } - public function stringify(mixed $raw, int $depth): string|null + public function handle(mixed $raw, int $depth): string|null { if (!$raw instanceof Throwable) { return null; @@ -41,7 +41,7 @@ public function stringify(mixed $raw, int $depth): string|null return $this->quoter->quote( $this->format( $raw, - $this->stringifier->stringify($raw->getMessage(), $depth + 1), + $this->handler->handle($raw->getMessage(), $depth + 1), 'in', $this->getSource($raw), ), diff --git a/src/Stringifier.php b/src/Stringifier.php index 7b066a3..3e8705d 100644 --- a/src/Stringifier.php +++ b/src/Stringifier.php @@ -12,5 +12,5 @@ interface Stringifier { - public function stringify(mixed $raw, int $depth): string|null; + public function stringify(mixed $raw): string; } diff --git a/src/Stringifiers/CompositeStringifier.php b/src/Stringifiers/CompositeStringifier.php deleted file mode 100644 index b659073..0000000 --- a/src/Stringifiers/CompositeStringifier.php +++ /dev/null @@ -1,97 +0,0 @@ - - * SPDX-License-Identifier: MIT - */ - -declare(strict_types=1); - -namespace Respect\Stringifier\Stringifiers; - -use DateTimeInterface; -use Respect\Stringifier\Quoters\StandardQuoter; -use Respect\Stringifier\Stringifier; - -use function array_unshift; - -final class CompositeStringifier implements Stringifier -{ - private const int MAXIMUM_DEPTH = 3; - private const int MAXIMUM_NUMBER_OF_ITEMS = 5; - private const int MAXIMUM_NUMBER_OF_PROPERTIES = self::MAXIMUM_NUMBER_OF_ITEMS; - private const int MAXIMUM_LENGTH = 120; - - /** @var Stringifier[] */ - private array $stringifiers = []; - - public function __construct(Stringifier ...$stringifiers) - { - $this->stringifiers = $stringifiers; - } - - public static function createDefault(): self - { - $quoter = new StandardQuoter(self::MAXIMUM_LENGTH); - - $stringifier = new self( - new InfiniteNumberStringifier($quoter), - new NotANumberStringifier($quoter), - new ResourceStringifier($quoter), - new BoolStringifier($quoter), - new NullStringifier($quoter), - new DeclaredStringifier($quoter), - $jsonEncodableStringifier = new JsonEncodableStringifier(), - ); - $stringifier->prependStringifier( - $arrayStringifier = new ArrayStringifier( - $stringifier, - $quoter, - self::MAXIMUM_DEPTH, - self::MAXIMUM_NUMBER_OF_ITEMS, - ), - ); - $stringifier->prependStringifier( - new ObjectStringifier( - $stringifier, - $quoter, - self::MAXIMUM_DEPTH, - self::MAXIMUM_NUMBER_OF_PROPERTIES, - ), - ); - $stringifier->prependStringifier(new CallableStringifier($stringifier, $quoter)); - $stringifier->prependStringifier( - new FiberObjectStringifier(new CallableStringifier($stringifier, $quoter, closureOnly: false), $quoter), - ); - $stringifier->prependStringifier(new EnumerationStringifier($quoter)); - $stringifier->prependStringifier(new ObjectWithDebugInfoStringifier($arrayStringifier, $quoter)); - $stringifier->prependStringifier(new ArrayObjectStringifier($arrayStringifier, $quoter)); - $stringifier->prependStringifier(new JsonSerializableObjectStringifier($jsonEncodableStringifier, $quoter)); - $stringifier->prependStringifier(new StringableObjectStringifier($jsonEncodableStringifier, $quoter)); - $stringifier->prependStringifier(new ThrowableObjectStringifier($jsonEncodableStringifier, $quoter)); - $stringifier->prependStringifier(new DateTimeStringifier($quoter, DateTimeInterface::ATOM)); - $stringifier->prependStringifier(new IteratorObjectStringifier($stringifier, $quoter)); - - return $stringifier; - } - - public function prependStringifier(Stringifier $stringifier): void - { - array_unshift($this->stringifiers, $stringifier); - } - - public function stringify(mixed $raw, int $depth): string|null - { - foreach ($this->stringifiers as $stringifier) { - $string = $stringifier->stringify($raw, $depth); - if ($string === null) { - continue; - } - - return $string; - } - - return null; - } -} diff --git a/src/Stringify.php b/src/Stringify.php deleted file mode 100644 index 3462365..0000000 --- a/src/Stringify.php +++ /dev/null @@ -1,40 +0,0 @@ - - * SPDX-License-Identifier: MIT - */ - -declare(strict_types=1); - -namespace Respect\Stringifier; - -use Respect\Stringifier\Stringifiers\CompositeStringifier; - -use function print_r; - -final class Stringify -{ - public const int STARTING_DEPTH = 0; - - public function __construct( - private readonly Stringifier $stringifier, - ) { - } - - public static function createDefault(): self - { - return new self(CompositeStringifier::createDefault()); - } - - public function value(mixed $value): string - { - return $this->stringifier->stringify($value, self::STARTING_DEPTH) ?? print_r($value, true); - } - - public function __invoke(mixed $value): string - { - return $this->value($value); - } -} diff --git a/stringify.php b/stringify.php index 380d9ca..07dda4c 100644 --- a/stringify.php +++ b/stringify.php @@ -10,13 +10,15 @@ namespace Respect\Stringifier; +use Respect\Stringifier\Handlers\CompositeHandler; + function stringify(mixed $value): string { - static $stringify; + static $stringifier; - if ($stringify === null) { - $stringify = Stringify::createDefault(); + if (!$stringifier instanceof Stringifier) { + $stringifier = new HandlerStringifier(CompositeHandler::create(), new DumpStringifier()); } - return $stringify->value($value); + return $stringifier->stringify($value); } diff --git a/tests/src/Double/FakeStringifier.php b/tests/src/Double/FakeHandler.php similarity index 71% rename from tests/src/Double/FakeStringifier.php rename to tests/src/Double/FakeHandler.php index 1c871bb..e8b4cb3 100644 --- a/tests/src/Double/FakeStringifier.php +++ b/tests/src/Double/FakeHandler.php @@ -10,15 +10,15 @@ namespace Respect\Stringifier\Test\Double; -use Respect\Stringifier\Stringifier; +use Respect\Stringifier\Handler; use function hash; use function implode; use function serialize; -final class FakeStringifier implements Stringifier +final class FakeHandler implements Handler { - public function stringify(mixed $raw, int $depth): string + public function handle(mixed $raw, int $depth = 0): string { return implode('.', ['fake', $depth, hash('crc32', serialize($raw))]); } diff --git a/tests/src/Double/LameStringifier.php b/tests/src/Double/LameHandler.php similarity index 62% rename from tests/src/Double/LameStringifier.php rename to tests/src/Double/LameHandler.php index fb8ca38..a41dcb1 100644 --- a/tests/src/Double/LameStringifier.php +++ b/tests/src/Double/LameHandler.php @@ -10,11 +10,11 @@ namespace Respect\Stringifier\Test\Double; -use Respect\Stringifier\Stringifier; +use Respect\Stringifier\Handler; -final class LameStringifier implements Stringifier +final class LameHandler implements Handler { - public function stringify(mixed $raw, int $depth): string|null + public function handle(mixed $raw, int $depth): string|null { return null; } diff --git a/tests/unit/Stringifiers/ArrayStringifierTest.php b/tests/unit/Handlers/ArrayHandlerTest.php similarity index 59% rename from tests/unit/Stringifiers/ArrayStringifierTest.php rename to tests/unit/Handlers/ArrayHandlerTest.php index ef16b66..fa26c3f 100644 --- a/tests/unit/Stringifiers/ArrayStringifierTest.php +++ b/tests/unit/Handlers/ArrayHandlerTest.php @@ -8,26 +8,26 @@ declare(strict_types=1); -namespace Respect\Stringifier\Test\Unit\Stringifiers; +namespace Respect\Stringifier\Test\Unit\Handlers; use PHPUnit\Framework\Attributes\CoversClass; use PHPUnit\Framework\Attributes\Test; use PHPUnit\Framework\TestCase; -use Respect\Stringifier\Stringifiers\ArrayStringifier; +use Respect\Stringifier\Handlers\ArrayHandler; +use Respect\Stringifier\Test\Double\FakeHandler; use Respect\Stringifier\Test\Double\FakeQuoter; -use Respect\Stringifier\Test\Double\FakeStringifier; use function sprintf; -#[CoversClass(ArrayStringifier::class)] -final class ArrayStringifierTest extends TestCase +#[CoversClass(ArrayHandler::class)] +final class ArrayHandlerTest extends TestCase { #[Test] public function itShouldNotStringifyRawValueWhenItIsNotAnArray(): void { - $sut = new ArrayStringifier(new FakeStringifier(), new FakeQuoter(), 3, 5); + $sut = new ArrayHandler(new FakeHandler(), new FakeQuoter(), 3, 5); - self::assertNull($sut->stringify(false, 0)); + self::assertNull($sut->handle(false, 0)); } #[Test] @@ -38,9 +38,9 @@ public function itShouldStringifyRawValueWhenItIsAnEmptyArray(): void $quoter = new FakeQuoter(); - $sut = new ArrayStringifier(new FakeStringifier(), $quoter, 3, 5); + $sut = new ArrayHandler(new FakeHandler(), $quoter, 3, 5); - $actual = $sut->stringify($raw, $depth); + $actual = $sut->handle($raw, $depth); $expected = $quoter->quote('[]', $depth); self::assertSame($expected, $actual); @@ -52,18 +52,18 @@ public function itShouldStringifyRawValueWhenItIsAnNonAssociativeArray(): void $raw = [1, 2, 3]; $depth = 0; - $stringifier = new FakeStringifier(); + $stringifier = new FakeHandler(); $quoter = new FakeQuoter(); - $sut = new ArrayStringifier($stringifier, $quoter, 3, 5); + $sut = new ArrayHandler($stringifier, $quoter, 3, 5); - $actual = $sut->stringify($raw, $depth); + $actual = $sut->handle($raw, $depth); $expected = $quoter->quote( sprintf( '[%s, %s, %s]', - $stringifier->stringify($raw[0], $depth + 1), - $stringifier->stringify($raw[1], $depth + 1), - $stringifier->stringify($raw[2], $depth + 1), + $stringifier->handle($raw[0], $depth + 1), + $stringifier->handle($raw[1], $depth + 1), + $stringifier->handle($raw[2], $depth + 1), ), $depth, ); @@ -77,19 +77,19 @@ public function itShouldStringifyRawValueWhenItIsAnAssociativeArray(): void $raw = ['foo' => 1, 'bar' => 2]; $depth = 0; - $stringifier = new FakeStringifier(); + $stringifier = new FakeHandler(); $quoter = new FakeQuoter(); - $sut = new ArrayStringifier($stringifier, $quoter, 3, 5); + $sut = new ArrayHandler($stringifier, $quoter, 3, 5); - $actual = $sut->stringify($raw, $depth); + $actual = $sut->handle($raw, $depth); $expected = $quoter->quote( sprintf( '[%s: %s, %s: %s]', - $stringifier->stringify('foo', $depth + 1), - $stringifier->stringify($raw['foo'], $depth + 1), - $stringifier->stringify('bar', $depth + 1), - $stringifier->stringify($raw['bar'], $depth + 1), + $stringifier->handle('foo', $depth + 1), + $stringifier->handle($raw['foo'], $depth + 1), + $stringifier->handle('bar', $depth + 1), + $stringifier->handle($raw['bar'], $depth + 1), ), $depth, ); @@ -103,22 +103,22 @@ public function itShouldStringifyRawValueWhenIsNotSequentialArray(): void $raw = [1, 2 => 3]; $depth = 0; - $stringifier = new FakeStringifier(); + $stringifier = new FakeHandler(); $quoter = new FakeQuoter(); - $sut = new ArrayStringifier($stringifier, $quoter, 3, 5); + $sut = new ArrayHandler($stringifier, $quoter, 3, 5); $expected = $quoter->quote( sprintf( '[%s: %s, %s: %s]', - $stringifier->stringify(0, $depth + 1), - $stringifier->stringify(1, $depth + 1), - $stringifier->stringify(2, $depth + 1), - $stringifier->stringify(3, $depth + 1), + $stringifier->handle(0, $depth + 1), + $stringifier->handle(1, $depth + 1), + $stringifier->handle(2, $depth + 1), + $stringifier->handle(3, $depth + 1), ), $depth, ); - self::assertSame($expected, $sut->stringify($raw, $depth)); + self::assertSame($expected, $sut->handle($raw, $depth)); } #[Test] @@ -127,26 +127,26 @@ public function itShouldStringifyRawValueWhenItIsNestedArray(): void $raw = ['a', ['b', 'c', ['d', 'e']]]; $depth = 0; - $stringifier = new FakeStringifier(); + $stringifier = new FakeHandler(); $quoter = new FakeQuoter(); - $sut = new ArrayStringifier($stringifier, $quoter, 3, 5); + $sut = new ArrayHandler($stringifier, $quoter, 3, 5); - $actual = $sut->stringify($raw, $depth); + $actual = $sut->handle($raw, $depth); $expected = $quoter->quote( sprintf( '[%s, %s]', - $stringifier->stringify('a', $depth + 1), + $stringifier->handle('a', $depth + 1), $quoter->quote( sprintf( '[%s, %s, %s]', - $stringifier->stringify('b', $depth + 2), - $stringifier->stringify('c', $depth + 2), + $stringifier->handle('b', $depth + 2), + $stringifier->handle('c', $depth + 2), $quoter->quote( sprintf( '[%s, %s]', - $stringifier->stringify('d', $depth + 3), - $stringifier->stringify('e', $depth + 3), + $stringifier->handle('d', $depth + 3), + $stringifier->handle('e', $depth + 3), ), $depth + 2, ), @@ -170,9 +170,9 @@ public function itShouldStringifyRawValueWithPlaceholderWhenDepthEqualsTheMaximu $quoter = new FakeQuoter(); - $sut = new ArrayStringifier(new FakeStringifier(), $quoter, $maximumDepth, 5); + $sut = new ArrayHandler(new FakeHandler(), $quoter, $maximumDepth, 5); - $actual = $sut->stringify($raw, $depth); + $actual = $sut->handle($raw, $depth); $expected = $quoter->quote('...', $depth); self::assertSame($expected, $actual); @@ -188,9 +188,9 @@ public function itShouldStringifyRawValueWithPlaceholderWhenDepthIsBiggerThanMax $quoter = new FakeQuoter(); - $sut = new ArrayStringifier(new FakeStringifier(), $quoter, $maximumDepth, 5); + $sut = new ArrayHandler(new FakeHandler(), $quoter, $maximumDepth, 5); - $actual = $sut->stringify($raw, $depth); + $actual = $sut->handle($raw, $depth); $expected = $quoter->quote('...', $depth); self::assertSame($expected, $actual); @@ -204,24 +204,24 @@ public function itShouldStringifyRawValueWithPlaceholderWhenItReachesTheMaximumD $maximumDepth = 3; - $stringifier = new FakeStringifier(); + $stringifier = new FakeHandler(); $quoter = new FakeQuoter(); - $sut = new ArrayStringifier($stringifier, $quoter, $maximumDepth, 5); + $sut = new ArrayHandler($stringifier, $quoter, $maximumDepth, 5); - $actual = $sut->stringify($raw, $depth); + $actual = $sut->handle($raw, $depth); $expected = $quoter->quote( sprintf( '[%s, %s]', - $stringifier->stringify('a', $depth + 1), + $stringifier->handle('a', $depth + 1), $quoter->quote( sprintf( '[%s, %s]', - $stringifier->stringify('b', $depth + 2), + $stringifier->handle('b', $depth + 2), $quoter->quote( sprintf( '[%s, %s]', - $stringifier->stringify('c', $depth + 3), + $stringifier->handle('c', $depth + 3), $quoter->quote('...', $depth + 3), ), $depth + 2, @@ -244,21 +244,21 @@ public function itShouldStringifyRawValueWithPlaceholderWhenLimitOfItemsIsReache $raw = [1, 2, 3, 4, 5, 6]; $depth = 0; - $stringifier = new FakeStringifier(); + $stringifier = new FakeHandler(); $quoter = new FakeQuoter(); - $sut = new ArrayStringifier($stringifier, $quoter, 1, $itemsLimit); + $sut = new ArrayHandler($stringifier, $quoter, 1, $itemsLimit); $expected = $quoter->quote( sprintf( '[%s, %s, %s, ...]', - $stringifier->stringify(1, $depth + 1), - $stringifier->stringify(2, $depth + 1), - $stringifier->stringify(3, $depth + 1), + $stringifier->handle(1, $depth + 1), + $stringifier->handle(2, $depth + 1), + $stringifier->handle(3, $depth + 1), ), $depth, ); - $actual = $sut->stringify($raw, $depth); + $actual = $sut->handle($raw, $depth); self::assertSame($expected, $actual); } diff --git a/tests/unit/Stringifiers/ArrayObjectStringifierTest.php b/tests/unit/Handlers/ArrayObjectHandlerTest.php similarity index 57% rename from tests/unit/Stringifiers/ArrayObjectStringifierTest.php rename to tests/unit/Handlers/ArrayObjectHandlerTest.php index fc634a1..9ab6796 100644 --- a/tests/unit/Stringifiers/ArrayObjectStringifierTest.php +++ b/tests/unit/Handlers/ArrayObjectHandlerTest.php @@ -8,30 +8,30 @@ declare(strict_types=1); -namespace Respect\Stringifier\Test\Unit\Stringifiers; +namespace Respect\Stringifier\Test\Unit\Handlers; use ArrayObject; use PHPUnit\Framework\Attributes\CoversClass; use PHPUnit\Framework\Attributes\Test; use PHPUnit\Framework\TestCase; -use Respect\Stringifier\Stringifiers\ArrayObjectStringifier; +use Respect\Stringifier\Handlers\ArrayObjectHandler; +use Respect\Stringifier\Test\Double\FakeHandler; use Respect\Stringifier\Test\Double\FakeQuoter; -use Respect\Stringifier\Test\Double\FakeStringifier; use stdClass; use function sprintf; -#[CoversClass(ArrayObjectStringifier::class)] -final class ArrayObjectStringifierTest extends TestCase +#[CoversClass(ArrayObjectHandler::class)] +final class ArrayObjectHandlerTest extends TestCase { private const int DEPTH = 0; #[Test] public function itShouldNotStringifyRawValueWhenItIsNotAnArrayObject(): void { - $sut = new ArrayObjectStringifier(new FakeStringifier(), new FakeQuoter()); + $sut = new ArrayObjectHandler(new FakeHandler(), new FakeQuoter()); - self::assertNull($sut->stringify(new stdClass(), self::DEPTH)); + self::assertNull($sut->handle(new stdClass(), self::DEPTH)); } #[Test] @@ -39,14 +39,14 @@ public function itShouldStringifyRawValueWhenItIsAnArrayObject(): void { $raw = new ArrayObject([1, 2, 3]); - $stringifier = new FakeStringifier(); + $stringifier = new FakeHandler(); $quoter = new FakeQuoter(); - $string = $stringifier->stringify($raw->getArrayCopy(), self::DEPTH + 1); + $string = $stringifier->handle($raw->getArrayCopy(), self::DEPTH + 1); - $sut = new ArrayObjectStringifier($stringifier, $quoter); + $sut = new ArrayObjectHandler($stringifier, $quoter); - $actual = $sut->stringify($raw, self::DEPTH); + $actual = $sut->handle($raw, self::DEPTH); $expected = $quoter->quote( sprintf('ArrayObject { getArrayCopy() => %s }', $string), self::DEPTH, diff --git a/tests/unit/Stringifiers/BoolStringifierTest.php b/tests/unit/Handlers/BoolHandlerTest.php similarity index 65% rename from tests/unit/Stringifiers/BoolStringifierTest.php rename to tests/unit/Handlers/BoolHandlerTest.php index 51a2a68..83110ce 100644 --- a/tests/unit/Stringifiers/BoolStringifierTest.php +++ b/tests/unit/Handlers/BoolHandlerTest.php @@ -8,25 +8,25 @@ declare(strict_types=1); -namespace Respect\Stringifier\Test\Unit\Stringifiers; +namespace Respect\Stringifier\Test\Unit\Handlers; use PHPUnit\Framework\Attributes\CoversClass; use PHPUnit\Framework\Attributes\Test; use PHPUnit\Framework\TestCase; -use Respect\Stringifier\Stringifiers\BoolStringifier; +use Respect\Stringifier\Handlers\BoolHandler; use Respect\Stringifier\Test\Double\FakeQuoter; -#[CoversClass(BoolStringifier::class)] -final class BoolStringifierTest extends TestCase +#[CoversClass(BoolHandler::class)] +final class BoolHandlerTest extends TestCase { private const int DEPTH = 0; #[Test] public function itShouldNotStringifyWhenRawValueIsNotBoolean(): void { - $sut = new BoolStringifier(new FakeQuoter()); + $sut = new BoolHandler(new FakeQuoter()); - self::assertNull($sut->stringify(1, self::DEPTH)); + self::assertNull($sut->handle(1, self::DEPTH)); } #[Test] @@ -34,9 +34,9 @@ public function itShouldStringifyRawValueWhenItIsTrue(): void { $quoter = new FakeQuoter(); - $sut = new BoolStringifier($quoter); + $sut = new BoolHandler($quoter); - $actual = $sut->stringify(true, self::DEPTH); + $actual = $sut->handle(true, self::DEPTH); $expected = $quoter->quote('true', self::DEPTH); self::assertSame($expected, $actual); @@ -47,9 +47,9 @@ public function itShouldStringifyRawValueWhenItIsFalse(): void { $quoter = new FakeQuoter(); - $sut = new BoolStringifier($quoter); + $sut = new BoolHandler($quoter); - $actual = $sut->stringify(false, self::DEPTH); + $actual = $sut->handle(false, self::DEPTH); $expected = $quoter->quote('false', self::DEPTH); self::assertSame($expected, $actual); diff --git a/tests/unit/Stringifiers/CallableStringifierTest.php b/tests/unit/Handlers/CallableHandlerTest.php similarity index 84% rename from tests/unit/Stringifiers/CallableStringifierTest.php rename to tests/unit/Handlers/CallableHandlerTest.php index 7c607ff..ccd7208 100644 --- a/tests/unit/Stringifiers/CallableStringifierTest.php +++ b/tests/unit/Handlers/CallableHandlerTest.php @@ -8,7 +8,7 @@ declare(strict_types=1); -namespace Respect\Stringifier\Test\Unit\Stringifiers; +namespace Respect\Stringifier\Test\Unit\Handlers; use Countable; use DateTime; @@ -17,24 +17,24 @@ use PHPUnit\Framework\Attributes\DataProvider; use PHPUnit\Framework\Attributes\Test; use PHPUnit\Framework\TestCase; -use Respect\Stringifier\Stringifiers\CallableStringifier; +use Respect\Stringifier\Handlers\CallableHandler; +use Respect\Stringifier\Test\Double\FakeHandler; use Respect\Stringifier\Test\Double\FakeQuoter; -use Respect\Stringifier\Test\Double\FakeStringifier; use function array_sum; use function sprintf; -#[CoversClass(CallableStringifier::class)] -final class CallableStringifierTest extends TestCase +#[CoversClass(CallableHandler::class)] +final class CallableHandlerTest extends TestCase { private const int DEPTH = 0; #[Test] public function itShouldNotStringifyWhenRawValueIsNotCallable(): void { - $sut = new CallableStringifier(new FakeStringifier(), new FakeQuoter(), closureOnly: false); + $sut = new CallableHandler(new FakeHandler(), new FakeQuoter(), closureOnly: false); - self::assertNull($sut->stringify(1, self::DEPTH)); + self::assertNull($sut->handle(1, self::DEPTH)); } #[Test] @@ -43,9 +43,9 @@ public function itShouldStringifyWhenRawValueIsClosure(callable $raw, string $ex { $quoter = new FakeQuoter(); - $sut = new CallableStringifier(new FakeStringifier(), $quoter); + $sut = new CallableHandler(new FakeHandler(), $quoter); - $actual = $sut->stringify($raw, self::DEPTH); + $actual = $sut->handle($raw, self::DEPTH); $expected = $quoter->quote($expectedWithoutQuotes, self::DEPTH); self::assertEquals($expected, $actual); @@ -55,9 +55,9 @@ public function itShouldStringifyWhenRawValueIsClosure(callable $raw, string $ex #[DataProvider('nonClosureCallableRawValuesProvider')] public function itShouldNotStringifyNonClosureCallableByDefault(callable $raw, string $useless): void { - $sut = new CallableStringifier(new FakeStringifier(), new FakeQuoter()); + $sut = new CallableHandler(new FakeHandler(), new FakeQuoter()); - self::assertNull($sut->stringify($raw, self::DEPTH)); + self::assertNull($sut->handle($raw, self::DEPTH)); } #[Test] @@ -68,9 +68,9 @@ public function itShouldStringifyNonClosureCallableWhenClosureOnlyIsFalse( ): void { $quoter = new FakeQuoter(); - $sut = new CallableStringifier(new FakeStringifier(), $quoter, closureOnly: false); + $sut = new CallableHandler(new FakeHandler(), $quoter, closureOnly: false); - $actual = $sut->stringify($raw, self::DEPTH); + $actual = $sut->handle($raw, self::DEPTH); $expected = $quoter->quote($expectedWithoutQuotes, self::DEPTH); self::assertEquals($expected, $actual); @@ -81,14 +81,14 @@ public function itShouldStringifyWhenRawValueIsCallableWithDefaultValues(): void { $raw = static fn(int $value = 1): int => $value; - $stringifier = new FakeStringifier(); + $stringifier = new FakeHandler(); $quoter = new FakeQuoter(); - $sut = new CallableStringifier($stringifier, $quoter); + $sut = new CallableHandler($stringifier, $quoter); - $actual = $sut->stringify($raw, self::DEPTH); + $actual = $sut->handle($raw, self::DEPTH); $expected = $quoter->quote( - sprintf('Closure { static fn(int $value = %s): int }', $stringifier->stringify(1, self::DEPTH + 1)), + sprintf('Closure { static fn(int $value = %s): int }', $stringifier->handle(1, self::DEPTH + 1)), self::DEPTH, ); @@ -102,9 +102,9 @@ public function itShouldStringifyWhenRawValueIsCallableThatDoesNotHaveAnAccessib $quoter = new FakeQuoter(); - $sut = new CallableStringifier(new FakeStringifier(), $quoter, closureOnly: false); + $sut = new CallableHandler(new FakeHandler(), $quoter, closureOnly: false); - $actual = $sut->stringify($raw, self::DEPTH); + $actual = $sut->handle($raw, self::DEPTH); $expected = $quoter->quote( 'array_walk(object|array &$array, callable $callback, ?mixed $arg = fake.1.cbade92e): true', self::DEPTH, diff --git a/tests/unit/Handlers/CompositeHandlerTest.php b/tests/unit/Handlers/CompositeHandlerTest.php new file mode 100644 index 0000000..6887d12 --- /dev/null +++ b/tests/unit/Handlers/CompositeHandlerTest.php @@ -0,0 +1,78 @@ + + * SPDX-License-Identifier: MIT + */ + +declare(strict_types=1); + +namespace Respect\Stringifier\Test\Unit\Handlers; + +use PHPUnit\Framework\Attributes\CoversClass; +use PHPUnit\Framework\Attributes\Test; +use PHPUnit\Framework\TestCase; +use Respect\Stringifier\Handlers\CompositeHandler; +use Respect\Stringifier\Test\Double\FakeHandler; +use Respect\Stringifier\Test\Double\LameHandler; +use stdClass; + +#[CoversClass(CompositeHandler::class)] +final class CompositeHandlerTest extends TestCase +{ + private const int DEPTH = 0; + + #[Test] + public function itShouldNotStringifyRawValueWhenThereAreNoHandlersDefined(): void + { + $sut = new CompositeHandler(); + + self::assertNull($sut->handle(new stdClass(), self::DEPTH)); + } + + #[Test] + public function itShouldStringifyRawValueByTryingToUseAllHandlersUntilOneCanStringifyIt(): void + { + $raw = new stdClass(); + + $stringifier = new FakeHandler(); + + $sut = new CompositeHandler(new LameHandler(), new LameHandler(), $stringifier); + + $actual = $sut->handle(new stdClass(), self::DEPTH); + $expected = $stringifier->handle($raw, self::DEPTH); + + self::assertSame($expected, $actual); + } + + #[Test] + public function itShouldStringifyRawValueStartingWithTheLastPrependedHandler(): void + { + $raw = new stdClass(); + + $stringifier = new FakeHandler(); + + $sut = new CompositeHandler(new LameHandler(), new LameHandler()); + $sut->prependHandler($stringifier); + + $actual = $sut->handle(new stdClass(), self::DEPTH); + $expected = $stringifier->handle($raw, self::DEPTH); + + self::assertSame($expected, $actual); + } + + #[Test] + public function itShouldNotStringifyWhenNoneOfTheHandlersCanStringify(): void + { + $sut = new CompositeHandler(new LameHandler(), new LameHandler(), new LameHandler()); + + self::assertNull($sut->handle(new stdClass(), self::DEPTH)); + } + + #[Test] + public function itShouldCreateDefaultCompositeHandler(): void + { + self::assertInstanceOf(CompositeHandler::class, CompositeHandler::create()); + } +} diff --git a/tests/unit/Stringifiers/DateTimeStringifierTest.php b/tests/unit/Handlers/DateTimeHandlerTest.php similarity index 78% rename from tests/unit/Stringifiers/DateTimeStringifierTest.php rename to tests/unit/Handlers/DateTimeHandlerTest.php index 168ca3e..50b8909 100644 --- a/tests/unit/Stringifiers/DateTimeStringifierTest.php +++ b/tests/unit/Handlers/DateTimeHandlerTest.php @@ -8,7 +8,7 @@ declare(strict_types=1); -namespace Respect\Stringifier\Test\Unit\Stringifiers; +namespace Respect\Stringifier\Test\Unit\Handlers; use DateTime; use DateTimeImmutable; @@ -17,20 +17,20 @@ use PHPUnit\Framework\Attributes\DataProvider; use PHPUnit\Framework\Attributes\Test; use PHPUnit\Framework\TestCase; -use Respect\Stringifier\Stringifiers\DateTimeStringifier; +use Respect\Stringifier\Handlers\DateTimeHandler; use Respect\Stringifier\Test\Double\FakeQuoter; -#[CoversClass(DateTimeStringifier::class)] -final class DateTimeStringifierTest extends TestCase +#[CoversClass(DateTimeHandler::class)] +final class DateTimeHandlerTest extends TestCase { private const int DEPTH = 0; #[Test] public function itShouldNotStringifyRawValueWhenItIsNotInstanceOfDateTimeInterface(): void { - $sut = new DateTimeStringifier(new FakeQuoter(), 'c'); + $sut = new DateTimeHandler(new FakeQuoter(), 'c'); - self::assertNull($sut->stringify('NotDateTimeInterface', self::DEPTH)); + self::assertNull($sut->handle('NotDateTimeInterface', self::DEPTH)); } #[Test] @@ -42,9 +42,9 @@ public function itShouldStringifyRawValueWhenItIsInstanceOfDateTimeInterface( ): void { $quoter = new FakeQuoter(); - $sut = new DateTimeStringifier($quoter, $format); + $sut = new DateTimeHandler($quoter, $format); - $actual = $sut->stringify($raw, self::DEPTH); + $actual = $sut->handle($raw, self::DEPTH); $expected = $quoter->quote($string, self::DEPTH); self::assertSame($expected, $actual); diff --git a/tests/unit/Stringifiers/DeclaredStringifierTest.php b/tests/unit/Handlers/DeclaredHandlerTest.php similarity index 72% rename from tests/unit/Stringifiers/DeclaredStringifierTest.php rename to tests/unit/Handlers/DeclaredHandlerTest.php index af2d454..d39f24e 100644 --- a/tests/unit/Stringifiers/DeclaredStringifierTest.php +++ b/tests/unit/Handlers/DeclaredHandlerTest.php @@ -8,7 +8,7 @@ declare(strict_types=1); -namespace Respect\Stringifier\Test\Unit\Stringifiers; +namespace Respect\Stringifier\Test\Unit\Handlers; use ArrayObject; use BasicEnumeration; @@ -17,21 +17,21 @@ use PHPUnit\Framework\Attributes\DataProvider; use PHPUnit\Framework\Attributes\Test; use PHPUnit\Framework\TestCase; +use Respect\Stringifier\Handlers\DeclaredHandler; use Respect\Stringifier\Helpers\ObjectHelper; -use Respect\Stringifier\Stringifiers\DeclaredStringifier; use Respect\Stringifier\Test\Double\FakeQuoter; -#[CoversClass(DeclaredStringifier::class)] -final class DeclaredStringifierTest extends TestCase +#[CoversClass(DeclaredHandler::class)] +final class DeclaredHandlerTest extends TestCase { private const int DEPTH = 0; #[Test] public function itShouldNotStringifyWhenRawValueIsNotExists(): void { - $sut = new DeclaredStringifier(new FakeQuoter()); + $sut = new DeclaredHandler(new FakeQuoter()); - self::assertNull($sut->stringify('NotAClassInterfaceTraitOrEnum', self::DEPTH)); + self::assertNull($sut->handle('NotAClassInterfaceTraitOrEnum', self::DEPTH)); } #[Test] @@ -40,9 +40,9 @@ public function itShouldStringifyWhenRawValueIsExists(string $raw): void { $quoter = new FakeQuoter(); - $sut = new DeclaredStringifier($quoter); + $sut = new DeclaredHandler($quoter); - $actual = $sut->stringify($raw, self::DEPTH); + $actual = $sut->handle($raw, self::DEPTH); $expected = $quoter->quote($raw, self::DEPTH); self::assertEquals($expected, $actual); diff --git a/tests/unit/Stringifiers/EnumerationStringifierTest.php b/tests/unit/Handlers/EnumerationHandlerTest.php similarity index 64% rename from tests/unit/Stringifiers/EnumerationStringifierTest.php rename to tests/unit/Handlers/EnumerationHandlerTest.php index a39c9a0..0254a39 100644 --- a/tests/unit/Stringifiers/EnumerationStringifierTest.php +++ b/tests/unit/Handlers/EnumerationHandlerTest.php @@ -8,27 +8,27 @@ declare(strict_types=1); -namespace Respect\Stringifier\Test\Unit\Stringifiers; +namespace Respect\Stringifier\Test\Unit\Handlers; use BackedEnumeration; use BasicEnumeration; use PHPUnit\Framework\Attributes\CoversClass; use PHPUnit\Framework\Attributes\Test; use PHPUnit\Framework\TestCase; -use Respect\Stringifier\Stringifiers\EnumerationStringifier; +use Respect\Stringifier\Handlers\EnumerationHandler; use Respect\Stringifier\Test\Double\FakeQuoter; -#[CoversClass(EnumerationStringifier::class)] -final class EnumerationStringifierTest extends TestCase +#[CoversClass(EnumerationHandler::class)] +final class EnumerationHandlerTest extends TestCase { private const int DEPTH = 0; #[Test] public function itShouldNotStringifyWhenRawValueIsNotAnEnumeration(): void { - $sut = new EnumerationStringifier(new FakeQuoter()); + $sut = new EnumerationHandler(new FakeQuoter()); - self::assertNull($sut->stringify(1, self::DEPTH)); + self::assertNull($sut->handle(1, self::DEPTH)); } #[Test] @@ -36,9 +36,9 @@ public function itShouldStringifyRawValueWhenItIsBasicEnumeration(): void { $quoter = new FakeQuoter(); - $sut = new EnumerationStringifier($quoter); + $sut = new EnumerationHandler($quoter); - $actual = $sut->stringify(BasicEnumeration::BAR, self::DEPTH); + $actual = $sut->handle(BasicEnumeration::BAR, self::DEPTH); $expected = $quoter->quote('BasicEnumeration::BAR', self::DEPTH); self::assertSame($expected, $actual); @@ -49,9 +49,9 @@ public function itShouldStringifyRawValueWhenItIsBackedEnumeration(): void { $quoter = new FakeQuoter(); - $sut = new EnumerationStringifier($quoter); + $sut = new EnumerationHandler($quoter); - $actual = $sut->stringify(BackedEnumeration::BAZ, self::DEPTH); + $actual = $sut->handle(BackedEnumeration::BAZ, self::DEPTH); $expected = $quoter->quote('BackedEnumeration::BAZ', self::DEPTH); self::assertSame($expected, $actual); diff --git a/tests/unit/Stringifiers/FiberObjectStringifierTest.php b/tests/unit/Handlers/FiberObjectHandlerTest.php similarity index 58% rename from tests/unit/Stringifiers/FiberObjectStringifierTest.php rename to tests/unit/Handlers/FiberObjectHandlerTest.php index 20b8c9d..2479783 100644 --- a/tests/unit/Stringifiers/FiberObjectStringifierTest.php +++ b/tests/unit/Handlers/FiberObjectHandlerTest.php @@ -8,31 +8,31 @@ declare(strict_types=1); -namespace Respect\Stringifier\Test\Unit\Stringifiers; +namespace Respect\Stringifier\Test\Unit\Handlers; use Fiber; use PHPUnit\Framework\Attributes\CoversClass; use PHPUnit\Framework\Attributes\Test; use PHPUnit\Framework\TestCase; -use Respect\Stringifier\Stringifiers\FiberObjectStringifier; +use Respect\Stringifier\Handlers\FiberObjectHandler; +use Respect\Stringifier\Test\Double\FakeHandler; use Respect\Stringifier\Test\Double\FakeQuoter; -use Respect\Stringifier\Test\Double\FakeStringifier; use stdClass; use WithInvoke; use function sprintf; -#[CoversClass(FiberObjectStringifier::class)] -final class FiberObjectStringifierTest extends TestCase +#[CoversClass(FiberObjectHandler::class)] +final class FiberObjectHandlerTest extends TestCase { private const int DEPTH = 0; #[Test] public function itShouldNotStringifyRawValueWhenItIsNotAnObjectWithDebugInfo(): void { - $sut = new FiberObjectStringifier(new FakeStringifier(), new FakeQuoter()); + $sut = new FiberObjectHandler(new FakeHandler(), new FakeQuoter()); - self::assertNull($sut->stringify(new stdClass(), self::DEPTH)); + self::assertNull($sut->handle(new stdClass(), self::DEPTH)); } #[Test] @@ -42,14 +42,14 @@ public function itShouldStringifyRawValueWhenItIsAnObjectWithDebugInfo(): void $raw = new Fiber($callable); - $stringifier = new FakeStringifier(); + $stringifier = new FakeHandler(); $quoter = new FakeQuoter(); - $string = $stringifier->stringify($callable, self::DEPTH + 1); + $string = $stringifier->handle($callable, self::DEPTH + 1); - $sut = new FiberObjectStringifier($stringifier, $quoter); + $sut = new FiberObjectHandler($stringifier, $quoter); - $actual = $sut->stringify($raw, self::DEPTH); + $actual = $sut->handle($raw, self::DEPTH); $expected = $quoter->quote( sprintf('Fiber { %s }', $string), self::DEPTH, diff --git a/tests/unit/Stringifiers/InfiniteNumberStringifierTest.php b/tests/unit/Handlers/InfiniteNumberHandlerTest.php similarity index 61% rename from tests/unit/Stringifiers/InfiniteNumberStringifierTest.php rename to tests/unit/Handlers/InfiniteNumberHandlerTest.php index aadfe46..b197997 100644 --- a/tests/unit/Stringifiers/InfiniteNumberStringifierTest.php +++ b/tests/unit/Handlers/InfiniteNumberHandlerTest.php @@ -8,35 +8,35 @@ declare(strict_types=1); -namespace Respect\Stringifier\Test\Unit\Stringifiers; +namespace Respect\Stringifier\Test\Unit\Handlers; use PHPUnit\Framework\Attributes\CoversClass; use PHPUnit\Framework\Attributes\Test; use PHPUnit\Framework\TestCase; -use Respect\Stringifier\Stringifiers\InfiniteNumberStringifier; +use Respect\Stringifier\Handlers\InfiniteNumberHandler; use Respect\Stringifier\Test\Double\FakeQuoter; use const INF; -#[CoversClass(InfiniteNumberStringifier::class)] -final class InfiniteNumberStringifierTest extends TestCase +#[CoversClass(InfiniteNumberHandler::class)] +final class InfiniteNumberHandlerTest extends TestCase { private const int DEPTH = 0; #[Test] public function itShouldNotStringifyRawValueWhenItIsNotFloat(): void { - $sut = new InfiniteNumberStringifier(new FakeQuoter()); + $sut = new InfiniteNumberHandler(new FakeQuoter()); - self::assertNull($sut->stringify(1, self::DEPTH)); + self::assertNull($sut->handle(1, self::DEPTH)); } #[Test] public function itShouldNotStringifyRawValueWhenItIsFiniteFloat(): void { - $sut = new InfiniteNumberStringifier(new FakeQuoter()); + $sut = new InfiniteNumberHandler(new FakeQuoter()); - self::assertNull($sut->stringify(1.0, self::DEPTH)); + self::assertNull($sut->handle(1.0, self::DEPTH)); } #[Test] @@ -44,9 +44,9 @@ public function itShouldStringifyRawValueWhenItIsAnInfinitePositiveNumber(): voi { $quoter = new FakeQuoter(); - $sut = new InfiniteNumberStringifier($quoter); + $sut = new InfiniteNumberHandler($quoter); - $actual = $sut->stringify(INF, self::DEPTH); + $actual = $sut->handle(INF, self::DEPTH); $expected = $quoter->quote('INF', self::DEPTH); self::assertSame($expected, $actual); @@ -57,9 +57,9 @@ public function itShouldStringifyRawValueWhenItIsAnInfiniteNegativeNumber(): voi { $quoter = new FakeQuoter(); - $sut = new InfiniteNumberStringifier($quoter); + $sut = new InfiniteNumberHandler($quoter); - $actual = $sut->stringify(INF * -1, self::DEPTH); + $actual = $sut->handle(INF * -1, self::DEPTH); $expected = $quoter->quote('-INF', self::DEPTH); self::assertSame($expected, $actual); diff --git a/tests/unit/Stringifiers/IteratorObjectStringifierTest.php b/tests/unit/Handlers/IteratorObjectHandlerTest.php similarity index 55% rename from tests/unit/Stringifiers/IteratorObjectStringifierTest.php rename to tests/unit/Handlers/IteratorObjectHandlerTest.php index 1059855..56491e1 100644 --- a/tests/unit/Stringifiers/IteratorObjectStringifierTest.php +++ b/tests/unit/Handlers/IteratorObjectHandlerTest.php @@ -8,38 +8,38 @@ declare(strict_types=1); -namespace Respect\Stringifier\Test\Unit\Stringifiers; +namespace Respect\Stringifier\Test\Unit\Handlers; use ArrayIterator; use ConcreteIterator; use PHPUnit\Framework\Attributes\CoversClass; use PHPUnit\Framework\Attributes\Test; use PHPUnit\Framework\TestCase; -use Respect\Stringifier\Stringifiers\IteratorObjectStringifier; +use Respect\Stringifier\Handlers\IteratorObjectHandler; +use Respect\Stringifier\Test\Double\FakeHandler; use Respect\Stringifier\Test\Double\FakeQuoter; -use Respect\Stringifier\Test\Double\FakeStringifier; use function sprintf; -#[CoversClass(IteratorObjectStringifier::class)] -final class IteratorObjectStringifierTest extends TestCase +#[CoversClass(IteratorObjectHandler::class)] +final class IteratorObjectHandlerTest extends TestCase { private const int DEPTH = 0; #[Test] public function itShouldNotStringifyRawValueWhenItIsNotTraversable(): void { - $sut = new IteratorObjectStringifier(new FakeStringifier(), new FakeQuoter()); + $sut = new IteratorObjectHandler(new FakeHandler(), new FakeQuoter()); - self::assertNull($sut->stringify([1, 2, 3, 4], self::DEPTH)); + self::assertNull($sut->handle([1, 2, 3, 4], self::DEPTH)); } #[Test] public function itShouldNotStringifyRawValueWhenItIsIterableThatIsNotValid(): void { - $sut = new IteratorObjectStringifier(new FakeStringifier(), new FakeQuoter()); + $sut = new IteratorObjectHandler(new FakeHandler(), new FakeQuoter()); - self::assertNull($sut->stringify(new ArrayIterator([]), self::DEPTH)); + self::assertNull($sut->handle(new ArrayIterator([]), self::DEPTH)); } #[Test] @@ -47,16 +47,16 @@ public function itShouldStringifyRawValueWhenItIsAnInstanceOfIterator(): void { $raw = new ConcreteIterator(); - $stringifier = new FakeStringifier(); + $stringifier = new FakeHandler(); $quoter = new FakeQuoter(); - $sut = new IteratorObjectStringifier($stringifier, $quoter); + $sut = new IteratorObjectHandler($stringifier, $quoter); - $actual = $sut->stringify($raw, self::DEPTH); + $actual = $sut->handle($raw, self::DEPTH); $expected = $quoter->quote( sprintf( 'ConcreteIterator { current() => %s }', - $stringifier->stringify($raw->current(), self::DEPTH + 1), + $stringifier->handle($raw->current(), self::DEPTH + 1), ), self::DEPTH, ); diff --git a/tests/unit/Stringifiers/JsonEncodableStringifierTest.php b/tests/unit/Handlers/JsonEncodableHandlerTest.php similarity index 61% rename from tests/unit/Stringifiers/JsonEncodableStringifierTest.php rename to tests/unit/Handlers/JsonEncodableHandlerTest.php index f8c84e4..6e04762 100644 --- a/tests/unit/Stringifiers/JsonEncodableStringifierTest.php +++ b/tests/unit/Handlers/JsonEncodableHandlerTest.php @@ -8,26 +8,26 @@ declare(strict_types=1); -namespace Respect\Stringifier\Test\Unit\Stringifiers; +namespace Respect\Stringifier\Test\Unit\Handlers; use PHPUnit\Framework\Attributes\CoversClass; use PHPUnit\Framework\Attributes\Test; use PHPUnit\Framework\TestCase; -use Respect\Stringifier\Stringifiers\JsonEncodableStringifier; +use Respect\Stringifier\Handlers\JsonEncodableHandler; use function tmpfile; -#[CoversClass(JsonEncodableStringifier::class)] -final class JsonEncodableStringifierTest extends TestCase +#[CoversClass(JsonEncodableHandler::class)] +final class JsonEncodableHandlerTest extends TestCase { private const int DEPTH = 0; #[Test] public function itShouldNotStringifyRawValueWhenItCannotBeConvertedToJson(): void { - $sut = new JsonEncodableStringifier(); + $sut = new JsonEncodableHandler(); - self::assertNull($sut->stringify(tmpfile(), self::DEPTH)); + self::assertNull($sut->handle(tmpfile(), self::DEPTH)); } #[Test] @@ -35,9 +35,9 @@ public function itShouldStringifyRawValueWhenItCanBeConvertedToJson(): void { $raw = 'É uma \' " string'; - $sut = new JsonEncodableStringifier(); + $sut = new JsonEncodableHandler(); - $actual = $sut->stringify($raw, self::DEPTH); + $actual = $sut->handle($raw, self::DEPTH); $expected = '"É uma \' \" string"'; self::assertSame($expected, $actual); diff --git a/tests/unit/Stringifiers/JsonSerializableObjectStringifierTest.php b/tests/unit/Handlers/JsonSerializableObjectHandlerTest.php similarity index 57% rename from tests/unit/Stringifiers/JsonSerializableObjectStringifierTest.php rename to tests/unit/Handlers/JsonSerializableObjectHandlerTest.php index 5fcf4c7..9d63350 100644 --- a/tests/unit/Stringifiers/JsonSerializableObjectStringifierTest.php +++ b/tests/unit/Handlers/JsonSerializableObjectHandlerTest.php @@ -8,30 +8,30 @@ declare(strict_types=1); -namespace Respect\Stringifier\Test\Unit\Stringifiers; +namespace Respect\Stringifier\Test\Unit\Handlers; use ConcreteJsonSerializable; use PHPUnit\Framework\Attributes\CoversClass; use PHPUnit\Framework\Attributes\Test; use PHPUnit\Framework\TestCase; -use Respect\Stringifier\Stringifiers\JsonSerializableObjectStringifier; +use Respect\Stringifier\Handlers\JsonSerializableObjectHandler; +use Respect\Stringifier\Test\Double\FakeHandler; use Respect\Stringifier\Test\Double\FakeQuoter; -use Respect\Stringifier\Test\Double\FakeStringifier; use stdClass; use function sprintf; -#[CoversClass(JsonSerializableObjectStringifier::class)] -final class JsonSerializableObjectStringifierTest extends TestCase +#[CoversClass(JsonSerializableObjectHandler::class)] +final class JsonSerializableObjectHandlerTest extends TestCase { private const int DEPTH = 0; #[Test] public function itShouldNotStringifyRawValueWhenItIsNotAnInstanceOfJsonSerializable(): void { - $sut = new JsonSerializableObjectStringifier(new FakeStringifier(), new FakeQuoter()); + $sut = new JsonSerializableObjectHandler(new FakeHandler(), new FakeQuoter()); - self::assertNull($sut->stringify(new stdClass(), self::DEPTH)); + self::assertNull($sut->handle(new stdClass(), self::DEPTH)); } #[Test] @@ -39,13 +39,13 @@ public function itShouldStringifyRawValueWhenItIsAnInstanceOfJsonSerializable(): { $raw = new ConcreteJsonSerializable(); - $stringifier = new FakeStringifier(); + $stringifier = new FakeHandler(); $quoter = new FakeQuoter(); - $jsonString = $stringifier->stringify($raw->jsonSerialize(), self::DEPTH + 1); + $jsonString = $stringifier->handle($raw->jsonSerialize(), self::DEPTH + 1); - $sut = new JsonSerializableObjectStringifier($stringifier, $quoter); - $actual = $sut->stringify($raw, self::DEPTH); + $sut = new JsonSerializableObjectHandler($stringifier, $quoter); + $actual = $sut->handle($raw, self::DEPTH); $expected = $quoter->quote( sprintf('%s { jsonSerialize() => %s }', ConcreteJsonSerializable::class, $jsonString), self::DEPTH, diff --git a/tests/unit/Stringifiers/NotANumberStringifierTest.php b/tests/unit/Handlers/NotANumberHandlerTest.php similarity index 58% rename from tests/unit/Stringifiers/NotANumberStringifierTest.php rename to tests/unit/Handlers/NotANumberHandlerTest.php index f89aa7f..a433979 100644 --- a/tests/unit/Stringifiers/NotANumberStringifierTest.php +++ b/tests/unit/Handlers/NotANumberHandlerTest.php @@ -8,35 +8,35 @@ declare(strict_types=1); -namespace Respect\Stringifier\Test\Unit\Stringifiers; +namespace Respect\Stringifier\Test\Unit\Handlers; use PHPUnit\Framework\Attributes\CoversClass; use PHPUnit\Framework\Attributes\Test; use PHPUnit\Framework\TestCase; -use Respect\Stringifier\Stringifiers\NotANumberStringifier; +use Respect\Stringifier\Handlers\NotANumberHandler; use Respect\Stringifier\Test\Double\FakeQuoter; use function acos; -#[CoversClass(NotANumberStringifier::class)] -final class NotANumberStringifierTest extends TestCase +#[CoversClass(NotANumberHandler::class)] +final class NotANumberHandlerTest extends TestCase { private const int DEPTH = 0; #[Test] public function itShouldNotStringifyRawValueWhenItIsNotFloat(): void { - $sut = new NotANumberStringifier(new FakeQuoter()); + $sut = new NotANumberHandler(new FakeQuoter()); - self::assertNull($sut->stringify('string', self::DEPTH)); + self::assertNull($sut->handle('string', self::DEPTH)); } #[Test] public function itShouldNotStringifyRawValueWhenItIsNumber(): void { - $sut = new NotANumberStringifier(new FakeQuoter()); + $sut = new NotANumberHandler(new FakeQuoter()); - self::assertNull($sut->stringify(1.00000000002, self::DEPTH)); + self::assertNull($sut->handle(1.00000000002, self::DEPTH)); } #[Test] @@ -44,9 +44,9 @@ public function itShouldStringifyRawValueWhenItIsNotNumber(): void { $quoter = new FakeQuoter(); - $sut = new NotANumberStringifier($quoter); + $sut = new NotANumberHandler($quoter); - $actual = $sut->stringify(acos(8), self::DEPTH); + $actual = $sut->handle(acos(8), self::DEPTH); $expected = $quoter->quote('NaN', self::DEPTH); self::assertSame($expected, $actual); diff --git a/tests/unit/Stringifiers/NullStringifierTest.php b/tests/unit/Handlers/NullHandlerTest.php similarity index 63% rename from tests/unit/Stringifiers/NullStringifierTest.php rename to tests/unit/Handlers/NullHandlerTest.php index b09a89e..096f160 100644 --- a/tests/unit/Stringifiers/NullStringifierTest.php +++ b/tests/unit/Handlers/NullHandlerTest.php @@ -8,25 +8,25 @@ declare(strict_types=1); -namespace Respect\Stringifier\Test\Unit\Stringifiers; +namespace Respect\Stringifier\Test\Unit\Handlers; use PHPUnit\Framework\Attributes\CoversClass; use PHPUnit\Framework\Attributes\Test; use PHPUnit\Framework\TestCase; -use Respect\Stringifier\Stringifiers\NullStringifier; +use Respect\Stringifier\Handlers\NullHandler; use Respect\Stringifier\Test\Double\FakeQuoter; -#[CoversClass(NullStringifier::class)] -final class NullStringifierTest extends TestCase +#[CoversClass(NullHandler::class)] +final class NullHandlerTest extends TestCase { private const int DEPTH = 0; #[Test] public function itShouldNotStringifyRawValueWhenItIsNotNull(): void { - $sut = new NullStringifier(new FakeQuoter()); + $sut = new NullHandler(new FakeQuoter()); - self::assertNull($sut->stringify(1, self::DEPTH)); + self::assertNull($sut->handle(1, self::DEPTH)); } #[Test] @@ -34,9 +34,9 @@ public function itShouldStringifyRawValueWhenItIsNull(): void { $quoter = new FakeQuoter(); - $sut = new NullStringifier($quoter); + $sut = new NullHandler($quoter); - $actual = $sut->stringify(null, self::DEPTH); + $actual = $sut->handle(null, self::DEPTH); $expected = $quoter->quote('null', self::DEPTH); self::assertSame($expected, $actual); diff --git a/tests/unit/Stringifiers/ObjectStringifierTest.php b/tests/unit/Handlers/ObjectHandlerTest.php similarity index 67% rename from tests/unit/Stringifiers/ObjectStringifierTest.php rename to tests/unit/Handlers/ObjectHandlerTest.php index 137db3b..db31e19 100644 --- a/tests/unit/Stringifiers/ObjectStringifierTest.php +++ b/tests/unit/Handlers/ObjectHandlerTest.php @@ -8,16 +8,16 @@ declare(strict_types=1); -namespace Respect\Stringifier\Test\Unit\Stringifiers; +namespace Respect\Stringifier\Test\Unit\Handlers; use PHPUnit\Framework\Attributes\CoversClass; use PHPUnit\Framework\Attributes\Test; use PHPUnit\Framework\TestCase; use ReflectionClass; use ReflectionObject; -use Respect\Stringifier\Stringifiers\ObjectStringifier; +use Respect\Stringifier\Handlers\ObjectHandler; +use Respect\Stringifier\Test\Double\FakeHandler; use Respect\Stringifier\Test\Double\FakeQuoter; -use Respect\Stringifier\Test\Double\FakeStringifier; use SplStack; use stdClass; use WithProperties; @@ -26,8 +26,8 @@ use function assert; use function sprintf; -#[CoversClass(ObjectStringifier::class)] -final class ObjectStringifierTest extends TestCase +#[CoversClass(ObjectHandler::class)] +final class ObjectHandlerTest extends TestCase { private const int DEPTH = 0; private const int MAXIMUM_DEPTH = 4; @@ -36,14 +36,14 @@ final class ObjectStringifierTest extends TestCase #[Test] public function itShouldNotStringifyRawValueWhenItIsNotAnObject(): void { - $sut = new ObjectStringifier( - new FakeStringifier(), + $sut = new ObjectHandler( + new FakeHandler(), new FakeQuoter(), self::MAXIMUM_DEPTH, self::MAXIMUM_NUMBER_OF_PROPERTIES, ); - self::assertNull($sut->stringify(true, self::DEPTH)); + self::assertNull($sut->handle(true, self::DEPTH)); } #[Test] @@ -51,12 +51,12 @@ public function itShouldStringifyRawValueWhenItIsAnObjectWithoutProperties(): vo { $raw = new stdClass(); - $stringifier = new FakeStringifier(); + $stringifier = new FakeHandler(); $quoter = new FakeQuoter(); - $sut = new ObjectStringifier($stringifier, $quoter, self::MAXIMUM_DEPTH, self::MAXIMUM_NUMBER_OF_PROPERTIES); + $sut = new ObjectHandler($stringifier, $quoter, self::MAXIMUM_DEPTH, self::MAXIMUM_NUMBER_OF_PROPERTIES); - $actual = $sut->stringify($raw, self::DEPTH); + $actual = $sut->handle($raw, self::DEPTH); $expected = $quoter->quote('stdClass {}', self::DEPTH); self::assertSame($expected, $actual); @@ -67,23 +67,23 @@ public function itShouldStringifyRawValueWhenItIsAnObjectWithProperties(): void { $raw = new WithProperties(); - $stringifier = new FakeStringifier(); + $stringifier = new FakeHandler(); $quoter = new FakeQuoter(); - $sut = new ObjectStringifier($stringifier, $quoter, self::MAXIMUM_DEPTH, self::MAXIMUM_NUMBER_OF_PROPERTIES); + $sut = new ObjectHandler($stringifier, $quoter, self::MAXIMUM_DEPTH, self::MAXIMUM_NUMBER_OF_PROPERTIES); $relection = new ReflectionObject($raw); $parentReflection = $relection->getParentClass(); assert($parentReflection instanceof ReflectionClass); - $actual = $sut->stringify($raw, self::DEPTH); + $actual = $sut->handle($raw, self::DEPTH); $expected = $quoter->quote( sprintf( '%s { +$publicProperty=%s #$protectedProperty=%s -$privateProperty=%s }', $relection->getName(), - $stringifier->stringify($relection->getProperty('publicProperty')->getValue($raw), self::DEPTH + 1), - $stringifier->stringify($relection->getProperty('protectedProperty')->getValue($raw), self::DEPTH + 1), - $stringifier->stringify( + $stringifier->handle($relection->getProperty('publicProperty')->getValue($raw), self::DEPTH + 1), + $stringifier->handle($relection->getProperty('protectedProperty')->getValue($raw), self::DEPTH + 1), + $stringifier->handle( $parentReflection->getProperty('privateProperty')->getValue($raw), self::DEPTH + 1, ), @@ -99,14 +99,14 @@ public function itShouldStringifyRawValueWhenItIsAnObjectWithUninitializedProper { $raw = new WithUninitializedProperties(); - $stringifier = new FakeStringifier(); + $stringifier = new FakeHandler(); $quoter = new FakeQuoter(); - $sut = new ObjectStringifier($stringifier, $quoter, self::MAXIMUM_DEPTH, self::MAXIMUM_NUMBER_OF_PROPERTIES); + $sut = new ObjectHandler($stringifier, $quoter, self::MAXIMUM_DEPTH, self::MAXIMUM_NUMBER_OF_PROPERTIES); $relection = new ReflectionObject($raw); - $actual = $sut->stringify($raw, self::DEPTH); + $actual = $sut->handle($raw, self::DEPTH); $expected = $quoter->quote( sprintf( '%s { +$uninitializedProperty=%s }', @@ -130,24 +130,24 @@ public function itShouldStringifyRawValueWhenItIsAnObjectWithPropertiesThatAreOb $raw->b->d->e = []; $raw->b->d->f = new stdClass(); - $stringifier = new FakeStringifier(); + $stringifier = new FakeHandler(); $quoter = new FakeQuoter(); - $sut = new ObjectStringifier($stringifier, $quoter, self::MAXIMUM_DEPTH, self::MAXIMUM_NUMBER_OF_PROPERTIES); + $sut = new ObjectHandler($stringifier, $quoter, self::MAXIMUM_DEPTH, self::MAXIMUM_NUMBER_OF_PROPERTIES); - $actual = $sut->stringify($raw, self::DEPTH); + $actual = $sut->handle($raw, self::DEPTH); $expected = $quoter->quote( sprintf( 'stdClass { +$a=%s +$b=%s }', - $stringifier->stringify($raw->a, self::DEPTH + 1), + $stringifier->handle($raw->a, self::DEPTH + 1), $quoter->quote( sprintf( 'stdClass { +$c=%s +$d=%s }', - $stringifier->stringify($raw->b->c, self::DEPTH + 2), + $stringifier->handle($raw->b->c, self::DEPTH + 2), $quoter->quote( sprintf( 'stdClass { +$e=%s +$f=%s }', - $stringifier->stringify($raw->b->d->e, self::DEPTH + 3), + $stringifier->handle($raw->b->d->e, self::DEPTH + 3), $quoter->quote('stdClass {}', self::DEPTH + 3), ), self::DEPTH + 2, @@ -168,14 +168,14 @@ public function itShouldStringifyRawValueWithPlaceholderWhenItReachesTheMaximumD $raw = new stdClass(); $raw->property = $raw; - $stringifier = new FakeStringifier(); + $stringifier = new FakeHandler(); $quoter = new FakeQuoter(); $maximumDepth = self::DEPTH + 3; - $sut = new ObjectStringifier($stringifier, $quoter, $maximumDepth, self::MAXIMUM_NUMBER_OF_PROPERTIES); + $sut = new ObjectHandler($stringifier, $quoter, $maximumDepth, self::MAXIMUM_NUMBER_OF_PROPERTIES); - $actual = $sut->stringify($raw, self::DEPTH); + $actual = $sut->handle($raw, self::DEPTH); $expected = $quoter->quote( sprintf( 'stdClass { +$property=%s }', @@ -208,20 +208,20 @@ public function itShouldStringifyRawValueWithPlaceholderWhenItReachesLimitOfItem $raw->c = 3; $raw->d = 4; - $stringifier = new FakeStringifier(); + $stringifier = new FakeHandler(); $quoter = new FakeQuoter(); $itemsLimit = 3; - $sut = new ObjectStringifier($stringifier, $quoter, self::MAXIMUM_DEPTH, $itemsLimit); + $sut = new ObjectHandler($stringifier, $quoter, self::MAXIMUM_DEPTH, $itemsLimit); - $actual = $sut->stringify($raw, self::DEPTH); + $actual = $sut->handle($raw, self::DEPTH); $expected = $quoter->quote( sprintf( 'stdClass { +$a=%s +$b=%s +$c=%s ... }', - $stringifier->stringify($raw->a, self::DEPTH + 1), - $stringifier->stringify($raw->b, self::DEPTH + 1), - $stringifier->stringify($raw->c, self::DEPTH + 1), + $stringifier->handle($raw->a, self::DEPTH + 1), + $stringifier->handle($raw->b, self::DEPTH + 1), + $stringifier->handle($raw->c, self::DEPTH + 1), ), self::DEPTH, ); @@ -236,16 +236,16 @@ public function itShouldStringifyRawValueWhenItIsAnAnonymousClass(): void public int $foo = 1; }; - $stringifier = new FakeStringifier(); + $stringifier = new FakeHandler(); $quoter = new FakeQuoter(); - $sut = new ObjectStringifier($stringifier, $quoter, self::MAXIMUM_DEPTH, self::MAXIMUM_NUMBER_OF_PROPERTIES); + $sut = new ObjectHandler($stringifier, $quoter, self::MAXIMUM_DEPTH, self::MAXIMUM_NUMBER_OF_PROPERTIES); - $actual = $sut->stringify($raw, self::DEPTH); + $actual = $sut->handle($raw, self::DEPTH); $expected = $quoter->quote( sprintf( 'class { +$foo=%s }', - $stringifier->stringify($raw->foo, self::DEPTH + 1), + $stringifier->handle($raw->foo, self::DEPTH + 1), ), self::DEPTH, ); @@ -261,14 +261,14 @@ public function itShouldStringifyRawValueWhenItIsAnAnonymousClassExtendingAnothe $quoter = new FakeQuoter(); - $sut = new ObjectStringifier( - new FakeStringifier(), + $sut = new ObjectHandler( + new FakeHandler(), $quoter, self::MAXIMUM_DEPTH, self::MAXIMUM_NUMBER_OF_PROPERTIES, ); - $actual = $sut->stringify($raw, self::DEPTH); + $actual = $sut->handle($raw, self::DEPTH); $expected = $quoter->quote('SplStack@anonymous {}', self::DEPTH); self::assertSame($expected, $actual); diff --git a/tests/unit/Stringifiers/ObjectWithDebugInfoStringifierTest.php b/tests/unit/Handlers/ObjectWithDebugInfoHandlerTest.php similarity index 56% rename from tests/unit/Stringifiers/ObjectWithDebugInfoStringifierTest.php rename to tests/unit/Handlers/ObjectWithDebugInfoHandlerTest.php index aa6e3b7..603ea77 100644 --- a/tests/unit/Stringifiers/ObjectWithDebugInfoStringifierTest.php +++ b/tests/unit/Handlers/ObjectWithDebugInfoHandlerTest.php @@ -8,30 +8,30 @@ declare(strict_types=1); -namespace Respect\Stringifier\Test\Unit\Stringifiers; +namespace Respect\Stringifier\Test\Unit\Handlers; use PHPUnit\Framework\Attributes\CoversClass; use PHPUnit\Framework\Attributes\Test; use PHPUnit\Framework\TestCase; -use Respect\Stringifier\Stringifiers\ObjectWithDebugInfoStringifier; +use Respect\Stringifier\Handlers\ObjectWithDebugInfoHandler; +use Respect\Stringifier\Test\Double\FakeHandler; use Respect\Stringifier\Test\Double\FakeQuoter; -use Respect\Stringifier\Test\Double\FakeStringifier; use stdClass; use WithDebugInfo; use function sprintf; -#[CoversClass(ObjectWithDebugInfoStringifier::class)] -final class ObjectWithDebugInfoStringifierTest extends TestCase +#[CoversClass(ObjectWithDebugInfoHandler::class)] +final class ObjectWithDebugInfoHandlerTest extends TestCase { private const int DEPTH = 0; #[Test] public function itShouldNotStringifyRawValueWhenItIsNotAnObjectWithDebugInfo(): void { - $sut = new ObjectWithDebugInfoStringifier(new FakeStringifier(), new FakeQuoter()); + $sut = new ObjectWithDebugInfoHandler(new FakeHandler(), new FakeQuoter()); - self::assertNull($sut->stringify(new stdClass(), self::DEPTH)); + self::assertNull($sut->handle(new stdClass(), self::DEPTH)); } #[Test] @@ -39,14 +39,14 @@ public function itShouldStringifyRawValueWhenItIsAnObjectWithDebugInfo(): void { $raw = new WithDebugInfo(); - $stringifier = new FakeStringifier(); + $stringifier = new FakeHandler(); $quoter = new FakeQuoter(); - $string = $stringifier->stringify($raw->__debugInfo(), self::DEPTH + 1); + $string = $stringifier->handle($raw->__debugInfo(), self::DEPTH + 1); - $sut = new ObjectWithDebugInfoStringifier($stringifier, $quoter); + $sut = new ObjectWithDebugInfoHandler($stringifier, $quoter); - $actual = $sut->stringify($raw, self::DEPTH); + $actual = $sut->handle($raw, self::DEPTH); $expected = $quoter->quote( sprintf('%s { __debugInfo() => %s }', WithDebugInfo::class, $string), self::DEPTH, diff --git a/tests/unit/Stringifiers/ResourceStringifierTest.php b/tests/unit/Handlers/ResourceHandlerTest.php similarity index 63% rename from tests/unit/Stringifiers/ResourceStringifierTest.php rename to tests/unit/Handlers/ResourceHandlerTest.php index 91a26f9..356aaa6 100644 --- a/tests/unit/Stringifiers/ResourceStringifierTest.php +++ b/tests/unit/Handlers/ResourceHandlerTest.php @@ -8,27 +8,27 @@ declare(strict_types=1); -namespace Respect\Stringifier\Test\Unit\Stringifiers; +namespace Respect\Stringifier\Test\Unit\Handlers; use PHPUnit\Framework\Attributes\CoversClass; use PHPUnit\Framework\Attributes\Test; use PHPUnit\Framework\TestCase; -use Respect\Stringifier\Stringifiers\ResourceStringifier; +use Respect\Stringifier\Handlers\ResourceHandler; use Respect\Stringifier\Test\Double\FakeQuoter; use function tmpfile; -#[CoversClass(ResourceStringifier::class)] -final class ResourceStringifierTest extends TestCase +#[CoversClass(ResourceHandler::class)] +final class ResourceHandlerTest extends TestCase { private const int DEPTH = 0; #[Test] public function itShouldNotStringifyRawValueWhenItIsNotOfTypeResource(): void { - $sut = new ResourceStringifier(new FakeQuoter()); + $sut = new ResourceHandler(new FakeQuoter()); - self::assertNull($sut->stringify(true, self::DEPTH)); + self::assertNull($sut->handle(true, self::DEPTH)); } #[Test] @@ -36,9 +36,9 @@ public function itShouldStringifyRawValueWhenItIsOfTypeResource(): void { $quoter = new FakeQuoter(); - $sut = new ResourceStringifier($quoter); + $sut = new ResourceHandler($quoter); - $actual = $sut->stringify(tmpfile(), self::DEPTH); + $actual = $sut->handle(tmpfile(), self::DEPTH); $expected = $quoter->quote('resource ', self::DEPTH); self::assertSame($expected, $actual); diff --git a/tests/unit/Stringifiers/StringableObjectStringifierTest.php b/tests/unit/Handlers/StringableObjectHandlerTest.php similarity index 57% rename from tests/unit/Stringifiers/StringableObjectStringifierTest.php rename to tests/unit/Handlers/StringableObjectHandlerTest.php index ff2228c..c48b61e 100644 --- a/tests/unit/Stringifiers/StringableObjectStringifierTest.php +++ b/tests/unit/Handlers/StringableObjectHandlerTest.php @@ -8,30 +8,30 @@ declare(strict_types=1); -namespace Respect\Stringifier\Test\Unit\Stringifiers; +namespace Respect\Stringifier\Test\Unit\Handlers; use ConcreteStringable; use PHPUnit\Framework\Attributes\CoversClass; use PHPUnit\Framework\Attributes\Test; use PHPUnit\Framework\TestCase; -use Respect\Stringifier\Stringifiers\StringableObjectStringifier; +use Respect\Stringifier\Handlers\StringableObjectHandler; +use Respect\Stringifier\Test\Double\FakeHandler; use Respect\Stringifier\Test\Double\FakeQuoter; -use Respect\Stringifier\Test\Double\FakeStringifier; use stdClass; use function sprintf; -#[CoversClass(StringableObjectStringifier::class)] -final class StringableObjectStringifierTest extends TestCase +#[CoversClass(StringableObjectHandler::class)] +final class StringableObjectHandlerTest extends TestCase { private const int DEPTH = 0; #[Test] public function itShouldNotStringifyRawValueWhenItIsNotAnInstanceOfStringable(): void { - $sut = new StringableObjectStringifier(new FakeStringifier(), new FakeQuoter()); + $sut = new StringableObjectHandler(new FakeHandler(), new FakeQuoter()); - self::assertNull($sut->stringify(new stdClass(), self::DEPTH)); + self::assertNull($sut->handle(new stdClass(), self::DEPTH)); } #[Test] @@ -39,14 +39,14 @@ public function itShouldStringifyRawValueWhenItIsAnInstanceOfStringable(): void { $raw = new ConcreteStringable(); - $stringifier = new FakeStringifier(); + $stringifier = new FakeHandler(); $quoter = new FakeQuoter(); - $string = $stringifier->stringify($raw->__toString(), self::DEPTH + 1); + $string = $stringifier->handle($raw->__toString(), self::DEPTH + 1); - $sut = new StringableObjectStringifier($stringifier, $quoter); + $sut = new StringableObjectHandler($stringifier, $quoter); - $actual = $sut->stringify($raw, self::DEPTH); + $actual = $sut->handle($raw, self::DEPTH); $expected = $quoter->quote( sprintf('%s { __toString() => %s }', ConcreteStringable::class, $string), self::DEPTH, diff --git a/tests/unit/Stringifiers/ThrowableObjectStringifierTest.php b/tests/unit/Handlers/ThrowableObjectHandlerTest.php similarity index 68% rename from tests/unit/Stringifiers/ThrowableObjectStringifierTest.php rename to tests/unit/Handlers/ThrowableObjectHandlerTest.php index 4758cdb..c24842a 100644 --- a/tests/unit/Stringifiers/ThrowableObjectStringifierTest.php +++ b/tests/unit/Handlers/ThrowableObjectHandlerTest.php @@ -8,7 +8,7 @@ declare(strict_types=1); -namespace Respect\Stringifier\Test\Unit\Stringifiers; +namespace Respect\Stringifier\Test\Unit\Handlers; use DomainException; use Error; @@ -19,9 +19,9 @@ use PHPUnit\Framework\Attributes\DataProvider; use PHPUnit\Framework\Attributes\Test; use PHPUnit\Framework\TestCase; -use Respect\Stringifier\Stringifiers\ThrowableObjectStringifier; +use Respect\Stringifier\Handlers\ThrowableObjectHandler; +use Respect\Stringifier\Test\Double\FakeHandler; use Respect\Stringifier\Test\Double\FakeQuoter; -use Respect\Stringifier\Test\Double\FakeStringifier; use RuntimeException; use stdClass; use Throwable; @@ -29,34 +29,34 @@ use function sprintf; -#[CoversClass(ThrowableObjectStringifier::class)] -final class ThrowableObjectStringifierTest extends TestCase +#[CoversClass(ThrowableObjectHandler::class)] +final class ThrowableObjectHandlerTest extends TestCase { private const int DEPTH = 0; #[Test] public function isShouldNotStringifyRawValueWhenItIsNotThrowable(): void { - $sut = new ThrowableObjectStringifier(new FakeStringifier(), new FakeQuoter()); + $sut = new ThrowableObjectHandler(new FakeHandler(), new FakeQuoter()); - self::assertNull($sut->stringify(new stdClass(), self::DEPTH)); + self::assertNull($sut->handle(new stdClass(), self::DEPTH)); } #[Test] #[DataProvider('throwableWithMessageProvider')] public function itShouldStringifyRawValueWhenItIsThrowableWithMessage(Throwable $raw): void { - $stringifier = new FakeStringifier(); + $stringifier = new FakeHandler(); $quoter = new FakeQuoter(); - $sut = new ThrowableObjectStringifier($stringifier, $quoter); + $sut = new ThrowableObjectHandler($stringifier, $quoter); - $actual = $sut->stringify($raw, self::DEPTH); + $actual = $sut->handle($raw, self::DEPTH); $expectedValue = $quoter->quote( sprintf( - '%s { %s in tests/unit/Stringifiers/ThrowableObjectStringifierTest.php:%d }', + '%s { %s in tests/unit/Handlers/ThrowableObjectHandlerTest.php:%d }', $raw::class, - $stringifier->stringify($raw->getMessage(), self::DEPTH + 1), + $stringifier->handle($raw->getMessage(), self::DEPTH + 1), $raw->getLine(), ), self::DEPTH, @@ -69,15 +69,15 @@ public function itShouldStringifyRawValueWhenItIsThrowableWithMessage(Throwable #[DataProvider('throwableWithoutMessageProvider')] public function itShouldStringifyRawValueWhenItIsThrowableWithoutMessage(Throwable $raw): void { - $stringifier = new FakeStringifier(); + $stringifier = new FakeHandler(); $quoter = new FakeQuoter(); - $sut = new ThrowableObjectStringifier($stringifier, $quoter); + $sut = new ThrowableObjectHandler($stringifier, $quoter); - $actual = $sut->stringify($raw, self::DEPTH); + $actual = $sut->handle($raw, self::DEPTH); $expectedValue = $quoter->quote( sprintf( - '%s { in tests/unit/Stringifiers/ThrowableObjectStringifierTest.php:%d }', + '%s { in tests/unit/Handlers/ThrowableObjectHandlerTest.php:%d }', $raw::class, $raw->getLine(), ), diff --git a/tests/unit/Stringifiers/CompositeStringifierTest.php b/tests/unit/Stringifiers/CompositeStringifierTest.php deleted file mode 100644 index 22b1806..0000000 --- a/tests/unit/Stringifiers/CompositeStringifierTest.php +++ /dev/null @@ -1,78 +0,0 @@ - - * SPDX-License-Identifier: MIT - */ - -declare(strict_types=1); - -namespace Respect\Stringifier\Test\Unit\Stringifiers; - -use PHPUnit\Framework\Attributes\CoversClass; -use PHPUnit\Framework\Attributes\Test; -use PHPUnit\Framework\TestCase; -use Respect\Stringifier\Stringifiers\CompositeStringifier; -use Respect\Stringifier\Test\Double\FakeStringifier; -use Respect\Stringifier\Test\Double\LameStringifier; -use stdClass; - -#[CoversClass(CompositeStringifier::class)] -final class CompositeStringifierTest extends TestCase -{ - private const int DEPTH = 0; - - #[Test] - public function itShouldNotStringifyRawValueWhenThereAreNoStringifiersDefined(): void - { - $sut = new CompositeStringifier(); - - self::assertNull($sut->stringify(new stdClass(), self::DEPTH)); - } - - #[Test] - public function itShouldStringifyRawValueByTryingToUseAllStringifiersUntilOneCanStringifyIt(): void - { - $raw = new stdClass(); - - $stringifier = new FakeStringifier(); - - $sut = new CompositeStringifier(new LameStringifier(), new LameStringifier(), $stringifier); - - $actual = $sut->stringify(new stdClass(), self::DEPTH); - $expected = $stringifier->stringify($raw, self::DEPTH); - - self::assertSame($expected, $actual); - } - - #[Test] - public function itShouldStringifyRawValueStartingWithTheLastPrependedStringifier(): void - { - $raw = new stdClass(); - - $stringifier = new FakeStringifier(); - - $sut = new CompositeStringifier(new LameStringifier(), new LameStringifier()); - $sut->prependStringifier($stringifier); - - $actual = $sut->stringify(new stdClass(), self::DEPTH); - $expected = $stringifier->stringify($raw, self::DEPTH); - - self::assertSame($expected, $actual); - } - - #[Test] - public function itShouldNotStringifyWhenNoneOfTheStringifiersCanStringify(): void - { - $sut = new CompositeStringifier(new LameStringifier(), new LameStringifier(), new LameStringifier()); - - self::assertNull($sut->stringify(new stdClass(), self::DEPTH)); - } - - #[Test] - public function itShouldCreateDefaultCompositeStringifier(): void - { - self::assertInstanceOf(CompositeStringifier::class, CompositeStringifier::createDefault()); - } -} diff --git a/tests/unit/StringifyTest.php b/tests/unit/StringifyTest.php deleted file mode 100644 index 6a5e0b6..0000000 --- a/tests/unit/StringifyTest.php +++ /dev/null @@ -1,72 +0,0 @@ - - * SPDX-License-Identifier: MIT - */ - -declare(strict_types=1); - -namespace Respect\Stringifier\Test\Unit; - -use PHPUnit\Framework\Attributes\CoversClass; -use PHPUnit\Framework\Attributes\Test; -use PHPUnit\Framework\TestCase; -use Respect\Stringifier\Stringify; -use Respect\Stringifier\Test\Double\FakeStringifier; -use Respect\Stringifier\Test\Double\LameStringifier; -use stdClass; - -use function print_r; - -#[CoversClass(Stringify::class)] -final class StringifyTest extends TestCase -{ - #[Test] - public function itShouldStringifyRawValueWithTheGivenStringifier(): void - { - $raw = new stdClass(); - - $stringifier = new FakeStringifier(); - - $sut = new Stringify($stringifier); - - $actual = $sut->value($raw); - $expected = $stringifier->stringify($raw, Stringify::STARTING_DEPTH); - - self::assertSame($expected, $actual); - } - - #[Test] - public function itShouldStringifyRawValueEvenIfTheGivenStringifierCannotStringify(): void - { - $raw = new stdClass(); - - $sut = new Stringify(new LameStringifier()); - - $actual = $sut->value($raw); - $expected = print_r($raw, true); - - self::assertSame($expected, $actual); - } - - #[Test] - public function itShouldStringifyRawValueViaInvokeMethod(): void - { - $raw = new stdClass(); - - $sut = new Stringify(new LameStringifier()); - - $actual = $sut($raw); - $expected = print_r($raw, true); - - self::assertSame($expected, $actual); - } - - #[Test] - public function itShouldCreateDefaultStringifyObject(): void - { - self::assertInstanceOf(Stringify::class, Stringify::createDefault()); - } -}