I have a callback method that returns a DateTime object, which I'd like to normalize to specific formats on different places. Therefore I'd like to use:

@Bos\Normalize(type="datetime", format="Y-m-d", callback="getCalculatedDate")

But this completely ignores the callback method.

In my opinion the callback method must only act as an alternative source for the property data and not influence any other functionality.

Currently this normalizer works with an opt-in mechanism, that means you have to specifically indicate which properties or methods are normalized (with optional use of group).

It should be possible to indicate on class level (with optional group) to just normalize all properties in that class.

• Support for PHP 8.x should be added (should check up until which Symfony version can be used)
• Rector should be added to help refactoring and upgrade.
• Update bundle to use newer Symfony 4.x/5.x bundle structure
• Aim should be to keep versioning of this bundle in line with Symfony

(Investigation) More information on the bundles:

• https://github.com/symfony/symfony/blob/3.4/UPGRADE-4.0.md#symfony-framework
• https://github.com/symfony/symfony/blob/4.4/UPGRADE-4.4.md#httpkernel

Make analysis on which methods and properties: public, protected and private are normalized?
How many parent classes deep does it find methods and properties?

• I would expect all properties, (public, protected and private) will be normalized, from any parent class.
• I would expect all methods (public, protected and private) will be normalized, from any parent class.

Test (and update) compatibility with Symfony 3, 4 and > PHP 7.2

Adding maximal depth functionality on class and class property level.

Performance in production-mode can be greatly improved by caching the annotations between requests, just like the @route annotations in Symfony, as in production-mode the annotations are not expected to change. The annotations can be cached during cache:warmup in the Symfony cache folder.

Currently Symfony uses ArrayCache by default. We should write the annotations to the FileSystem cache instead. This should increase speed significantly.

Ideally I would like to identify classes without using getId(). There are scenario's where the class to be normalized does not have a getId() method!

When normalizing a doctrine proxy, the ID property of that object is reflected to a string. If the object is initialized, and not a proxy anymore, the value is (correctly) an integer.

Possible solution: If object doctrine proxy, use getId() instead of property reflection.

It should possible to indicate that properties or method that have no (normalize) group defined to always used.
So that if I normalize a class with a specific group, those properties are also taken into account.

Change in 2f3d8ba

Method reflection should fetch method of all parents, not just the first parent.

We can fix this by doing something like:

do {
    ...
} while ($reflectionClass = $reflectionClass->getParentClass());

To investigate.

A type="datetime" always needs a get method. The normalizer should always get the value from a property (if the normalize annotation is on the property).

When normalizing a 'datetime' property, the get() method is always used. If the method does not exist, a fatal error is thrown.

If a variable outputs @return int, make sure it's cast to, if possible.

I have an abstract:

abstract class AbstractPerson
{
    /**
     * @var string
     *
     * @Bos\Normalize(group={"parent_test"})
     */
    private $name = 'parent-foo';
}

I have a class that extends this abstract:

class Person extends AbstractPerson
{
    /**
     * @var string
     *
     * @Bos\Normalize(group={"parent_test"})
     */
    private $name;

    /**
     * @return $this
     */
    public function setName(string $name): self
    {
        $this->name = $name;

        return $this;
    }
}

When executing this unit test:

$person = (new Person())->setName('child-foo');

$this->assertSame(['name' => 'child-foo'], $this->normalizer->normalize($person, 'parent_test'));

Expected result: the value to be child-foo because this is the most concrete value.
Actual result: the normalized content is: parent-foo.

Add new module to support serializing of data.

To support:

• JSON
• XML

The README is large and it can be difficult to find that one annotation property. We should try to convert the README into a proper Wiki.

We need to be able to translate values.

This issue is more like a try-out; We should look into adding an option to support passing context to the normalizer.

This context can contain, next to the group, an option that has property names that should be included. When passing this option the max_depth is set to 0.

Currently the normalized data is cached within the same session. If a new application session starts, the normalizer needs to re-normalize all the methods and properties.

Is there a way to keep the normalized data over application sessions?

(Cache data with the Symfony cache interface?)

The result of a method should also be available so dummy properties (that only serve as a holder for a callback method) are not needed anymore.

