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,53 @@
+# TypeSignature - Type signature generator for PHP
+
+[![Build Status](https://travis-ci.com/Sevavietl/TypeSignature.svg?branch=master)](https://travis-ci.com/Sevavietl/TypeSignature)
+[![Coverage Status](https://coveralls.io/repos/github/Sevavietl/TypeSignature/badge.svg)](https://coveralls.io/github/Sevavietl/TypeSignature)
+[![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
+
+Supports following PHP [types](http://php.net/manual/en/language.types.intro.php):
+
+- [boolean](http://php.net/manual/en/language.types.boolean.php)
+- [integer](http://php.net/manual/en/language.types.integer.php)
+- [float](http://php.net/manual/en/language.types.float.php)
+- [string](http://php.net/manual/en/language.types.string.php)
+- [array](http://php.net/manual/en/language.types.array.php)
+
+```php
+\TypeSignature\TypeSignature::array('string'); // => 'string[]'
+```
+
+- [object](http://php.net/manual/en/language.types.object.php)
+- [callable](http://php.net/manual/en/language.types.callable.php)
+- [mixed](http://php.net/manual/en/language.pseudo-types.php#language.types.mixed)
+- [number](http://php.net/manual/en/language.pseudo-types.php#language.types.number)
+
+```php
+\TypeSignature\TypeSignature::number(); // => 'integer|float|double'
+```
+
+- [callback](http://php.net/manual/en/language.pseudo-types.php#language.types.callback)
+- [union types](https://ceylon-lang.org/documentation/1.3/tour/types/#union_types)
+
+```php
+\TypeSignature\TypeSignature::union(\TypeSignature\TypeSignature::integer(), \TypeSignature\TypeSignature::string()); // => 'integer|string'
+```
+
+- [intersection types](https://ceylon-lang.org/documentation/1.3/tour/types/#intersection_types)
+
+```php
+\TypeSignature\TypeSignature::intersection(\ArrayAccess::class, \Countable::class); // => 'ArrayAccess&Countable'
+```
+
+- [optional types](http://php.net/manual/en/migration71.new-features.php)
+
+```php
+\TypeSignature\TypeSignature::optional(TypeSignature::string()); => 'string
+```
+
+## TODO
+
+- iterable
+- [resource](http://php.net/manual/en/language.types.resource.php)

composer.json

@@ -0,0 +1,30 @@
+{
+    "name": "sevavietl/type-signature",
+    "description": "Type signature generator for PHP",
+    "type": "library",
+    "require": {
+        "php": ">=7.1"
+    },
+    "require-dev": {
+        "phpunit/phpunit": "^7.3",
+        "phpstan/phpstan": "^0.10.3",
+        "php-coveralls/php-coveralls": "^2.1"
+    },
+    "autoload": {
+        "psr-4": {
+            "TypeSignature\\": "src/"
+        }
+    },
+    "autoload-dev": {
+        "psr-4": {
+            "TypeSignature\\Test\\": "test/"
+        }
+    },
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "sevavietl",
+            "email": "sevavietl@gmail.com"
+        }
+    ]
+}

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/TypeSignature.php

@@ -0,0 +1,134 @@
+<?php
+
+namespace TypeSignature;
+
+final class TypeSignature
+{
+    public static function arguments(string ...$types): string
+    {
+        return implode(', ', $types);
+    }
+
+    /**
+     * @see http://php.net/manual/en/language.types.boolean.php
+     * @return string
+     */
+    public static function boolean(): string
+    {
+        return 'bool';
+    }
+
+    /**
+     * @see http://php.net/manual/en/language.types.integer.php
+     * @return string
+     */
+    public static function integer(): string
+    {
+        return 'integer';
+    }
+
+    /**
+     * @see http://php.net/manual/en/language.types.float.php
+     * @return string
+     */
+    public static function float(): string
+    {
+        return self::union('float', 'double');
+    }
+
+    /**
+     * @see http://php.net/manual/en/language.types.float.php
+     * @return string
+     */
+    public static function double(): string
+    {
+        return self::float();
+    }
+
+    /**
+     * @see http://php.net/manual/en/language.types.string.php
+     * @return string
+     */
+    public static function string(): string
+    {
+        return 'string';
+    }
+
+    /**
+     * @see http://php.net/manual/en/language.types.array.php
+     * @param string $type
+     * @return string
+     */
+    public static function array(string $type): string
+    {
+        if ((bool) preg_match('/(?:\[\])$/', $type)) {
+            return $type;
+        }
+
+        return "{$type}[]";
+    }
+
+    /**
+     * @see http://php.net/manual/en/language.types.object.php
+     * @return string
+     */
+    public static function object(): string
+    {
+        return 'object';
+    }
+
+    /**
+     * @see http://php.net/manual/en/language.types.callable.php
+     * @return string
+     */
+    public static function callable(): string
+    {
+        return 'callable';
+    }
+
+    /**
+     * @see http://php.net/manual/en/language.pseudo-types.php#language.types.mixed
+     * @return string
+     */
+    public static function mixed(): string
+    {
+        return 'mixed';
+    }
+
+    /**
+     * @see http://php.net/manual/en/language.pseudo-types.php#language.types.number
+     * @return string
+     */
+    public static function number(): string
+    {
+        return self::union(self::integer(), self::float());
+    }
+
+    /**
+     * @see http://php.net/manual/en/language.pseudo-types.php#language.types.callback
+     * @return string
+     */
+    public static function callback(): string
+    {
+        return self::callable();
+    }
+
+    public static function union(string ...$types): string
+    {
+        return implode('|', $types);
+    }
+
+    public static function intersection(string ...$types): string
+    {
+        return implode('&', $types);
+    }
+
+    public static function optional(string $type): string
+    {
+        if (0 === strpos($type, '?')) {
+            return $type;
+        }
+
+        return "?{$type}";
+    }
+}

test/TypeSignatureTest.php

@@ -0,0 +1,86 @@
+<?php
+
+namespace TypeSignature\Test;
+
+use PHPUnit\Framework\TestCase;
+use TypeSignature\TypeSignature;
+
+final class TypeSignatureTest extends TestCase
+{
+    public function testArguments(): void
+    {
+        $this->assertSame('string, integer', TypeSignature::arguments('string', 'integer'));
+    }
+
+    public function testBoolean(): void
+    {
+        $this->assertSame('bool', TypeSignature::boolean());
+    }
+
+    public function testInteger(): void
+    {
+        $this->assertSame('integer', TypeSignature::integer());
+    }
+
+    public function testFloat(): void
+    {
+        $this->assertSame('float|double', TypeSignature::float());
+    }
+
+    public function testDouble(): void
+    {
+        $this->assertSame('float|double', TypeSignature::double());
+    }
+
+    public function testString(): void
+    {
+        $this->assertSame('string', TypeSignature::string());
+    }
+
+    public function testArray(): void
+    {
+        $this->assertSame('string[]', TypeSignature::array('string'));
+        $this->assertSame('string[]', TypeSignature::array(TypeSignature::array('string')));
+    }
+
+    public function testObject(): void
+    {
+        $this->assertSame('object', TypeSignature::object());
+    }
+
+    public function testCallable(): void
+    {
+        $this->assertSame('callable', TypeSignature::callable());
+    }
+
+    public function testMixed(): void
+    {
+        $this->assertSame('mixed', TypeSignature::mixed());
+    }
+
+    public function testNumber(): void
+    {
+        $this->assertSame('integer|float|double', TypeSignature::number());
+    }
+
+    public function testCallback(): void
+    {
+        $this->assertSame('callable', TypeSignature::callback());
+    }
+
+    public function testUnion(): void
+    {
+        $this->assertSame('integer|string', TypeSignature::union(TypeSignature::integer(), TypeSignature::string()));
+    }
+
+    public function testIntersection(): void
+    {
+        $this->assertSame('ArrayAccess&Countable', TypeSignature::intersection(\ArrayAccess::class, \Countable::class));
+    }
+
+    public function testOptional(): void
+    {
+        $this->assertSame('?string', TypeSignature::optional(TypeSignature::string()));
+        $this->assertSame('?string', TypeSignature::optional(TypeSignature::optional(TypeSignature::string())));
+    }
+}