Arrayy\Property

Complexity

Total Complexity

42

Size/Duplication

Total Lines	228
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

74.43%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	assertTypeEquals()	0	14	5
A	checkType()	0	6	2
A	fromPhpDocumentorProperty()	0	29	5
A	getTypes()	0	4	1
A	isValidGenericCollection()	0	16	4
B	isValidType()	0	20	6
C	parseDocTypeObject()	0	58	14
A	throwInvalidType()	0	16	4

<?php

namespace Arrayy;

use phpDocumentor\Reflection\Type;

/**
 * Class Property
 *
 * inspired by https://github.com/spatie/value-object
 */
class Property extends \ReflectionProperty
{
  /**
   * @var array
   */
  protected static $typeMapping = [
      'int'  => 'integer',
      'bool' => 'boolean',
  ];

  /**
   * @var bool
   */
  protected $hasTypeDeclaration = false;

  /**
   * @var bool
   */
  protected $isNullable = false;

  /**
   * @var array
   */
  protected $types = [];

  /**
   * Property constructor.
   *
   * @param null|\ReflectionProperty $reflectionProperty
   * @param object                   $fakeObject
   *
   * @throws \ReflectionException
   */
  public function __construct($reflectionProperty, $fakeObject = null)
  {
    parent::__construct($fakeObject, $reflectionProperty->getName());

It seems like $reflectionProperty is not always an object, but can also be of type null. Maybe add an additional type check?

  }

  /**
   * @param string $type
   * @param mixed  $value
   *
   * @return bool
   */
  protected function assertTypeEquals(string $type, $value): bool
  {
    if (strpos($type, '[]') !== false) {
      return $this->isValidGenericCollection($type, $value);
    }

    if ($type === 'mixed' && $value !== null) {
      return true;
    }

    return $value instanceof $type
           ||
           \gettype($value) === (self::$typeMapping[$type] ?? $type);
  }

  public function checkType($value)
  {
    if (!$this->isValidType($value)) {
      $this->throwInvalidType($value);
    }
  }

  public static function fromPhpDocumentorProperty(\phpDocumentor\Reflection\DocBlock\Tags\Property $phpDocumentorReflectionProperty): self
  {
    $tmpProperty = $phpDocumentorReflectionProperty->getVariableName();
    $tmpObject = new \stdClass();
    $tmpObject->{$tmpProperty} = null;

    $tmpReflection = new self(new \ReflectionProperty($tmpObject, $tmpProperty), $tmpObject);

    $type = $phpDocumentorReflectionProperty->getType();

    if ($type) {
      $tmpReflection->hasTypeDeclaration = true;

      $docTypes = self::parseDocTypeObject($type);
      if (\is_array($docTypes) === true) {
        foreach ($docTypes as $docType) {
          $tmpReflection->types[] = $docType;
        }
      } else {
        $tmpReflection->types[] = $docTypes;
      }

      if (\in_array('null', $tmpReflection->types, true)) {
        $tmpReflection->isNullable = true;
      }
    }

    return $tmpReflection;
  }

  public function getTypes(): array
  {
    return $this->types;
  }

  protected function isValidGenericCollection(string $type, $collection): bool
  {
    if (!\is_array($collection)) {
      return false;
    }

    $valueType = \str_replace('[]', '', $type);

    foreach ($collection as $value) {
      if (!$this->assertTypeEquals($valueType, $value)) {
        return false;
      }
    }

    return true;
  }

  /**
   * @param mixed $value
   *
   * @return bool
   */
  protected function isValidType($value): bool
  {
    if (!$this->hasTypeDeclaration) {
      return true;
    }

    if ($this->isNullable && $value === null) {
      return true;
    }

    foreach ($this->types as $currentType) {
      $isValidType = $this->assertTypeEquals($currentType, $value);

      if ($isValidType) {
        return true;
      }
    }

    return false;
  }

  /**
   * @param Type $type
   *
   * @return string[]|string
   */
  protected static function parseDocTypeObject(Type $type)
  {
    if ($type instanceof \phpDocumentor\Reflection\Types\Object_) {
      return (string)$type->getFqsen();
    }

    if ($type instanceof \phpDocumentor\Reflection\Types\Array_) {
      $value = $type->getValueType();
      if ($value instanceof \phpDocumentor\Reflection\Types\Mixed_) {
        return 'mixed';
      }

      return 'array';
    }

    if ($type instanceof \phpDocumentor\Reflection\Types\Null_) {
      return 'null';
    }

    if ($type instanceof \phpDocumentor\Reflection\Types\Mixed_) {
      return 'mixed';
    }

    if ($type instanceof \phpDocumentor\Reflection\Types\Scalar) {
      return 'string|int|float|bool';
    }

    if ($type instanceof \phpDocumentor\Reflection\Types\Boolean) {
      return 'bool';
    }

    if ($type instanceof \phpDocumentor\Reflection\Types\Callable_) {
      return 'callable';
    }

    if ($type instanceof \phpDocumentor\Reflection\Types\Compound) {
      $types = [];
      foreach ($type as $subType) {
        $types[] = self::parseDocTypeObject($subType);
      }

      return $types;
    }

    if ($type instanceof \phpDocumentor\Reflection\Types\Float_) {
      return 'float';
    }

    if ($type instanceof \phpDocumentor\Reflection\Types\String_) {
      return 'string';
    }

    if ($type instanceof \phpDocumentor\Reflection\Types\Integer) {
      return 'int';
    }

    throw new \Exception('Unhandled PhpDoc type: ' . get_class($type));
  }

  /**
   * @param mixed $value
   */
  protected function throwInvalidType($value)
  {
    $type = \gettype($value);

    if ($type === 'NULL') {
      $value = 'null';
    } elseif ($type === 'object') {
      $value = \get_class($value);
    } elseif ($type === 'array') {
      $value = 'array';
    }

    $expectedTypes = \implode('|', $this->getTypes());

    throw new \InvalidArgumentException("Invalid type: expected {$this->name} to be of type {{$expectedTypes}}, instead got value `{$value}` with type {{$type}}.");
  }
}