The PropertyInfo Component

Extractor Ordering

The order of extractor instances within an array matters: the first non-null result will be returned. That is why you must provide each category of extractors as a separate array, even if an extractor provides information for more than one category.

For example, while the ReflectionExtractor and DoctrineExtractor both provide list and type information it is probably better that:

• The ReflectionExtractor has priority for list information so that all properties in a class (not just mapped properties) are returned.

• The DoctrineExtractor has priority for type information so that entity metadata is used instead of type-hinting to provide more accurate type information:

  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19

  use Symfony\Bridge\Doctrine\PropertyInfo\DoctrineExtractor;
  use Symfony\Component\PropertyInfo\Extractor\ReflectionExtractor;
  use Symfony\Component\PropertyInfo\PropertyInfoExtractor;
  
  $reflectionExtractor = new ReflectionExtractor();
  $doctrineExtractor = new DoctrineExtractor(/* ... */);
  
  $propertyInfo = new PropertyInfoExtractor(
      // List extractors
      [
          $reflectionExtractor,
          $doctrineExtractor
      ],
      // Type extractors
      [
          $doctrineExtractor,
          $reflectionExtractor
      ]
  );

List Information

Extractors that implement PropertyListExtractorInterface provide the list of properties that are available on a class as an array containing each property name as a string:

1
2
3
4
5
6
7
8
9
10

$properties = $propertyInfo->getProperties($class);
/*
    Example Result
    --------------
    array(3) {
        [0] => string(8) "username"
        [1] => string(8) "password"
        [2] => string(6) "active"
    }
*/

Type Information

Extractors that implement PropertyTypeExtractorInterface provide extensive data type information for a property:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

$types = $propertyInfo->getTypes($class, $property);
/*
    Example Result
    --------------
    array(1) {
        [0] =>
            class Symfony\Component\PropertyInfo\Type (6) {
            private $builtinType          => string(6) "string"
            private $nullable             => bool(false)
            private $class                => NULL
            private $collection           => bool(false)
            private $collectionKeyType    => NULL
            private $collectionValueType  => NULL
        }
    }
*/

See The PropertyInfo Component for info about the Type class.

Description Information

Extractors that implement PropertyDescriptionExtractorInterface provide long and short descriptions from a properties annotations as strings:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

$title = $propertyInfo->getShortDescription($class, $property);
/*
    Example Result
    --------------
    string(41) "This is the first line of the DocComment."
*/

$paragraph = $propertyInfo->getLongDescription($class, $property);
/*
    Example Result
    --------------
    string(79):
        These is the subsequent paragraph in the DocComment.
        It can span multiple lines.
*/

Access Information

Extractors that implement PropertyAccessExtractorInterface provide whether properties are readable or writable as booleans:

1
2
3
4
5

$propertyInfo->isReadable($class, $property);
// Example Result: bool(true)

$propertyInfo->isWritable($class, $property);
// Example Result: bool(false)

The ReflectionExtractor looks for getter/isser/setter method in addition to whether or not a property is public to determine if it's accessible.

This is based on how PropertyAccess works, so it even looks for adder/remover methods and can transform between singular and plural property names:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

use Acme\Entity\Analysis;

class SomeClass
{
    private $analyses;

    public function addAnalysis(Analysis $analysis)
    {
        // ...
    }

    public function removeAnalysis(Analysis $analysis)
    {
        // ...
    }
}

// to be writable, both the adder and the remover methods must be defined
$propertyInfo->isWritable(SomeClass::class, 'analyses'); // returns true

Type::getBuiltInType()

The Type::getBuiltinType() method returns the built-in PHP data type, which can be one of these string values: array, bool, callable, float, int, iterable, null, object, resource or string.

Constants inside the Type class, in the form Type::BUILTIN_TYPE_*, are provided for convenience.

Type::isNullable()

The Type::isNullable() method will return a boolean value indicating whether the property parameter can be set to null.

Type::getClassName()

If the built-in PHP data type is object, the Type::getClassName() method will return the fully-qualified class or interface name accepted.

Type::isCollection()

The Type::isCollection() method will return a boolean value indicating if the property parameter is a collection - a non-scalar value capable of containing other values. Currently this returns true if:

• The built-in PHP data type is array, or
• The mutator method the property is derived from has a prefix of add or remove (which are defined as the list of array mutator prefixes).

Type::getCollectionKeyType() & Type::getCollectionValueType()

If the property is a collection, additional type objects may be returned for both the key and value types of the collection (if the information is available), via the Type::getCollectionKeyType() and Type::getCollectionValueType() methods.

ReflectionExtractor

Using PHP reflection, the ReflectionExtractor provides list, type and access information from setter and accessor methods. It can also provide return and scalar types for PHP 7+:

1
2
3
4
5
6
7
8
9
10
11

use Symfony\Component\PropertyInfo\Extractor\ReflectionExtractor;

$reflectionExtractor = new ReflectionExtractor();

// List information.
$reflectionExtractor->getProperties($class);
// Type information.
$reflectionExtractor->getTypes($class, $property);
// Access information.
$reflectionExtractor->isReadable($class, $property);
$reflectionExtractor->isWritable($class, $property);

1
2
3
4

# app/config/config.yml
framework:
    property_info:
        enabled: true

PhpDocExtractor

Using phpDocumentor Reflection to parse property and method annotations, the PhpDocExtractor provides type and description information. This extractor is automatically registered with the property_info in the Symfony Framework if the dependent library is present:

1
2
3
4
5
6
7
8
9

use Symfony\Component\PropertyInfo\Extractor\PhpDocExtractor;

$phpDocExtractor = new PhpDocExtractor();

// Type information.
$phpDocExtractor->getTypes($class, $property);
// Description information.
$phpDocExtractor->getShortDescription($class, $property);
$phpDocExtractor->getLongDescription($class, $property);

SerializerExtractor

Using groups metadata from the Serializer component, the SerializerExtractor provides list information. This extractor is not registered automatically with the property_info service in the Symfony Framework:

1
2
3
4
5
6
7
8
9
10
11
12

use Doctrine\Common\Annotations\AnnotationReader;
use Symfony\Component\PropertyInfo\Extractor\SerializerExtractor;
use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactory;
use Symfony\Component\Serializer\Mapping\Loader\AnnotationLoader;

$serializerClassMetadataFactory = new ClassMetadataFactory(
    new AnnotationLoader(new AnnotationReader)
);
$serializerExtractor = new SerializerExtractor($serializerClassMetadataFactory);

// List information.
$serializerExtractor->getProperties($class);

DoctrineExtractor

Using entity mapping data from Doctrine ORM, the DoctrineExtractor provides list and type information. This extractor is not registered automatically with the property_info service in the Symfony Framework:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

use Doctrine\ORM\EntityManager;
use Doctrine\ORM\Tools\Setup;
use Symfony\Bridge\Doctrine\PropertyInfo\DoctrineExtractor;

$config = Setup::createAnnotationMetadataConfiguration([__DIR__], true);
$entityManager = EntityManager::create([
    'driver' => 'pdo_sqlite',
    // ...
], $config);
$doctrineExtractor = new DoctrineExtractor($entityManager->getMetadataFactory());

// List information.
$doctrineExtractor->getProperties($class);
// Type information.
$doctrineExtractor->getTypes($class, $property);