DEV Community: Emanuel Vintila

Making a custom inspector in Unity to handle properties

Emanuel Vintila — Thu, 20 Jun 2019 15:02:00 +0000

Unity's built-in inspector only lets us modify fields. In this article we will see how we can extend the inspector to also display properties.

In order to create a custom inspector, we must derive from UnityEditor.Editor. This is the class declaration along with the properties that we will be using.

public class MyEditor : Editor
{
    protected Type InspectedType { get; set; }
    protected object InspectedObject { get; set; }
    protected List<PropertyInfo> Properties { get; set; }
    protected List<FieldInfo> Fields { get; set; }
}

First, in the OnEnable method of the inspector, let us collect the inspected object's settable fields and properties.

protected virtual void OnEnable()
{
    InspectedObject = serializedObject.targetObject;
    InspectedType = InspectedObject.GetType();

    Properties = InspectedType
        .GetProperties(BindingFlags.Public | BindingFlags.Instance)
        .Where(property => property.DeclaringType == InspectedType)
        .Where(property => (property.SetMethod?.IsPublic).GetValueOrDefault())
        .ToList();

    Fields = InspectedType
        .GetFields(BindingFlags.Public | BindingFlags.Instance)
        .Concat(InspectedType
                .GetFields(BindingFlags.NonPublic | BindingFlags.Instance)
                .Where(field => field.GetCustomAttribute<SerializeField>() != null)
               )
        .Where(field => field.IsInitOnly == false)
        .ToList();
}

Now, we will need a method that creates a field for a specific type with a label and a value.

protected virtual object MakeFieldForType(Type type, string label, object value)
{
    T F<T>(Func<string, T, GUILayoutOption[], T> fn)
    {
        return fn(label, (T) value, null);
    }

    if (type == typeof(bool))
        return F<bool>(EditorGUILayout.Toggle);
    if (type == typeof(int))
        return F<int>(EditorGUILayout.IntField);
    if (type == typeof(long))
        return F<long>(EditorGUILayout.LongField);
    if (type == typeof(float))
        return F<float>(EditorGUILayout.FloatField);
    if (type == typeof(double))
        return F<double>(EditorGUILayout.DoubleField);
    if (type == typeof(string))
        return F<string>(EditorGUILayout.TextField);

    throw new ArgumentException(nameof(type));
}

Finally, let us override the OnInspectorGUI method; it uses the MakeFieldForType method defined above.

public override void OnInspectorGUI()
{
    EditorGUILayout.LabelField("Properties");
    foreach (PropertyInfo property in Properties)
    {
        string label = property.Name;
        object value = property.GetValue(InspectedObject);
        property.SetValue(InspectedObject, MakeFieldForType(property.PropertyType, label, value));
    }

    EditorGUILayout.Separator();

    EditorGUILayout.LabelField("Fields");
    foreach (FieldInfo field in Fields)
    {
        string label = field.Name;
        object value = field.GetValue(InspectedObject);
        field.SetValue(InspectedObject, MakeFieldForType(field.FieldType, label, value));
    }
}

Obviously, this is a basic example, you would have to handle more types in the MakeFieldForType method.

There are drawbacks to this method. The SerializedObject's undo functionality is lost. The multi-editing support is also lost, but it can be added back pretty easily (leave a comment with your solution to this one 😉).

In order to test our new custom inspector, we need to derive a class from it, and annotate it with the CustomEditor attribute, which tells Unity that it should use the editor for the respective type.

using System.Collections.Generic;
using UnityEditor;
using UnityEngine;

public class ExampleClass : MonoBehaviour
{ 
    public float Prop { get; set; }
    public float PropPrivateSet { get; private set; }
    public float PropReadOnly { get; }
    public float PropComputed => field * 2;

    public float field;
    public readonly float readonlyField = 5;
    [SerializeField]
    private float privateField;
}

[CustomEditor(typeof(ExampleClass))]
public class ExampleClassEditor : MyEditor { }

