vendor/spatie/data-transfer-object/src/DocblockFieldValidator.php line 49

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Spatie\DataTransferObject;
  7. use RecursiveArrayIterator;
  8. use RecursiveIteratorIterator;
  10. class DocblockFieldValidator extends FieldValidator
  11. {
  12. public const DOCBLOCK_REGEX = <<<REGEXP
  13. /
  14. @var ( # Starting with `@var `, we'll capture the definition the follows
  16. (?: # Not explicitly capturing this group,
  17. # which contains repeated sets of type definitions
  19. (?: # Not explicitly capturing this group
  20. [\w?|\\\\<>,\s] # Matches type definitions like `int|string|\My\Object|array<int, string>`
  21. )+ # These definitions can be repeated
  23. (?: # Not explicitly capturing this group
  24. \[] # Matches array definitions like `int[]`
  25. )? # Array definitions are optional though
  27. )+ # Repeated sets of type definitions
  29. ) # The whole definition after `@var ` is captured in one group
  30. /x
  31. REGEXP;
  33. public function __construct(string $definition, bool $hasDefaultValue = false)
  34. {
  35. preg_match(
  36. DocblockFieldValidator::DOCBLOCK_REGEX,
  37. $definition,
  38. $matches
  39. );
  41. $definition = trim($matches[1] ?? '');
  43. $this->hasTypeDeclaration = $definition !== '';
  44. $this->hasDefaultValue = $hasDefaultValue;
  45. $this->isNullable = $this->resolveNullable($definition);
  46. $this->isMixed = $this->resolveIsMixed($definition);
  47. $this->isMixedArray = $this->resolveIsMixedArray($definition);
  48. $this->allowedTypes = $this->resolveAllowedTypes($definition);
  49. $this->allowedArrayTypes = $this->resolveAllowedArrayTypes($definition);
  50. $this->allowedArrayKeyTypes = $this->resolveAllowedArrayKeyTypes($definition);
  51. }
  53. private function resolveNullable(string $definition): bool
  54. {
  55. if (! $definition) {
  56. return true;
  57. }
  59. if (Str::contains($definition, ['mixed', 'null', '?'])) {
  60. return true;
  61. }
  63. return false;
  64. }
  66. private function resolveIsMixed(string $definition): bool
  67. {
  68. return Str::contains($definition, ['mixed']);
  69. }
  71. private function resolveIsMixedArray(string $definition): bool
  72. {
  73. $types = $this->normaliseTypes(...explode('|', $definition));
  75. foreach ($types as $type) {
  76. if (in_array($type, ['iterable', 'array'])) {
  77. return true;
  78. }
  79. }
  81. return false;
  82. }
  84. private function resolveAllowedTypes(string $definition): array
  85. {
  86. return $this->normaliseTypes(...explode('|', $definition));
  87. }
  89. private function resolveAllowedArrayTypes(string $definition): array
  90. {
  91. // Iterators flatten the array for multiple return types from DataTransferObjectCollection::current
  92. return $this->normaliseTypes(...(new RecursiveIteratorIterator(new RecursiveArrayIterator(array_map(
  93. function (string $type) {
  94. if (! $type) {
  95. return;
  96. }
  98. if (strpos($type, '[]') !== false) {
  99. return str_replace('[]', '', $type);
  100. }
  102. if (strpos($type, '>') !== false) {
  103. preg_match('/([\w\\\\]+)(>)/', $type, $matches);
  105. return $matches[1];
  106. }
  108. if (is_subclass_of($type, DataTransferObjectCollection::class)) {
  109. return $this->resolveAllowedArrayTypesFromCollection($type);
  110. }
  112. return null;
  113. },
  114. explode('|', $definition)
  115. )))));
  116. }
  118. private function resolveAllowedArrayKeyTypes(string $definition): array
  119. {
  120. return $this->normaliseTypes(...array_map(
  121. function (string $type) {
  122. if (strpos($type, '<') === false) {
  123. return;
  124. }
  126. preg_match('/(<)([\w\\\\]+)(,)/', $type, $matches);
  128. return $matches[2] ?? null;
  129. },
  130. explode('|', $definition)
  131. ));
  132. }
  133. }