The factory functions removed in #184 were helpful in that they provided the same fluent interface with less code. I would like to propose that the following functions be restored as aliases (or perhaps a facade) to the static Assert:: methods:

use function Assert\that;
use function Assert\lazy;

I see no reason to have thatAll or thatNullOr be included, since they are just shortcuts to existing functionality.

• add assertion to ensure parameter is an object or a class that exists.
• add assertions to validate that an object (or class) has a property, and that an object (or class) has a set of properties.

The functions.php file is pulled in throught the Composer autoloader file mechanism: https://github.com/beberlei/assert/blob/master/composer.json#L20

If this package is used more than once in one PHP session (my use case is several WordPress plugins including it), this causes a fatal error:

Fatal error: Cannot redeclare Assert\that() [...]

I know that Composer should be used at the site level, not multiple times in one site. However, this could easily be fixed to allow for that use case, too, which would at least simplify the development process.

Provides a lot of hooks for people who want to be able to add their own assertions but don't want to lose the power of chaining and fluent interfaces. Having to recreate the that*() functions isn't ideal, but if someone is keen enough in their desire for custom assertions then it's a pretty small overhead.

These allow anyone using Psalm (or any other tool that understands its annotations) to understand the effect of beberlei/assert calls in their code.

Similar to https://github.com/sebastianbergmann/phpunit/pull/3708

For version beberlei/assert 2.9.6, Assertion::url('http://www.domain.ext'); fails on PHP 7.3.2, while it worked on 7.1.

Any idea what the cause is of this? Does PHP 7.3.2 interpret the regular expression differently?

Is that the reason why the regular expression was changed as mentioned here: https://github.com/beberlei/assert/issues/263 and documented here: https://github.com/beberlei/assert/blob/master/CHANGELOG.md#301---2018-07-04

I suppose this might be due to the upgrade to from PCRE to PCRE2 in PHP 7.3...

An upgrade to beberlei/assert 3.2.0 resolved this issue.

Maybe the 2.x versions should require PHP < 7.3. Not sure whether changing that "backwards" is a back practice though 😄

Using the existing LazyAssertion implementation, I found in cumbersome to capture multiple assertion failure messages pertaining to a single value. With this feature, I hope that this will be alleviated.

The purpose of the feature is to allow one to capture multiple assertion failures per value by dictating the behavior of the LazyAssertion class via special method call; the method is tryAll. What it will do specifically for this feature is, it will set a flag to keep the assertion chain going even after a failure is detected with a previous assertion.

This behavior can already be achieved, however it is necessary to call that multiple times, and this leads to multiple AssertionChain objects being created. For the sake of writing cleaner code and using resources more effectively, I felt this would be a worthwhile feature to propose.

Here is a list of exactly what I have included in this pull request:

• Added tryAll method to \Assert\LazyAssertion
• Added appropriate unit tests
• Updated the documentation

e.g. http://t_rost.rosfirm.ru/ is valid URL, may be it's not corresponds to some specs but it works replace ([\pL\pN\pS-]+\.)+[\pL]+ # a domain name with ([\pL\pN\pS-_]+\.)+[\pL]+ # a domain name

I wanted to extend the LazyAssertion in order to overload the that method. As I need to pass some additional details into the exception created by the assertion lib.

With all the properties on the LazyAssertion are private this doesn't allow for easy extending.

Would you be willing to accept a PR which would change the properties on the LazyAssertion from private too protected? (Like the Assert class already has, which can easily be extended)

@aliaOf annotation in inArray method causing the failing error

Doctrine\Common\Annotations\AnnotationException: [Semantical Error] The annotation "@aliasOf" in method Assert\Assertion::inArray() was never imported. Did you maybe forget to add a "use" statement for this annotation?

Removing the annotation seems to work. Should we remove it? Is there another workaround?

The functions in the Assert namespace can not be autoloaded, nor can they be used with alternative exception classes. This pull request resolves these issues by introducing a static factory class (\Assert\Assert) that provides these functions as static methods. This will also solve beberlei/assert#57.

This is my suggestion to support returning false in case of failure :

 public static function notEmpty($value, $message = null, string $propertyPath = null): bool
 {
        if (empty($value)) {
            $message = \sprintf(
                static::generateMessage($message ?: 'Value "%s" is empty, but non empty value was expected.'),
                static::stringify($value)
            );

            // throw static::createException($value, $message, static::VALUE_EMPTY, $propertyPath);
            return static::handleFailure($value, $message, static::VALUE_EMPTY, $propertyPath);
        }

        return true;
  }

 protected static function handleFailure($value, $message, $code, $propertyPath = null, array $constraints = []): bool
 {
        $exceptionClass = static::$exceptionClass;

        throw new $exceptionClass($message, $code, $propertyPath, $value, $constraints);
 }

That way anyone can inherit from Assertion class and override handleFailure to return false instead of throwing an exception. This is helpfull in many situations for example for a ternary condition...

This PR features new assertions for PHP8.1 enums.

Provides :

• Assertion::enumExists($value) that checks if $value is a valid enum FQCN
• Assertion::enumCase($value, $enumClass) that checks if $value is valid backing value for the $enumClass enum

I am using validation in my models and want to be specific about the validation errors. I want to know from which class and property and error came. I am aware that it is possible by setting the 'defaultPropertyPath' to something like 'Address.street', but this will cause a lot of duplication. For each 'that' call you'd have to specify the property.

What I am looking for is an API which looks more like this:

Assert::lazy('Address')
            ->that($street, 'street')->notEmpty()
            ->that($number, 'number')->notEmpty()
            ->verifyNow();

Assert::that('Address', 'street')->notEmpty();

For the "root" it might also be a nice idea to add a 'getRootPath' function that can be overriden. So that someone can pass in $this or $something::class and then format it inside this function, for example: reading $this::class and stripping it down to the basename.

I already have an implementation for this. Of course, to be backwards compatible it would mean that the that function can not be used; so maybe a new function called thatProperty.