This issue suggests to add support for a passdownGroup option in the normalizer bundle. With this option, the groups passed down to nested objects can be manually defined.

The following PHP class example will demonstrate the use case:

class Bar
{
    /**
     * @Bos\Normalize(group={"api_v3", "id_only"})
     * 
     * @var int
     */
    public $id;

    /**
     * @Bos\Normalize(group={"api_v3"}, passdownGroup="id_only")
     * 
     * @var Foo
     */
    public $foo;
}

class Foo
{
    /**
     * @Bos\Normalize(group={"api_v3", "id_only"})
     * 
     * @var int
     */
    public $id;

    /**
     * @Bos\Normalize(group={"api_v3"})
     * 
     * @var string
     */
    public $name;
}

Calling the normalizer like:

$this->normalizer->normalize($bar, 'api_v3');

Would result in:

{
  "id": 1,
  "foo": {
    "id": 1
  }
}

Instead of:

{
  "id": 1,
  "foo": {
    "id": 1,
    "name": "test"
  }
}

Without this feature, a lot of manual groups might have to be defined to support simple use cases like above.

Whenever I add a normalize annotation on a nested object, the property suddenly requires a getter() method to be set, while it actually uses the specified callback.

<?php

namespace AppBundle\Entity\Invoice;

use BowlOfSoup\NormalizerBundle\Annotation as Bos;

class Invoice
{
    /** @Bos\Normalize(type="object") */
    protected $debtor;
}

<?php

namespace AppBundle\Entity\Debtor;

use BowlOfSoup\NormalizerBundle\Annotation as Bos;

class Debtor
{
    /** @Bos\Normalize(callback="getFullName", name="name") */
    protected $bosName;

    public function getFullName()
    {
        ...
    }
}

The following results in exception 'Exception' with message 'Unable to get property value. No get() method found for property bosName' in /full/path/to/vendor/bowlofsoup/normalizer-bundle/Service/PropertyExtractor.php:77

Whenever I add a dummy method called getBosName, it works. The same setup however does work on the main object...

When serialising, make an option to sort all properties ascending by name.

Since TravisCI does not provide me with build minutes anymore, and their support is not responding, I'm migrating to Github Actions. Lets find out if this also works good :)

When normalizing a doctrine proxy, normalizer annotations on the entity are not taken into account.
This is because the annotations are not present on the proxy class itself.

Child:

class ProxySocial extends Social implements Proxy
{
    /**
     * {@inheritdoc}
     */
    public function __load()
    {
    }

    /**
     * {@inheritdoc}
     */
    public function __isInitialized()
    {
    }

    /**
     * {@inheritdoc}
     */
    public function getFacebook()
    {
        return parent::getFacebook();
    }
}

Parent; Which is in case of Doctrine proxies the actual class with correct annotations:

class Social
{
    /**
     * @var string
     *
     * @Bos\Normalize(group={"default"})
     */
    private $facebook;

    /**
     * @return string
     *
     * @Bos\Normalize(name="facebook", group={"via-method"})
     */
    public function getFacebook()
    {
        return $this->facebook;
    }
}

If we call the normalizer it will only check the child (proxy) method for annotations.
$normalizer->normalize($proxySocial, 'via-method')

We should support looking up the parent if a doctrine proxy is used.

class Bar
{
    /**
     * @Bos\Normalize()
     */
    public function getName(): string
    {
        return 'john wick';
    }
}
 
class Foo extends Bar
{
    /**
     * PHPDoc without @Bos\Normalize annotation
     */
    public function getName(): string
    {
        return 'John Wick';
    }
}

When normalizing getName() from Foo, nothing will output.

We should make an annotation that indicates that the parent Normalize() annotations should be inherited.

Example:

class Foo extends Bar
{
    /**
     * @Bos\InheritNormalize()
     */
    public function getName(): string
    {
        return 'John Wick';
    }
}

As a developer I want to have an exception when a property of an annotation does not exists (e.g. is wrongly spelled).

Example:

@bos/Normalize(groupp={"testgroup"});

should indicate that 'groupp' is a property that does not exist.

Serializer should be a combination of the normalization and encoding processes. Now the encoding is not seperated enough from the serialization code.