🚀 New Feature: Simplify Router Parameter Generation with Routable Objects

This pull request introduces the ability to pass objects directly as parameters to the Symfony Router, significantly simplifying the manual provision of complex parameter structures for routes. This improves code readability and reduces the chance of errors when generating URLs, especially with deeply nested or lengthy URL patterns.

💡 The Problem This Solves

In many Symfony applications, URL generation is a common task. For complex route patterns, such as /season/{season}/competition/{competition}/pools/{pool}/matches/{match}, developers currently have to manually collect all necessary parameters and pass them to the router. For example:

$this->router->generate('match_details', [
    'season' => $match->getPool()->getCompetition()->getSeason()->getSlug(),
    'competition' => $match->getPool()->getCompetition()->getSlug(),
    'pool' => $match->getPool()->getSlug(),
    'match' => $match->getSlug(),
]);

This quickly becomes cumbersome, error-prone, and reduces code readability, especially when routes require many parameters or when the objects containing the data are deeply nested.

✨ The Proposed Solution

This PR introduces a new concept where objects can define their own "router parameters" by implementing a specific interface. This allows the router to automatically extract the necessary parameters from the object, rather than requiring them to be manually specified.

Core Concepts:

• RoutableInterface: A new interface that objects can implement. This interface defines a method (e.g., getRouterParameters()) that returns a RouterParameters object.
• RouterParameters Value Object: A new value object that can hold a structured collection of parameters, including the ability to nest other RoutableInterface implementations.

Example Usage:

Let's say we have Pool and Match classes that implement the RoutableInterface:

class Pool implements RoutableInterface
{
    public function __construct(public readonly string $slug) {}

    public function getRouterParameters(): RouterParameters
    {
        return new RouterParameters(['pool' => $this->slug]);
    }
}

class Match implements RoutableInterface
{
    public function __construct(
        public readonly Pool $pool,
        public readonly string $slug,
    ) {}

    public function getRouterParameters(): RouterParameters
    {
        return (new RouterParameters([$this->pool, 'match' => $this->slug]))
            ->add('pool_details', [$this->pool]);
    }
}

With this implementation, URLs can be generated much more intuitively:

$match = new Match(new Pool('volley-championship'), 'final-match');

// Generate the URLs for the match: /pools/volley-championship/matches/final-match
$this->router->generate('match_details', [$match]);
$this->router->generate('match_edit', [$match]);

// Generate the URL for the related pool object: /pools/volley-championship
$this->router->generate('pool_details', [$match->pool]);
// Or directly via the match object:
$this->router->generate('pool_details', [$match]);

🌟 Benefits

• Improved Code Readability: Router calls become shorter and clearer.
• Less Error-Prone: Reduces the chance of typos or forgetting to provide parameters.
• Better Maintainability: If the URL structure changes, you only need to adjust the getRouterParameters() method in the respective objects, instead of modifying all generate() calls.
• Consistent URL Generation: Ensures that URLs for specific objects are always generated in the same way, regardless of the context.

🙏 Feedback Welcome!

This is my first feature pull request for Symfony, and I'm very eager to receive feedback. Any suggestions to improve the implementation or the proposal are greatly appreciated! I hope this feature can be valuable to the Symfony community.