Why do this when the built-in inspector is more powerful? Because the built-in inspector does not support properties, and properties are a crucial part of encapsulation. You would not ever want to expose fields to the public, instead you would wrap them in properties. Even auto-implemented properties are much better than fields.

Imagine one day you decide you wanted to implement some other logic when setting a specific field. You would have to either wrap it in a property (the C# way), or write getter and setter methods for it (which is more or less equivalent to writing a property). Doing this means breaking already existing usages of your field in existing code.

In conclusion: always use properties instead of fields in the public interface!

Instantiating generic types at runtime using reflection

Emanuel Vintila — Sun, 09 Jun 2019 12:43:03 +0000

In this post, we will see how we can instantiate generic types at runtime using reflection, and call methods on the instance with correct arguments.

Assume you want to have a List<T> dynamically created at runtime; we do not want to create a List<object> instance, we want our instance to have a runtime type of List<T>. Well, of course T will be substituted with an actual type, like string, or int, depending on a user choice.

Note: there is no Exception handling; it is beyond the scope of the post.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;

namespace Reflection
{
    public class Program
    {
        private static void Main(string[] args)
        {
            Console.WriteLine("What type do you want your items to be? ");
            string input = Console.ReadLine();
            Type type = Type.GetType(input);

            // this is called an unbound type
            Type unbound = typeof(List<>);
            // unbound.IsGenericType == true
            Type bound = unbound.MakeGenericType(type);

            // get parameterless constructor and invoke it
            object list = bound.GetConstructor(new Type[0]).Invoke(new object[0]);

            // cannot use nameof with unbound types
            // string addMethod = nameof(List<>.Add);
            // use any bound type instead
            string methodNameAdd = nameof(List<object>.Add);
            MethodInfo methodAdd = bound.GetMethod(methodNameAdd);

            while (true)
            {
                Console.Write("Insert a new value into the list: ");
                input = Console.ReadLine();
                object arg = input;
                if (type != typeof(string))
                {
                    ConstructorInfo constructor = type.GetConstructor(new[] {typeof(string)});
                    // construct the type from a string
                    if (constructor != null)
                        arg = constructor.Invoke(new object[] {input});
                    // or call the static Parse method on C# primitive types
                    else
                        arg = type
                            // get the public static Parse method that accepts a string
                            .GetMethod("Parse", 0, BindingFlags.Static | BindingFlags.Public, null,
                                new[] {typeof(string)}, null)
                            .Invoke(null, new object[] {input});
                }

                methodAdd.Invoke(list, new[] {arg});
                // display the list after adding the item
                foreach (object item in (IEnumerable) list)
                    Console.Write($"{item} ");
                Console.WriteLine();
            }
        }
    }
}

We have specified that the compile-time type of the list variable is object, but it will be assigned a List<T> that will be created using reflection.

We let the user choose what type they want their list to hold. This should be specified as a fully qualified name (e.g. System.Int32). Then we add items to the list, transforming them into the appropriate type first.

Creating an HTML form for a class - part 2

Emanuel Vintila — Sat, 01 Jun 2019 12:38:34 +0000

This post improves the concept described in the previous post, and will improve upon the implementation.

Most of the code in this post is built upon the code in the previous post, but it is self-standing, so you do not have to read the previous post, though I strongly advise you to do so.

Using reflection, not only can we inspect a class's properties or methods, but we can also inspect the DocComment of any particular property, method or class. Using the DocComment, we can annotate the properties of our class to aid our form building method. Let us extend the Article class to as follows:

class Article
{
    /**
     * @var int
     * @Readonly
     */
    public $id = 1;

    /** @var string */
    public $title;

    /**
     * @var string
     * @Textarea
     */
    public $body;

    /** @var DateTime */
    public $date;

    public function __construct()
    {
        $this->date = $this->date ?
            new DateTime($this->date) :
            new DateTime();
    }
}

We added an id property to our article, that will be readonly, and the body property should be displayed as a textarea, as specified by their respective annotations. Notice how our properties no longer have initializers, because we will also use the @var annotation to deduce their types. After parsing the DocComments into an array of annotations we can use it to build our form.

function ParseDocCommentAnnotations(string $comment): array
{
    $matches = null;
    $annotations = [];
    $lines = explode("\n", $comment);
    foreach ($lines as $line) {
        $line = trim($line);
        // match all lines that start with an @ and capture the relevant parts
        if (1 === preg_match('/^\/?\*+\s*(@.*?)(?:\s*\*\/)?$/', $line,
                $matches)) {
            $annotation = $matches[1];
            // eventually split them on white-space, to handle @var annotations
            // or others that might also specify a value, such as @min, @max etc.
            list($key, $value) = preg_split('/\s+/', $annotation, 2);
            // if the value is falsy, use the key as the value
            // we could use literal true instead or whatever makes sense
            $value = $value ?? $key;
            $annotations[strtolower($key)] = $value;
        }
    }

    return $annotations;
}

For the id property, the resulting array would be equivalent to [var' => 'int', readonly' => '@readonly']. Let us modify the MakeInput function to accept a ReflectionProperty $property parameter and an $object parameter and make use of the above function to return a form input.

/**
 * This function creates a valid HTML input with an associated label.
 * @param ReflectionProperty $property
 * @param mixed $object An instance of the class that the $property parameter
 * was declared into
 * @return string
 */
function MakeInput(ReflectionProperty $property, $object): string
{
    $annotations = ParseDocCommentAnnotations($property->getDocComment());
    if (false === array_key_exists('@var', $annotations))
        // we could throw an exception instead
        // or assume that the property is a string
        return '';

    $class = $property->getDeclaringClass();
    $name = $property->getName();
    $value = $property->getValue($object);
    $input_name = "{$class->getName()}[{$name}]";
    $is_textarea = array_key_exists('@textarea', $annotations) &&
        $annotations['@var'] === 'string';
    // the for attribute targets an element with the specified id, not the name
    $label = sprintf('<label for="%s">%s</label>', $input_name, $name);

    $input_attributes = ['name' => $input_name, 'id' => $input_name];
    if (false === $is_textarea)
        $input_attributes['value'] = $value;
    if (array_key_exists('@readonly', $annotations))
        $input_attributes['readonly'] = 'readonly';

    switch ($type = $annotations['@var']) {
        case 'bool':
            $input_attributes['type'] = 'checkbox';
            break;
        case 'int':
        case 'double':
        case 'float':
            $input_attributes['type'] = 'number';
            // this is where the power of the annotations comes in
            // you can annotate your class's properties in any way you want
            // and then use those annotations to build the form
            if (array_key_exists('@min', $annotations))
                $input_attributes['min'] = $annotations['@min'];
            if (array_key_exists('@max', $annotations))
                $input_attributes['max'] = $annotations['@max'];
            if (array_key_exists('@step', $annotations))
                $input_attributes['step'] = $annotations['@step'];
            break;
        case 'string':
            if (false === $is_textarea)
                $input_attributes['type'] = 'text';
            break;
        default:
            // maybe the annotation specifies a class that we know how to
            // display as a form input
            $class = new ReflectionClass($type);
            if ($class->implementsInterface(DateTimeInterface::class)) {
                $input_attributes['type'] = 'date';
                break;
            }
            throw new InvalidArgumentException("The property {$name}
                    with type {$type} could not be converted into an input.");
    }

    $attributes_string = '';
    foreach ($input_attributes as $k => $v)
        $attributes_string .= sprintf(' %s="%s"', $k, addslashes($v));

    if (false === $is_textarea)
        $input = "<input {$attributes_string} />";
    else
        $input = "<textarea {$attributes_string}>{$value}</textarea>";

    return $label . $input;
}

We are also refactoring the MakeInputand MakeForm functions to accept an object instance as a parameter, and the MakeObjectFromArray function to accept a ReflectionClass parameter.

function MakeInputs($object): array
{
    $inputs = [];
    $class = new ReflectionClass($object);
    $properties = $class->getProperties();
    foreach ($properties as $property)
        // we could use yield here and change the return type to Generator
        $inputs[] = MakeInput($property, $object);

    return $inputs;
}

/**
 * @param mixed $object An object instance of a class
 * that has its properties annotated
 * @return string
 */
function MakeForm($object): string
{
    $html = '<form method="POST">';
    foreach (MakeInputs($object) as $input)
        $html .= $input;
    $html .= '<input type="submit" />';
    $html .= '</form>';

    return $html;
}

function MakeObjectFromArray(ReflectionClass $class, array $values)
{
    // we do not call the constructor yet
    $instance = $class->newInstanceWithoutConstructor();
    // first we set each property to their respective value
    foreach ($values as $name => $value) {
        $property = $class->getProperty($name);
        $property->setAccessible(true);
        $property->setValue($instance, $value);
    }
    // note that we have set primitive values to our object properties
    // we late-call the constructor, like PDO does when fetching objects
    // and it re-creates the object instances from the primitive values
    $class->getConstructor()->invoke($instance);

    return $instance;
}

At last, let us write the following in our index.php

$request_method = strtoupper($_SERVER['REQUEST_METHOD']);
if ($request_method === 'GET') {
    echo MakeForm(new Article);
} elseif ($request_method === 'POST') {
    $class = new ReflectionClass(Article::class);
    $article = MakeObjectFromArray($class, $_POST[$class->getName()]);
    // validate and save article or re-show form and display errors
    // echo MakeForm($article);
    print_r($article);
}

Opening up our browser, everything is in place, the input for the id property is readonly, and the input for the body property is a textarea, as we specified in the annotations.

Creating a HTML form for a class using PHP and Reflection

Emanuel Vintila — Wed, 29 May 2019 12:54:51 +0000

This is a cross post from my own blog: Creating a HTML form for a class

Have you ever thought Could there possibly be an easier way to create a form rather than plainly writing out the markup?. Assuming your form represents an object that can be represented as a class, there most certainly is; and if not, then it most definitely should. Let us create an overly-simplified article on a blog.

class Article {
    /** @var string */
    public $title = '';
    /** @var string */
    public $body = '';
    /** @var DateTime */
    public $date;

    public function __construct() {
        // this will be explained when we get to re-creating the object
        // after a POST request
        $this->date = $this->date ?
            new DateTime($this->date) :
            new DateTime();
    }
}

We want the title and body to be plain text inputs, and the date to be a date input. We are going to handle both the displaying of the form through a GET request, and the submission of the form through a POST request. Let us begin by enumerating our class's properties, creating an input for each one, and also wrapping them in a form tag with a submit input. Let us get straight to reflection. I have only annotated the MakeInput function as the other two should be self-explanatory.

/**
  * This function creates a valid HTML input with an associated label.
  * @param string $name The input's name and the label's text.
  * @param mixed $value The input's initial value. This parameter also determines the input's type.
  * @return string
  */
public function MakeInput(string $name, $value): string
{
    $type = gettype($value);
    $label = sprintf('<label for="%1$s">%1$s</label>', $name);
    switch ($type) {
        case 'boolean':
            $input_type = 'checkbox';
            break;
        case 'integer':
        case 'double':
            $input_type = 'number';
            break;
        case 'string':
            $input_type = 'text';
            break;
        case 'object':
            // special handling for object types
            $class = new ReflectionClass($value);
            if ($class->implementsInterface(DateTimeInterface::class)) {
                $input_type = 'date';
                $value = $class
                    ->getMethod('format')
                    ->invoke($value, 'Y-m-d');
                break;
            }
            // if we do not know how to handle the object, fall-through and throw
        default:
            throw new InvalidArgumentException($value);
    }
    $input = sprintf('<input name="%1$s" id="%1$s" type="%2$s" value="%3$s" />',
        $name, $input_type, $value);

    return $label . $input;
}

public function MakeInputs(string $class_name): array
{
    $inputs = [];
    $instance = new $class_name();
    $class = new ReflectionClass($instance);
    $properties = $class->getProperties();
    foreach ($properties as $property) {
        // make it accessible so we can get its value
        $property->setAccessible(true);
        $name = $property->getName();
        $value = $property->getValue($instance);
        // this syntax means that after submission our $_POST superglobal
        // will contain an array named $class_name which will represent
        // our class
        $inputs[] = self::MakeInput("{$class_name}[{$name}]", $value);
    }

    return $inputs;
}

public static function MakeForm(string $class_name): string
{
    $html = '<form method="POST">';
    foreach (self::MakeInputs($class_name) as $input)
        $html .= $input;
    $html .= '<input type="submit" />';
    $html .= '</form>';

    return $html;
}

Now, we only need to write a single line in our index.php

echo FormHelper::MakeForm(Article::class);

And there we have our form. It is not the most beautiful looking form, but the markup is valid and it works. We could add a callback function as a parameter that adds classes or wraps every input in a container, but that is beyond the scope of this post. Let us address the submission part of the form now, that is, the POST request and the re-creation of our Article object.

public function MakeClassFromArray(string $class_name, array $values)
{
    $class = new ReflectionClass($class_name);
    // we do not call the constructor yet
    $instance = $class->newInstanceWithoutConstructor();
    // first we set each property to their respective value
    foreach ($values as $name => $value) {
        $property = $class->getProperty($name);
        $property->setAccessible(true);
        $property->setValue($instance, $value);
    }
    // note that we have set primitive values to our object properties
    // we late-call the constructor, like PDO does when fetching objects
    // and it re-creates the object instances from the primitive values
    $class->getConstructor()->invoke($instance);

    return $instance;
}

Our index.php becomes

$request_method = strtoupper($_SERVER['REQUEST_METHOD']);
$class = Article::class;
if ($request_method === 'GET') {
    echo MakeForm($class);
} elseif ($request_method === 'POST') {
    $article = MakeClassFromArray($class, $_POST[$class]);
    print_r($article);
}

And there you have it, after submitting the form, the $article variable was re-created from the request and is ready to be validated and stored into the database.

In the next post I will present another way of creating the form, one which will solve the issues this one has, such as properties having to be initialized to a default value, and the fact that the body property is represented by a plain input field rather than a textarea. Do not worry, it also involves reflection.

Creating a Router for an MVC framework

Emanuel Vintila — Sun, 26 May 2019 07:53:16 +0000

This is a cross post from my own blog: Creating a Router for an MVC framework

If you are not familiar with MVC I suggest you read an article on that topic before reading this one.

Most of the code in this post requires at least PHP version 7.1.

Let us assume your domain is example.com and you want to build your application such that a request to example.com/gallery/cats displays a gallery of kitty pictures to the user and a request to example.com/gallery/dogs should obviously display a gallery of dogs.

By analyzing the URL we notice that the gallery word does not change, only the cats, dogs, or whatever else you would have pictures of in your database. Then we will create a class that handles this logic.

<?php
// GalleryController.php
class GalleryController
{
    /** @var string */
    private $animal_type;

    public function __construct(string $animal_type)
    {
        $this->animal_type = $animal_type;
    }

    public function display()
    {
        // do whatever you need here, fetch from database, etc.
        echo $this->animal_type;
    }
}

So, when a user points their browser to example.com/gallery/cats, the application needs to instantiate the newly defined class GalleryController with the cats argument, and then call the display method. We will implement the router using regular expressions. Let us first define a data class that will associate a request with a controller and a method.

<?php
// Route.php
class Route
{
    /** @var string */
    public $path;
    /** @var string */
    public $controller;
    /** @var string */
    public $method;

    public function __construct(string $path, string $controller, string $method)
    {
        $this->path = $path;
        $this->controller = $controller;
        $this->method = $method;
    }
}

We are going to define a very simple Router class and then we will use it to see how it works.

<?php
// Router.php
class Router
{
    /** @var Route[] */
    private $routes;

    public function register(Route $route)
    {
        $this->routes[] = $route;
    }

    public function handleRequest(string $request)
    {
        $matches = [];
        foreach ($this->routes as $route) {
            if (preg_match($route->path, $request, $matches)) {
                // $matches[0] will always be equal to $request, so we just shift it off
                array_shift($matches);
                // here comes the magic
                $class = new ReflectionClass($route->controller);
                $method = $class->getMethod($route->method);
                // we instantiate a new class using the elements of the $matches array
                $instance = $class->newInstance(...$matches);
                // equivalent:
                // $instance = $class->newInstanceArgs($matches);
                // then we call the method on the newly instantiated object
                $method->invoke($instance);
                // finally, we return from the function, because we do not want the request to be handled more than once
                return;
            }
        }
        throw new RuntimeException("The request '$request' did not match any route.");
    }
}

Now, to actually run the application and test the Router class, create an index.php file with the following contents, and configure your web server to redirect all the requests to it.

<?php
// index.php
spl_autoload_extensions('.php');
spl_autoload_register();

$router = new Router();
$router->register(new Route('/^\/gallery\/(\w+)$/', 'GalleryController', 'display'));
$router->handleRequest($_SERVER['REQUEST_URI']);

Finally, point your browser to example.com/gallery/cats and it will display the word cats on your screen. The way it works is fairly simple:

We register the route with the router and we tell it to handle the incoming request
The router checks trough all the registered routes to see if the request matches any of them
It finds the matching route and instantiates a new class with the specified name, supplying the required arguments to its constructor, and then invokes the specified method onto the instance

That is pretty easy. Let us go a bit further. What if your controller constructor accepts an object as a parameter instead of a primitive type? We are going to define a User class that exposes their name and age:

<?php
// User.php
class User
{
    /** @var string */
    public $name;
    /** @var int */
    public $age;

    public function __construct(string $name, int $age)
    {
        $this->name = $name;
        $this->age = $age;
    }
}

And a UserController class that accepts an User as an argument:

<?php
// UserController.php
class UserController
{
    /** @var User */
    private $user;

    public function __construct(User $user)
    {
        $this->user = $user;
    }

    public function show()
    {
        echo "{$this->user->name} is {$this->user->age} years old.";
    }
}

Let us register a new route in the main script, right before the call to handleRequest:
$router->register(new Route('/^\/users\/(\w+)\/(\d+)$/', 'UserController', 'show'));
And now, if you go to example.com/users/mike/26, you will get an Exception, because the Router tries to pass a string to UserController's constructor, instead of an User. The fix involves using more reflection.

<?php
// Router.php
class Router
{
    /** @var Route[] */
    private $routes;

    public function register(Route $route)
    {
        $this->routes[] = $route;
    }

    public function handleRequest(string $request)
    {
        $matches = [];
        foreach ($this->routes as $route) {
            if (preg_match($route->path, $request, $matches)) {
                // $matches[0] will always be equal to $request, so we just shift it off
                array_shift($matches);
                // here comes the magic
                $class = new ReflectionClass($route->controller);
                $method = $class->getMethod($route->method);
                // we construct the controller using the newly defined method
                $instance = $this->constructClassFromArray($class, $matches);
                // then we call the method on the newly instantiated object
                $method->invoke($instance);
                // finally, we return from the function because we do not want the request to be handled more than once
                return;
            }
        }
        throw new RuntimeException("The request '$request' did not match any route.");
    }

    private function constructClassFromArray(ReflectionClass $class, array &$array)
    {
        $parameters = $class->getConstructor()->getParameters();
        // construct the arguments needed for its constructor
        $args = [];
        foreach ($parameters as $parameter)
            $args[] = $this->constructArgumentFromArray($parameter, $array);

        // then return the new instance
        return $class->newInstanceArgs($args);
    }

    private function constructArgumentFromArray(ReflectionParameter $parameter, array &$array)
    {
        $type = $parameter->getType();
        // if the parameter was not declared with any type, just return the next element from the array
        if ($type === null)
            return array_shift($array);

        // if the parameter is a primitive type, just cast it
        switch ($type->getName()) {
            case 'string':
                return (string) array_shift($array);
            case 'int':
                return (int) array_shift($array);
            case 'bool':
                return (bool) array_shift($array);
        }

        $class = $parameter->getClass();
        // if the parameter is a class type
        if ($class !== null) {
            // make another call that will actually call this method
            return $this->constructClassFromArray($class, $array);
        }

        throw new RuntimeException("Cannot construct the '{$parameter->getName()}' parameter in {$parameter->getDeclaringClass()->getName()}::{$parameter->getDeclaringFunction()->getName()} because it is of an invalid type{$type->getName()}.");
    }
}

Now the UserController class gets instantiated correctly, because the Router knows how to construct the User argument that the controller expects. But, what happens if the constructor for User has a nullable boolean parameter that represents a three-state value, for example whether they passed a certain test? Of course, PHP's boolean conversion rules still hold. Let us modify the User class to include this three-state boolean:

<?php
// User.php
class User
{
    /** @var string */
    public $name;
    /** @var int */
    public $age;
    /** @var bool|null */
    public $passed_test;

    public function __construct(string $name, int $age, ?bool $passed_test)
    {
        $this->name = $name;
        $this->age = $age;
        $this->passed_test = $passed_test;
    }
}

And UserController's show method to:

public function show()
{
    $message = 'invalid';
    if ($this->user->passed_test === true)
        $message = 'They passed the test!';
    elseif ($this->user->passed_test === false)
        $message = 'They didn\'t pass the test!';
    elseif ($this->user->passed_test === null)
        $message = 'They didn\'t attempt the test yet.';
    echo "{$this->user->name} is {$this->user->age} years old.\n";
    echo $message;
}

Finally let us modify the users route, to reflect the change:
$router->register(new Route('/^\/users\/(\w+)\/(\d+)\/?(\w+)?$/', 'UserController', 'show'));
Pointing your browser again to example.com/users/mike/26 will actually set their passed_test property to false instead of null. But why? That is because when we are constructing the User class, its constructor expects 3 arguments, but the URL only contains two. Thus, the last call to array_shift in constructArgumentFromArray actually returns null, that gets cast to bool, which is false. This is a straightforward fix. The constructArgumentFromArray method becomes:

private function constructArgumentFromArray(ReflectionParameter $parameter, array &$array)
{
    $type = $parameter->getType();
    // if the parameter was not declared with any type, just return the next element from the array
    if ($type === null)
        return array_shift($array);

    $class = $parameter->getClass();
    // if the parameter is a class type
    if ($class !== null) {
        // make another call that will actually call this method
        return $this->constructClassFromArray($class, $array);
    }

    // we ran out of $array elements
    if (count($array) === 0)
        // but we can pass null if the parameter allows it
        if ($parameter->allowsNull())
            return null;
        else
            throw new RuntimeException("Cannot construct the '{$parameter->getName()}' in {$parameter->getDeclaringClass()->getName()}::{$parameter->getDeclaringFunction()->getName()} because the array ran out of elements.");

    // if the parameter is a primitive type, just cast it
    switch ($type->getName()) {
        case 'string':
            return (string) array_shift($array);
        case 'int':
            return (int) array_shift($array);
        case 'bool':
            return (bool) array_shift($array);
    }

    throw new RuntimeException("Cannot construct the '{$parameter->getName()}' parameter in {$parameter->getDeclaringClass()->getName()}::{$parameter->getDeclaringFunction()->getName()} because it is of an invalid type{$type->getName()}.");
}

And now, the User class is instantiated correctly when we point the browser to example.com/users/mike/26 and to example.com/users/mike/26/any_truthy_or_falsy_value.