Return validated value

[dbalabka]

I've faced the fact that it is required to create temporary variables to validate values:

$firstName = getParam('firstName');
$lastName = getParam('lastName');
Assert::notNull($firstName);
Assert::notNull($lastName);

createCustomer(
    $firstName,
    $lastName
);

We can rid of temporary variables if the assertion function returns a valid value:

createCustomer(
    Assert::notNull(getParam('firstName')),
    Assert::notNull(getParam('lastName'))
);

For some of the assertion functions, we can simply return the valid value. The changes should be BC-safe.

Possible implementation: #281
Psalm support demonstration: https://psalm.dev/r/a439359976

References:

1. Similar Java implementation: https://commons.apache.org/proper/commons-lang/javadocs/api-3.1/org/apache/commons/lang3/Validate.html#notNull(T)

[frankdekker]

I'm looking for this feature as well, and this would be helpful for every method. Your example is precisely my use case. The fluent notation makes it much more cleaner to use. Your current PR is only the notNull method. Is your intention to add this to all methods? Otherwise I could also extend on this PR.

[dbalabka]

@frankdekker, I will add support for other methods as well if the maintainer accepts that such a feature is required. We should wait for @webmozart's reply.

[shadowhand]

I think that Assert should be used inside the createCustomer method:

public function createCustomer(mixed $firstName, mixed $lastName): void
{
    Assert::stringNotEmpty($firstName);
    Assert::stringNotEmpty($lastName);

    // And then database write, or whatever
}

The usage suggested by OP promotes using Assert (and thus, Throwable) as a validation tool, which is not how this package was intended to be used. Throws are far too costly in PHP to be used for validation.

[dbalabka]

@shadowhand , that is an interesting idea. Unfortunately, the createCustomer method is a part of the library, and there is no easy way to extend it. Furthermore, createCustomer is strictly typed and does not allow nullable values to be passed as a parameter. Therefore, the only way to make static analysis tools happy is to add type guards before calling the method.

[ruudk]

We had a similar need in our project, when working with poorly typed things (mostly vendor code). We decided to introduce an AssertReturn class which looks like this:

final class AssertReturn
{
    /**
     * @return array<mixed>
     */
    public static function array(mixed $input) : array
    {
        Assert::isArray($input);

        return $input;
    }

    /**
     * @return list<string>
     */
    public static function listOfString(mixed $input) : array
    {
        Assert::isList($input);
        Assert::allString($input);

        return $input;
    }

    public static function string(mixed $input) : string
    {
        Assert::string($input);

        return $input;
    }

    public static function boolean(mixed $input) : bool
    {
        Assert::boolean($input);

        return $input;
    }

    // ... and so on

I wish I didn't have to create this, and could just use echo Assert::string($input); instead.