https://github.com/daverandom/callbackvalidator

Tools for validating callback signatures in PHP
https://github.com/daverandom/callbackvalidator

Last synced: about 1 year ago
JSON representation

Tools for validating callback signatures in PHP

• Host: GitHub
• URL: https://github.com/daverandom/callbackvalidator
• Owner: DaveRandom
• License: mit
• Created: 2017-03-22T02:36:15.000Z (about 9 years ago)
• Default Branch: master
• Last Pushed: 2018-12-31T16:13:34.000Z (over 7 years ago)
• Last Synced: 2025-04-04T11:51:11.567Z (about 1 year ago)
• Language: PHP
• Size: 58.6 KB
• Stars: 44
• Watchers: 8
• Forks: 3
• Open Issues: 0
• Metadata Files:
  • Readme: README.md
  • License: LICENSE

Awesome Lists containing this project

README

          
Callback Validator

==================

Validates callback signatures against a prototype.

## Status

[![Build Status](https://travis-ci.org/DaveRandom/CallbackValidator.svg?branch=master)](https://travis-ci.org/DaveRandom/CallbackValidator)

[![Scrutinizer Code Quality](https://scrutinizer-ci.com/g/DaveRandom/CallbackValidator/badges/quality-score.png?b=master)](https://scrutinizer-ci.com/g/DaveRandom/CallbackValidator/?branch=master)

[![Code Coverage](https://scrutinizer-ci.com/g/DaveRandom/CallbackValidator/badges/coverage.png?b=master)](https://scrutinizer-ci.com/g/DaveRandom/CallbackValidator/?branch=master)

## Usage

```php

// Create a prototype function (can be any callable)

$prototype = function (A $a, B $b, $c): ?string {};

// Validate that callables match the prototype

$tests = [

    $prototype, // true

    function (A $a, B $b, $c) {}, // false - return type does not match

    function ($a, $b, $c): ?string {}, // true - arguments are contravariant

    function (A $a, B $b): ?string {}, // true - extra args don't cause errors

    function (A $a, B $b, $c, $d): ?string {}, // false - Insufficient args cause an error

    function (C $a, B $b, $c): ?string {}, // true if C is a supertype of A, false otherwise

    function (SuperTypeOfA $a, B $b, $c): ?string {}, // true

    function (A $a, B $b, $c): string {}, // true - return types are covariant

];

// Create a type from a prototype

$type = CallbackType::createFromCallable($prototype);

run_tests($type, $tests);

// ...or create a type by hand for more granular control over variance rules

$type = new CallbackType(

    new ReturnType(BuiltInTypes::STRING, ReturnType::NULLABLE | ReturnType::COVARIANT),

    new ParameterType('a', A::class),

    new ParameterType('b', B::class),

    new ParameterType('c')

);

run_tests($type, $tests);

function run_tests(CallbackType $type, array $tests)

{

    foreach ($tests as $test) {

        if ($type->isSatisfiedBy($test)) {

            echo "pass\n";

        } else {

            // CallbackType implements __toString() for easy inspections

            echo CallbackType::createFromCallable($test) . " does not satisfy {$type}\n";

        }

    }

}

```

## TODO

- Lots more tests

- Explain (text explanation of why callback does not validate)