Initial commit

Author: Sevavietl

.gitignore

@@ -0,0 +1,4 @@
+.idea
+vendor
+composer.lock
+build

.travis.yml

@@ -0,0 +1,18 @@
+language: php
+sudo: false
+php:
+- 7.1
+- 7.2
+
+before_install:
+- composer self-update
+
+install:
+- travis_retry composer install --no-interaction --prefer-source
+
+script:
+- vendor/bin/phpstan analyze src/ test/ --level max
+- vendor/bin/phpunit --coverage-clover build/logs/clover.xml
+
+after_success:
+- travis_retry php vendor/bin/php-coveralls -v

LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2018 Vsevolod Vietluzhskykh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,43 @@
+# TypeGuard - PHP type validation partly inspired by [Ceylon Union and Intersection types](https://ceylon-lang.org/documentation/1.3/tour/types/)
+
+[![Build Status](https://travis-ci.com/Sevavietl/TypeGuard.svg?branch=master)](https://travis-ci.com/Sevavietl/TypeGuard)
+[![Coverage Status](https://coveralls.io/repos/github/Sevavietl/TypeGuard/badge.svg)](https://coveralls.io/github/Sevavietl/TypeGuard)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![PHPStan](https://img.shields.io/badge/PHPStan-enabled-brightgreen.svg?style=flat)](https://github.com/phpstan/phpstan)
+
+## Features
+
+TypeGuard can validate:
+
+- Scalar types: `string`, `integer`, etc.:
+
+```php
+(new \TypeGuard\Type('string'))->match('foo'); // => true
+```
+
+- Object types: `ArrayAccess`, `stdClass`, etc.:
+
+```php
+(new \TypeGuard\Type('stdClass'))->match(new stdClass()); // => true
+```
+
+- Union types: `string|integer`:
+
+```php
+$guard = new \TypeGuard\Type('string|integer');
+$guard->match('foo'); // => true
+$guard->match(1); // => true
+```
+
+- Intersection types: `ArrayAccess&Countable`:
+
+```php
+(new \TypeGuard\Type('ArrayAccess&Countable'))->match(new ArrayIterator()); // => true
+```
+
+- Optional types: `?string`:
+
+```php
+(new \TypeGuard\Type('?string'))->match(null); // => true
+```
+

composer.json

@@ -0,0 +1,30 @@
+{
+    "name": "sevavietl/type-guard",
+    "description": "PHP type validator",
+    "type": "library",
+    "require": {
+        "php": ">=7.1",
+        "php-coveralls/php-coveralls": "^2.1"
+    },
+    "require-dev": {
+        "phpunit/phpunit": "^7.3",
+        "phpstan/phpstan": "^0.10.3"
+    },
+    "autoload": {
+        "psr-4": {
+            "TypeGuard\\": "src/"
+        }
+    },
+    "autoload-dev": {
+        "psr-4": {
+            "TypeGuard\\Test\\": "test/"
+        }
+    },
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "sevavietl",
+            "email": "[email protected]"
+        }
+    ]
+}

phpunit.xml.dist

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<phpunit backupGlobals="false"
+         backupStaticAttributes="false"
+         bootstrap="vendor/autoload.php"
+         colors="true"
+         convertErrorsToExceptions="true"
+         convertNoticesToExceptions="true"
+         convertWarningsToExceptions="true"
+         processIsolation="false"
+         stopOnFailure="false">
+    <filter>
+        <whitelist processUncoveredFilesFromWhitelist="true">
+            <directory suffix=".php">./src</directory>
+        </whitelist>
+    </filter>
+    <testsuites>
+        <testsuite name="unit">
+            <directory suffix="Test.php">test/</directory>
+        </testsuite>
+    </testsuites>
+</phpunit>

src/ArrayType.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace TypeGuard;
+
+final class ArrayType implements TypeInterface
+{
+    /** @var TypeInterface  */
+    private $type;
+
+    public function __construct(TypeInterface $type)
+    {
+        $this->type = $type;
+    }
+
+    /**
+     * @param mixed $parameter
+     * @return bool
+     */
+    public function match($parameter): bool
+    {
+        $type = \gettype($parameter);
+
+        if ($type !== 'array') {
+            return false;
+        }
+
+        foreach ($parameter as $item) {
+            if (! $this->type->match($item)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}

src/Guard.php

@@ -0,0 +1,57 @@
+<?php
+
+namespace TypeGuard;
+
+final class Guard
+{
+    /** @var TypeInterface */
+    private $type;
+
+    public function __construct(string $typeName)
+    {
+        if ($optional = $this->isOptional($typeName)) {
+            $typeName = substr($typeName, 1);
+        }
+
+        if ($array = $this->isArray($typeName)) {
+            $typeName = substr($typeName, 0, -2);
+        }
+
+        if ($this->isUnion($typeName)) {
+            $type = new UnionType(array_filter(explode(UnionType::SEPARATOR, $typeName), 'trim'));
+        } elseif ($this->isIntersection($typeName)) {
+            $type = new IntersectionType(array_filter(explode(IntersectionType::SEPARATOR, $typeName), 'trim'));
+        } else {
+            $type = new Type($typeName);
+        }
+
+        $type = $array ? new ArrayType($type) : $type;
+
+        $this->type = $optional ? new OptionalType($type) : $type;
+    }
+
+    private function isOptional(string $typeName): bool
+    {
+        return strpos($typeName, '?') === 0;
+    }
+
+    private function isArray(string $typeName): bool
+    {
+        return (bool) preg_match('/(?:\[\])$/', $typeName);
+    }
+
+    private function isUnion(string $typeName): bool
+    {
+        return strpos($typeName, UnionType::SEPARATOR) !== false;
+    }
+
+    private function isIntersection(string $typeName): bool
+    {
+        return strpos($typeName, IntersectionType::SEPARATOR) !== false;
+    }
+
+    public function match($parameter): bool
+    {
+        return $this->type->match($parameter);
+    }
+}

src/IntersectionType.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace TypeGuard;
+
+final class IntersectionType implements TypeInterface
+{
+    public const SEPARATOR = '&';
+
+    /** @var TypeInterface[] */
+    private $types;
+
+    public function __construct(array $typeNames)
+    {
+        $this->types = array_map(function ($typeName): TypeInterface {
+            return new Type($typeName);
+        }, $typeNames);
+    }
+
+    /**
+     * @param mixed $parameter
+     * @return bool
+     */
+    public function match($parameter): bool
+    {
+        return array_reduce($this->types, function (bool $carry, TypeInterface $type) use ($parameter): bool {
+            return $carry && $type->match($parameter);
+        }, true);
+    }
+}

src/OptionalType.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace TypeGuard;
+
+final class OptionalType implements TypeInterface
+{
+    /** @var TypeInterface */
+    private $type;
+
+    public function __construct(TypeInterface $type)
+    {
+        $this->type = $type;
+    }
+
+    /**
+     * @param mixed $parameter
+     * @return bool
+     */
+    public function match($parameter): bool
+    {
+        $type = \gettype($parameter);
+
+        if ($type === 'NULL') {
+            return true;
+        }
+
+        return $this->type->match($parameter);
+    }
+}

src/Type.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace TypeGuard;
+
+final class Type implements TypeInterface
+{
+    /** @var string */
+    private $typeName;
+
+    public function __construct(string $typeName)
+    {
+        $this->typeName = $typeName;
+    }
+
+    /**
+     * @param mixed $parameter
+     * @return bool
+     */
+    public function match($parameter): bool
+    {
+        $type = \gettype($parameter);
+
+        return $type === 'object'
+            ? $parameter instanceof $this->typeName
+            : $type === $this->typeName;
+    }
+}

src/TypeInterface.php

@@ -0,0 +1,12 @@
+<?php
+
+namespace TypeGuard;
+
+interface TypeInterface
+{
+    /**
+     * @param mixed $parameter
+     * @return bool
+     */
+    public function match($parameter): bool;
+}

src/UnionType.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace TypeGuard;
+
+final class UnionType implements TypeInterface
+{
+    public const SEPARATOR = '|';
+
+    /** @var TypeInterface[] */
+    private $types;
+
+    public function __construct(array $typeNames)
+    {
+        $this->types = array_map(function ($typeName) {
+            return new Type($typeName);
+        }, $typeNames);
+    }
+
+    /**
+     * @param mixed $parameters
+     * @return bool
+     */
+    public function match($parameters): bool
+    {
+        return array_reduce($this->types, function (bool $carry, TypeInterface $type) use ($parameters): bool {
+            return $carry || $type->match($parameters);
+        }, false);
+    }
+}