pax_global_header 0000666 0000000 0000000 00000000064 13015760036 0014513 g ustar 00root root 0000000 0000000 52 comment=e224fb2ea2fba6d3ad6fdaef91cd09a172155ccb
TypeResolver-0.2.1/ 0000775 0000000 0000000 00000000000 13015760036 0014156 5 ustar 00root root 0000000 0000000 TypeResolver-0.2.1/.gitignore 0000664 0000000 0000000 00000000033 13015760036 0016142 0 ustar 00root root 0000000 0000000 .idea
composer.lock
vendor
TypeResolver-0.2.1/.scrutinizer.yml 0000664 0000000 0000000 00000001434 13015760036 0017342 0 ustar 00root root 0000000 0000000 before_commands:
- "composer install --no-dev --prefer-source"
tools:
external_code_coverage: true
php_code_sniffer:
config:
standard: PSR2
filter:
paths: ["src/*", "tests/*"]
php_cpd:
enabled: true
excluded_dirs: ["tests", "vendor"]
php_loc:
enabled: true
excluded_dirs: ["tests", "vendor"]
php_mess_detector:
enabled: true
config:
ruleset: phpmd.xml.dist
design_rules: { eval_expression: false }
filter:
paths: ["src/*"]
php_pdepend:
enabled: true
excluded_dirs: ["tests", "vendor"]
php_analyzer:
enabled: true
filter:
paths: ["src/*", "tests/*"]
sensiolabs_security_checker: true
TypeResolver-0.2.1/.travis.yml 0000664 0000000 0000000 00000001245 13015760036 0016271 0 ustar 00root root 0000000 0000000 language: php
php:
- 5.5
- 5.6
- 7.0
- hhvm
- nightly
matrix:
allow_failures:
- php:
- hhvm
- nightly
cache:
directories:
- $HOME/.composer/cache
script:
- vendor/bin/phpunit --coverage-clover=coverage.clover -v
- composer update --no-interaction --prefer-source
- vendor/bin/phpunit -v
before_script:
- composer install --no-interaction
after_script:
- if [ $TRAVIS_PHP_VERSION = '5.6' ]; then wget https://scrutinizer-ci.com/ocular.phar; php ocular.phar code-coverage:upload --format=php-clover coverage.clover; fi
notifications:
irc: "irc.freenode.org#phpdocumentor"
email:
- me@mikevanriel.com
- ashnazg@php.net
TypeResolver-0.2.1/LICENSE 0000664 0000000 0000000 00000002070 13015760036 0015162 0 ustar 00root root 0000000 0000000 The MIT License (MIT)
Copyright (c) 2010 Mike van Riel
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.
TypeResolver-0.2.1/README.md 0000664 0000000 0000000 00000017164 13015760036 0015446 0 ustar 00root root 0000000 0000000 TypeResolver and FqsenResolver
==============================
The specification on types in DocBlocks (PSR-5) describes various keywords and special constructs
but also how to statically resolve the partial name of a Class into a Fully Qualified Class Name (FQCN).
PSR-5 also introduces an additional way to describe deeper elements than Classes, Interfaces and Traits
called the Fully Qualified Structural Element Name (FQSEN). Using this it is possible to refer to methods,
properties and class constants but also functions and global constants.
This package provides two Resolvers that are capable of
1. Returning a series of Value Object for given expression while resolving any partial class names, and
2. Returning an FQSEN object after resolving any partial Structural Element Names into Fully Qualified Structural
Element names.
## Installing
The easiest way to install this library is with [Composer](https://getcomposer.org) using the following command:
$ composer require phpdocumentor/type-resolver
## Examples
Ready to dive in and don't want to read through all that text below? Just consult the [examples](examples) folder and
check which type of action that your want to accomplish.
## On Types and Element Names
This component can be used in one of two ways
1. To resolve a Type or
2. To resolve a Fully Qualified Structural Element Name
The big difference between these two is in the number of things it can resolve.
The TypeResolver can resolve:
- a php primitive or pseudo-primitive such as a string or void (`@var string` or `@return void`).
- a composite such as an array of string (`@var string[]`).
- a compound such as a string or integer (`@var string|integer`).
- an object or interface such as the TypeResolver class (`@var TypeResolver`
or `@var \phpDocumentor\Reflection\TypeResolver`)
> please note that if you want to pass partial class names that additional steps are necessary, see the
> chapter `Resolving partial classes and FQSENs` for more information.
Where the FqsenResolver can resolve:
- Constant expressions (i.e. `@see \MyNamespace\MY_CONSTANT`)
- Function expressions (i.e. `@see \MyNamespace\myFunction()`)
- Class expressions (i.e. `@see \MyNamespace\MyClass`)
- Interface expressions (i.e. `@see \MyNamespace\MyInterface`)
- Trait expressions (i.e. `@see \MyNamespace\MyTrait`)
- Class constant expressions (i.e. `@see \MyNamespace\MyClass::MY_CONSTANT`)
- Property expressions (i.e. `@see \MyNamespace\MyClass::$myProperty`)
- Method expressions (i.e. `@see \MyNamespace\MyClass::myMethod()`)
## Resolving a type
In order to resolve a type you will have to instantiate the class `\phpDocumentor\Reflection\TypeResolver`
and call its `resolve` method like this:
$typeResolver = new \phpDocumentor\Reflection\TypeResolver();
$type = $typeResolver->resolve('string|integer');
In this example you will receive a Value Object of class `\phpDocumentor\Reflection\Types\Compound` that has two
elements, one of type `\phpDocumentor\Reflection\Types\String_` and one of type
`\phpDocumentor\Reflection\Types\Integer`.
The real power of this resolver is in its capability to expand partial class names into fully qualified class names; but
in order to do that we need an additional `\phpDocumentor\Reflection\Types\Context` class that will inform the resolver
in which namespace the given expression occurs and which namespace aliases (or imports) apply.
## Resolving an FQSEN
A Fully Qualified Structural Element Name is a reference to another element in your code bases and can be resolved using
the `\phpDocumentor\Reflection\FqsenResolver` class' `resolve` method, like this:
$fqsenResolver = new \phpDocumentor\Reflection\FqsenResolver();
$fqsen = $fqsenResolver->resolve('\phpDocumentor\Reflection\FqsenResolver::resolve()');
In this example we resolve a Fully Qualified Structural Element Name (meaning that it includes the full namespace, class
name and element name) and receive a Value Object of type `\phpDocumentor\Reflection\Fqsen`.
The real power of this resolver is in its capability to expand partial element names into Fully Qualified Structural
Element Names; but in order to do that we need an additional `\phpDocumentor\Reflection\Types\Context` class that will
inform the resolver in which namespace the given expression occurs and which namespace aliases (or imports) apply.
## Resolving partial Classes and Structural Element Names
Perhaps the best feature of this library is that it knows how to resolve partial class names into fully qualified class
names.
For example, you have this file:
```php
'\phpDocumentor\Reflection\Types']
);
Or by using the `\phpDocumentor\Reflection\Types\ContextFactory` to instantiate a new context based on a Reflector
object or by providing the namespace that you'd like to extract and the source code of the file in which the given
type expression occurs.
$contextFactory = new \phpDocumentor\Reflection\Types\ContextFactory();
$context = $contextFactory->createFromReflector(new ReflectionMethod('\My\Example\Classy', '__construct'));
or
$contextFactory = new \phpDocumentor\Reflection\Types\ContextFactory();
$context = $contextFactory->createForNamespace('\My\Example', file_get_contents('My/Example/Classy.php'));
### Using the Context
After you have obtained a Context it is just a matter of passing it along with the `resolve` method of either Resolver
class as second argument and the Resolvers will take this into account when resolving partial names.
To obtain the resolved class name for the `@var` tag in the example above you can do:
$typeResolver = new \phpDocumentor\Reflection\TypeResolver();
$type = $typeResolver->resolve('Types\Context', $context);
When you do this you will receive an object of class `\phpDocumentor\Reflection\Types\Object_` for which you can call
the `getFqsen` method to receive a Value Object that represents the complete FQSEN. So that would be
`phpDocumentor\Reflection\Types\Context`.
> Why is the FQSEN wrapped in another object `Object_`?
>
> The resolve method of the TypeResolver only returns object with the interface `Type` and the FQSEN is a common
> type that does not represent a Type. Also: in some cases a type can represent an "Untyped Object", meaning that it
> is an object (signified by the `object` keyword) but does not refer to a specific element using an FQSEN.
Another example is on how to resolve the FQSEN of a method as can be seen with the `@see` tag in the example above. To
resolve that you can do the following:
$fqsenResolver = new \phpDocumentor\Reflection\FqsenResolver();
$type = $fqsenResolver->resolve('Classy::otherFunction()', $context);
Because Classy is a Class in the current namespace its FQSEN will have the `My\Example` namespace and by calling the
`resolve` method of the FQSEN Resolver you will receive an `Fqsen` object that refers to
`\My\Example\Classy::otherFunction()`.
TypeResolver-0.2.1/composer.json 0000664 0000000 0000000 00000001232 13015760036 0016676 0 ustar 00root root 0000000 0000000 {
"name": "phpdocumentor/type-resolver",
"type": "library",
"license": "MIT",
"authors": [
{"name": "Mike van Riel", "email": "me@mikevanriel.com"}
],
"require": {
"php": ">=5.5",
"phpdocumentor/reflection-common": "^1.0"
},
"autoload": {
"psr-4": {"phpDocumentor\\Reflection\\": ["src/"]}
},
"autoload-dev": {
"psr-4": {"phpDocumentor\\Reflection\\": ["tests/unit"]}
},
"require-dev": {
"phpunit/phpunit": "^5.2||^4.8.24",
"mockery/mockery": "^0.9.4"
},
"extra": {
"branch-alias": {
"dev-master": "1.0.x-dev"
}
}
}
TypeResolver-0.2.1/examples/ 0000775 0000000 0000000 00000000000 13015760036 0015774 5 ustar 00root root 0000000 0000000 TypeResolver-0.2.1/examples/01-resolving-simple-types.php 0000664 0000000 0000000 00000000522 13015760036 0023363 0 ustar 00root root 0000000 0000000 resolve('string|integer'));
// Will return the string "string|int"
var_dump((string)$typeResolver->resolve('string|integer'));
TypeResolver-0.2.1/examples/02-resolving-classes.php 0000664 0000000 0000000 00000000645 13015760036 0022374 0 ustar 00root root 0000000 0000000 'Mockery' ]);
var_dump((string)$typeResolver->resolve('Types\Resolver|m\MockInterface', $context));
TypeResolver-0.2.1/examples/03-resolving-all-elements.php 0000664 0000000 0000000 00000001117 13015760036 0023315 0 ustar 00root root 0000000 0000000 resolve('Types\Resolver::resolveFqsen()', $context));
// Property named: \phpDocumentor\Types\Types\Resolver::$keyWords
var_dump((string)$fqsenResolver->resolve('Types\Resolver::$keyWords', $context));
TypeResolver-0.2.1/examples/04-discovering-the-context-using-class-reflection.php 0000664 0000000 0000000 00000002330 13015760036 0030056 0 ustar 00root root 0000000 0000000 createFromReflector(new ReflectionClass('My\\Example\\Classy'));
// Class named: \phpDocumentor\Reflection\Types\Resolver
var_dump((string)$typeResolver->resolve('Types\Resolver', $context));
// String
var_dump((string)$typeResolver->resolve('string', $context));
// Property named: \phpDocumentor\Reflection\Types\Resolver::$keyWords
var_dump((string)$fqsenResolver->resolve('Types\Resolver::$keyWords', $context));
// Class named: \My\Example\string
// - Shows the difference between the FqsenResolver and TypeResolver; the FqsenResolver will assume
// that the given value is not a type but most definitely a reference to another element. This is
// because conflicts between type keywords and class names can exist and if you know a reference
// is not a type but an element you can force that keywords are resolved.
var_dump((string)$fqsenResolver->resolve('string', $context));
TypeResolver-0.2.1/examples/05-discovering-the-context-using-method-reflection.php 0000664 0000000 0000000 00000002350 13015760036 0030234 0 ustar 00root root 0000000 0000000 createFromReflector(new ReflectionMethod('My\\Example\\Classy', '__construct'));
// Class named: \phpDocumentor\Reflection\Types\Resolver
var_dump((string)$typeResolver->resolve('Types\Resolver', $context));
// String
var_dump((string)$typeResolver->resolve('string', $context));
// Property named: \phpDocumentor\Reflection\Types\Resolver::$keyWords
var_dump((string)$fqsenResolver->resolve('Types\Resolver::$keyWords', $context));
// Class named: \My\Example\string
// - Shows the difference between the FqsenResolver and TypeResolver; the FqsenResolver will assume
// that the given value is not a type but most definitely a reference to another element. This is
// because conflicts between type keywords and class names can exist and if you know a reference
// is not a type but an element you can force that keywords are resolved.
var_dump((string)$fqsenResolver->resolve('string', $context));
TypeResolver-0.2.1/examples/06-discovering-the-context-using-file-contents.php 0000664 0000000 0000000 00000001352 13015760036 0027400 0 ustar 00root root 0000000 0000000 createForNamespace('My\Example', file_get_contents('Classy.php'));
// Class named: \phpDocumentor\Reflection\Types\Resolver
var_dump((string)$typeResolver->resolve('Types\Resolver', $context));
// String
var_dump((string)$typeResolver->resolve('string', $context));
// Property named: \phpDocumentor\Reflection\Types\Resolver::$keyWords
var_dump((string)$fqsenResolver->resolve('Types\Resolver::$keyWords', $context));
TypeResolver-0.2.1/examples/Classy.php 0000664 0000000 0000000 00000000306 13015760036 0017742 0 ustar 00root root 0000000 0000000
40
TypeResolver-0.2.1/phpunit.xml.dist 0000664 0000000 0000000 00000001443 13015760036 0017333 0 ustar 00root root 0000000 0000000
./tests/unit
./src/
./examples/
./vendor/
TypeResolver-0.2.1/src/ 0000775 0000000 0000000 00000000000 13015760036 0014745 5 ustar 00root root 0000000 0000000 TypeResolver-0.2.1/src/FqsenResolver.php 0000664 0000000 0000000 00000004302 13015760036 0020253 0 ustar 00root root 0000000 0000000
* @license http://www.opensource.org/licenses/mit-license.php MIT
* @link http://phpdoc.org
*/
namespace phpDocumentor\Reflection;
use phpDocumentor\Reflection\Types\Context;
class FqsenResolver
{
/** @var string Definition of the NAMESPACE operator in PHP */
const OPERATOR_NAMESPACE = '\\';
public function resolve($fqsen, Context $context = null)
{
if ($context === null) {
$context = new Context('');
}
if ($this->isFqsen($fqsen)) {
return new Fqsen($fqsen);
}
return $this->resolvePartialStructuralElementName($fqsen, $context);
}
/**
* Tests whether the given type is a Fully Qualified Structural Element Name.
*
* @param string $type
*
* @return bool
*/
private function isFqsen($type)
{
return strpos($type, self::OPERATOR_NAMESPACE) === 0;
}
/**
* Resolves a partial Structural Element Name (i.e. `Reflection\DocBlock`) to its FQSEN representation
* (i.e. `\phpDocumentor\Reflection\DocBlock`) based on the Namespace and aliases mentioned in the Context.
*
* @param string $type
* @param Context $context
*
* @return Fqsen
*/
private function resolvePartialStructuralElementName($type, Context $context)
{
$typeParts = explode(self::OPERATOR_NAMESPACE, $type, 2);
$namespaceAliases = $context->getNamespaceAliases();
// if the first segment is not an alias; prepend namespace name and return
if (!isset($namespaceAliases[$typeParts[0]])) {
$namespace = $context->getNamespace();
if ('' !== $namespace) {
$namespace .= self::OPERATOR_NAMESPACE;
}
return new Fqsen(self::OPERATOR_NAMESPACE . $namespace . $type);
}
$typeParts[0] = $namespaceAliases[$typeParts[0]];
return new Fqsen(self::OPERATOR_NAMESPACE . implode(self::OPERATOR_NAMESPACE, $typeParts));
}
}
TypeResolver-0.2.1/src/Type.php 0000664 0000000 0000000 00000000661 13015760036 0016402 0 ustar 00root root 0000000 0000000
* @license http://www.opensource.org/licenses/mit-license.php MIT
* @link http://phpdoc.org
*/
namespace phpDocumentor\Reflection;
interface Type
{
public function __toString();
}
TypeResolver-0.2.1/src/TypeResolver.php 0000664 0000000 0000000 00000021236 13015760036 0020125 0 ustar 00root root 0000000 0000000
* @license http://www.opensource.org/licenses/mit-license.php MIT
* @link http://phpdoc.org
*/
namespace phpDocumentor\Reflection;
use phpDocumentor\Reflection\Types\Array_;
use phpDocumentor\Reflection\Types\Compound;
use phpDocumentor\Reflection\Types\Context;
use phpDocumentor\Reflection\Types\Object_;
final class TypeResolver
{
/** @var string Definition of the ARRAY operator for types */
const OPERATOR_ARRAY = '[]';
/** @var string Definition of the NAMESPACE operator in PHP */
const OPERATOR_NAMESPACE = '\\';
/** @var string[] List of recognized keywords and unto which Value Object they map */
private $keywords = array(
'string' => 'phpDocumentor\Reflection\Types\String_',
'int' => 'phpDocumentor\Reflection\Types\Integer',
'integer' => 'phpDocumentor\Reflection\Types\Integer',
'bool' => 'phpDocumentor\Reflection\Types\Boolean',
'boolean' => 'phpDocumentor\Reflection\Types\Boolean',
'float' => 'phpDocumentor\Reflection\Types\Float_',
'double' => 'phpDocumentor\Reflection\Types\Float_',
'object' => 'phpDocumentor\Reflection\Types\Object_',
'mixed' => 'phpDocumentor\Reflection\Types\Mixed',
'array' => 'phpDocumentor\Reflection\Types\Array_',
'resource' => 'phpDocumentor\Reflection\Types\Resource',
'void' => 'phpDocumentor\Reflection\Types\Void_',
'null' => 'phpDocumentor\Reflection\Types\Null_',
'scalar' => 'phpDocumentor\Reflection\Types\Scalar',
'callback' => 'phpDocumentor\Reflection\Types\Callable_',
'callable' => 'phpDocumentor\Reflection\Types\Callable_',
'false' => 'phpDocumentor\Reflection\Types\Boolean',
'true' => 'phpDocumentor\Reflection\Types\Boolean',
'self' => 'phpDocumentor\Reflection\Types\Self_',
'$this' => 'phpDocumentor\Reflection\Types\This',
'static' => 'phpDocumentor\Reflection\Types\Static_'
);
/** @var FqsenResolver */
private $fqsenResolver;
/**
* Initializes this TypeResolver with the means to create and resolve Fqsen objects.
*
* @param FqsenResolver $fqsenResolver
*/
public function __construct(FqsenResolver $fqsenResolver = null)
{
$this->fqsenResolver = $fqsenResolver ?: new FqsenResolver();
}
/**
* Analyzes the given type and returns the FQCN variant.
*
* When a type is provided this method checks whether it is not a keyword or
* Fully Qualified Class Name. If so it will use the given namespace and
* aliases to expand the type to a FQCN representation.
*
* This method only works as expected if the namespace and aliases are set;
* no dynamic reflection is being performed here.
*
* @param string $type The relative or absolute type.
* @param Context $context
*
* @uses Context::getNamespace() to determine with what to prefix the type name.
* @uses Context::getNamespaceAliases() to check whether the first part of the relative type name should not be
* replaced with another namespace.
*
* @return Type|null
*/
public function resolve($type, Context $context = null)
{
if (!is_string($type)) {
throw new \InvalidArgumentException(
'Attempted to resolve type but it appeared not to be a string, received: ' . var_export($type, true)
);
}
$type = trim($type);
if (!$type) {
throw new \InvalidArgumentException('Attempted to resolve "' . $type . '" but it appears to be empty');
}
if ($context === null) {
$context = new Context('');
}
switch (true) {
case $this->isKeyword($type):
return $this->resolveKeyword($type);
case ($this->isCompoundType($type)):
return $this->resolveCompoundType($type, $context);
case $this->isTypedArray($type):
return $this->resolveTypedArray($type, $context);
case $this->isFqsen($type):
return $this->resolveTypedObject($type);
case $this->isPartialStructuralElementName($type):
return $this->resolveTypedObject($type, $context);
// @codeCoverageIgnoreStart
default:
// I haven't got the foggiest how the logic would come here but added this as a defense.
throw new \RuntimeException(
'Unable to resolve type "' . $type . '", there is no known method to resolve it'
);
}
// @codeCoverageIgnoreEnd
}
/**
* Adds a keyword to the list of Keywords and associates it with a specific Value Object.
*
* @param string $keyword
* @param string $typeClassName
*
* @return void
*/
public function addKeyword($keyword, $typeClassName)
{
if (!class_exists($typeClassName)) {
throw new \InvalidArgumentException(
'The Value Object that needs to be created with a keyword "' . $keyword . '" must be an existing class'
. ' but we could not find the class ' . $typeClassName
);
}
if (!in_array(Type::class, class_implements($typeClassName))) {
throw new \InvalidArgumentException(
'The class "' . $typeClassName . '" must implement the interface "phpDocumentor\Reflection\Type"'
);
}
$this->keywords[$keyword] = $typeClassName;
}
/**
* Detects whether the given type represents an array.
*
* @param string $type A relative or absolute type as defined in the phpDocumentor documentation.
*
* @return bool
*/
private function isTypedArray($type)
{
return substr($type, -2) === self::OPERATOR_ARRAY;
}
/**
* Detects whether the given type represents a PHPDoc keyword.
*
* @param string $type A relative or absolute type as defined in the phpDocumentor documentation.
*
* @return bool
*/
private function isKeyword($type)
{
return in_array(strtolower($type), array_keys($this->keywords), true);
}
/**
* Detects whether the given type represents a relative structural element name.
*
* @param string $type A relative or absolute type as defined in the phpDocumentor documentation.
*
* @return bool
*/
private function isPartialStructuralElementName($type)
{
return ($type[0] !== self::OPERATOR_NAMESPACE) && !$this->isKeyword($type);
}
/**
* Tests whether the given type is a Fully Qualified Structural Element Name.
*
* @param string $type
*
* @return bool
*/
private function isFqsen($type)
{
return strpos($type, self::OPERATOR_NAMESPACE) === 0;
}
/**
* Tests whether the given type is a compound type (i.e. `string|int`).
*
* @param string $type
*
* @return bool
*/
private function isCompoundType($type)
{
return strpos($type, '|') !== false;
}
/**
* Resolves the given typed array string (i.e. `string[]`) into an Array object with the right types set.
*
* @param string $type
* @param Context $context
*
* @return Array_
*/
private function resolveTypedArray($type, Context $context)
{
return new Array_($this->resolve(substr($type, 0, -2), $context));
}
/**
* Resolves the given keyword (such as `string`) into a Type object representing that keyword.
*
* @param string $type
*
* @return Type
*/
private function resolveKeyword($type)
{
$className = $this->keywords[strtolower($type)];
return new $className();
}
/**
* Resolves the given FQSEN string into an FQSEN object.
*
* @param string $type
*
* @return Object_
*/
private function resolveTypedObject($type, Context $context = null)
{
return new Object_($this->fqsenResolver->resolve($type, $context));
}
/**
* Resolves a compound type (i.e. `string|int`) into the appropriate Type objects or FQSEN.
*
* @param string $type
* @param Context $context
*
* @return Compound
*/
private function resolveCompoundType($type, Context $context)
{
$types = [];
foreach (explode('|', $type) as $part) {
$types[] = $this->resolve($part, $context);
}
return new Compound($types);
}
}
TypeResolver-0.2.1/src/Types/ 0000775 0000000 0000000 00000000000 13015760036 0016051 5 ustar 00root root 0000000 0000000 TypeResolver-0.2.1/src/Types/Array_.php 0000664 0000000 0000000 00000004116 13015760036 0020001 0 ustar 00root root 0000000 0000000
* @license http://www.opensource.org/licenses/mit-license.php MIT
* @link http://phpdoc.org
*/
namespace phpDocumentor\Reflection\Types;
use phpDocumentor\Reflection\Fqsen;
use phpDocumentor\Reflection\Type;
/**
* Represents an array type as described in the PSR-5, the PHPDoc Standard.
*
* An array can be represented in two forms:
*
* 1. Untyped (`array`), where the key and value type is unknown and hence classified as 'Mixed'.
* 2. Types (`string[]`), where the value type is provided by preceding an opening and closing square bracket with a
* type name.
*/
final class Array_ implements Type
{
/** @var Type */
private $valueType;
/** @var Type */
private $keyType;
/**
* Initializes this representation of an array with the given Type or Fqsen.
*
* @param Type $valueType
* @param Type $keyType
*/
public function __construct(Type $valueType = null, Type $keyType = null)
{
if ($keyType === null) {
$keyType = new Compound([ new String_(), new Integer() ]);
}
if ($valueType === null) {
$valueType = new Mixed();
}
$this->valueType = $valueType;
$this->keyType = $keyType;
}
/**
* Returns the type for the keys of this array.
*
* @return Type
*/
public function getKeyType()
{
return $this->keyType;
}
/**
* Returns the value for the keys of this array.
*
* @return Type
*/
public function getValueType()
{
return $this->valueType;
}
/**
* Returns a rendered output of the Type as it would be used in a DocBlock.
*
* @return string
*/
public function __toString()
{
if ($this->valueType instanceof Mixed) {
return 'array';
}
return $this->valueType . '[]';
}
}
TypeResolver-0.2.1/src/Types/Boolean.php 0000664 0000000 0000000 00000001304 13015760036 0020137 0 ustar 00root root 0000000 0000000
* @license http://www.opensource.org/licenses/mit-license.php MIT
* @link http://phpdoc.org
*/
namespace phpDocumentor\Reflection\Types;
use phpDocumentor\Reflection\Type;
/**
* Value Object representing a Boolean type.
*/
final class Boolean implements Type
{
/**
* Returns a rendered output of the Type as it would be used in a DocBlock.
*
* @return string
*/
public function __toString()
{
return 'bool';
}
}
TypeResolver-0.2.1/src/Types/Callable_.php 0000664 0000000 0000000 00000001313 13015760036 0020416 0 ustar 00root root 0000000 0000000
* @license http://www.opensource.org/licenses/mit-license.php MIT
* @link http://phpdoc.org
*/
namespace phpDocumentor\Reflection\Types;
use phpDocumentor\Reflection\Type;
/**
* Value Object representing a Callable type.
*/
final class Callable_ implements Type
{
/**
* Returns a rendered output of the Type as it would be used in a DocBlock.
*
* @return string
*/
public function __toString()
{
return 'callable';
}
}
TypeResolver-0.2.1/src/Types/Compound.php 0000664 0000000 0000000 00000004015 13015760036 0020346 0 ustar 00root root 0000000 0000000
* @license http://www.opensource.org/licenses/mit-license.php MIT
* @link http://phpdoc.org
*/
namespace phpDocumentor\Reflection\Types;
use phpDocumentor\Reflection\Type;
/**
* Value Object representing a Compound Type.
*
* A Compound Type is not so much a special keyword or object reference but is a series of Types that are separated
* using an OR operator (`|`). This combination of types signifies that whatever is associated with this compound type
* may contain a value with any of the given types.
*/
final class Compound implements Type
{
/** @var Type[] */
private $types = [];
/**
* Initializes a compound type (i.e. `string|int`) and tests if the provided types all implement the Type interface.
*
* @param Type[] $types
*/
public function __construct(array $types)
{
foreach ($types as $type) {
if (!$type instanceof Type) {
throw new \InvalidArgumentException('A compound type can only have other types as elements');
}
}
$this->types = $types;
}
/**
* Returns the type at the given index.
*
* @param integer $index
*
* @return Type|null
*/
public function get($index)
{
if (!$this->has($index)) {
return null;
}
return $this->types[$index];
}
/**
* Tests if this compound type has a type with the given index.
*
* @param integer $index
*
* @return bool
*/
public function has($index)
{
return isset($this->types[$index]);
}
/**
* Returns a rendered output of the Type as it would be used in a DocBlock.
*
* @return string
*/
public function __toString()
{
return implode('|', $this->types);
}
}
TypeResolver-0.2.1/src/Types/Context.php 0000664 0000000 0000000 00000005540 13015760036 0020212 0 ustar 00root root 0000000 0000000
* @license http://www.opensource.org/licenses/mit-license.php MIT
* @link http://phpdoc.org
*/
namespace phpDocumentor\Reflection\Types;
/**
* Provides information about the Context in which the DocBlock occurs that receives this context.
*
* A DocBlock does not know of its own accord in which namespace it occurs and which namespace aliases are applicable
* for the block of code in which it is in. This information is however necessary to resolve Class names in tags since
* you can provide a short form or make use of namespace aliases.
*
* The phpDocumentor Reflection component knows how to create this class but if you use the DocBlock parser from your
* own application it is possible to generate a Context class using the ContextFactory; this will analyze the file in
* which an associated class resides for its namespace and imports.
*
* @see ContextFactory::createFromClassReflector()
* @see ContextFactory::createForNamespace()
*/
final class Context
{
/** @var string The current namespace. */
private $namespace = '';
/** @var array List of namespace aliases => Fully Qualified Namespace. */
private $namespaceAliases = [];
/**
* Initializes the new context and normalizes all passed namespaces to be in Qualified Namespace Name (QNN)
* format (without a preceding `\`).
*
* @param string $namespace The namespace where this DocBlock resides in.
* @param array $namespaceAliases List of namespace aliases => Fully Qualified Namespace.
*/
public function __construct($namespace, array $namespaceAliases = [])
{
$this->namespace = ('global' !== $namespace && 'default' !== $namespace)
? trim((string)$namespace, '\\')
: '';
foreach ($namespaceAliases as $alias => $fqnn) {
if ($fqnn[0] === '\\') {
$fqnn = substr($fqnn, 1);
}
if ($fqnn[strlen($fqnn) - 1] === '\\') {
$fqnn = substr($fqnn, 0, -1);
}
$namespaceAliases[$alias] = $fqnn;
}
$this->namespaceAliases = $namespaceAliases;
}
/**
* Returns the Qualified Namespace Name (thus without `\` in front) where the associated element is in.
*
* @return string
*/
public function getNamespace()
{
return $this->namespace;
}
/**
* Returns a list of Qualified Namespace Names (thus without `\` in front) that are imported, the keys represent
* the alias for the imported Namespace.
*
* @return string[]
*/
public function getNamespaceAliases()
{
return $this->namespaceAliases;
}
}
TypeResolver-0.2.1/src/Types/ContextFactory.php 0000664 0000000 0000000 00000015364 13015760036 0021547 0 ustar 00root root 0000000 0000000
* @license http://www.opensource.org/licenses/mit-license.php MIT
* @link http://phpdoc.org
*/
namespace phpDocumentor\Reflection\Types;
/**
* Convenience class to create a Context for DocBlocks when not using the Reflection Component of phpDocumentor.
*
* For a DocBlock to be able to resolve types that use partial namespace names or rely on namespace imports we need to
* provide a bit of context so that the DocBlock can read that and based on it decide how to resolve the types to
* Fully Qualified names.
*
* @see Context for more information.
*/
final class ContextFactory
{
/** The literal used at the end of a use statement. */
const T_LITERAL_END_OF_USE = ';';
/** The literal used between sets of use statements */
const T_LITERAL_USE_SEPARATOR = ',';
/**
* Build a Context given a Class Reflection.
*
* @param \ReflectionClass $reflector
*
* @see Context for more information on Contexts.
*
* @return Context
*/
public function createFromReflector(\Reflector $reflector)
{
if (method_exists($reflector, 'getDeclaringClass')) {
$reflector = $reflector->getDeclaringClass();
}
$fileName = $reflector->getFileName();
$namespace = $reflector->getNamespaceName();
if (file_exists($fileName)) {
return $this->createForNamespace($namespace, file_get_contents($fileName));
}
return new Context($namespace, []);
}
/**
* Build a Context for a namespace in the provided file contents.
*
* @param string $namespace It does not matter if a `\` precedes the namespace name, this method first normalizes.
* @param string $fileContents the file's contents to retrieve the aliases from with the given namespace.
*
* @see Context for more information on Contexts.
*
* @return Context
*/
public function createForNamespace($namespace, $fileContents)
{
$namespace = trim($namespace, '\\');
$useStatements = [];
$currentNamespace = '';
$tokens = new \ArrayIterator(token_get_all($fileContents));
while ($tokens->valid()) {
switch ($tokens->current()[0]) {
case T_NAMESPACE:
$currentNamespace = $this->parseNamespace($tokens);
break;
case T_CLASS:
// Fast-forward the iterator through the class so that any
// T_USE tokens found within are skipped - these are not
// valid namespace use statements so should be ignored.
$braceLevel = 0;
$firstBraceFound = false;
while ($tokens->valid() && ($braceLevel > 0 || !$firstBraceFound)) {
if ($tokens->current() === '{'
|| $tokens->current()[0] === T_CURLY_OPEN
|| $tokens->current()[0] === T_DOLLAR_OPEN_CURLY_BRACES) {
if (!$firstBraceFound) {
$firstBraceFound = true;
}
$braceLevel++;
}
if ($tokens->current() === '}') {
$braceLevel--;
}
$tokens->next();
}
break;
case T_USE:
if ($currentNamespace === $namespace) {
$useStatements = array_merge($useStatements, $this->parseUseStatement($tokens));
}
break;
}
$tokens->next();
}
return new Context($namespace, $useStatements);
}
/**
* Deduce the name from tokens when we are at the T_NAMESPACE token.
*
* @param \ArrayIterator $tokens
*
* @return string
*/
private function parseNamespace(\ArrayIterator $tokens)
{
// skip to the first string or namespace separator
$this->skipToNextStringOrNamespaceSeparator($tokens);
$name = '';
while ($tokens->valid() && ($tokens->current()[0] === T_STRING || $tokens->current()[0] === T_NS_SEPARATOR)
) {
$name .= $tokens->current()[1];
$tokens->next();
}
return $name;
}
/**
* Deduce the names of all imports when we are at the T_USE token.
*
* @param \ArrayIterator $tokens
*
* @return string[]
*/
private function parseUseStatement(\ArrayIterator $tokens)
{
$uses = [];
$continue = true;
while ($continue) {
$this->skipToNextStringOrNamespaceSeparator($tokens);
list($alias, $fqnn) = $this->extractUseStatement($tokens);
$uses[$alias] = $fqnn;
if ($tokens->current()[0] === self::T_LITERAL_END_OF_USE) {
$continue = false;
}
}
return $uses;
}
/**
* Fast-forwards the iterator as longs as we don't encounter a T_STRING or T_NS_SEPARATOR token.
*
* @param \ArrayIterator $tokens
*
* @return void
*/
private function skipToNextStringOrNamespaceSeparator(\ArrayIterator $tokens)
{
while ($tokens->valid() && ($tokens->current()[0] !== T_STRING) && ($tokens->current()[0] !== T_NS_SEPARATOR)) {
$tokens->next();
}
}
/**
* Deduce the namespace name and alias of an import when we are at the T_USE token or have not reached the end of
* a USE statement yet.
*
* @param \ArrayIterator $tokens
*
* @return string
*/
private function extractUseStatement(\ArrayIterator $tokens)
{
$result = [''];
while ($tokens->valid()
&& ($tokens->current()[0] !== self::T_LITERAL_USE_SEPARATOR)
&& ($tokens->current()[0] !== self::T_LITERAL_END_OF_USE)
) {
if ($tokens->current()[0] === T_AS) {
$result[] = '';
}
if ($tokens->current()[0] === T_STRING || $tokens->current()[0] === T_NS_SEPARATOR) {
$result[count($result) - 1] .= $tokens->current()[1];
}
$tokens->next();
}
if (count($result) == 1) {
$backslashPos = strrpos($result[0], '\\');
if (false !== $backslashPos) {
$result[] = substr($result[0], $backslashPos + 1);
} else {
$result[] = $result[0];
}
}
return array_reverse($result);
}
}
TypeResolver-0.2.1/src/Types/Float_.php 0000664 0000000 0000000 00000001275 13015760036 0017773 0 ustar 00root root 0000000 0000000
* @license http://www.opensource.org/licenses/mit-license.php MIT
* @link http://phpdoc.org
*/
namespace phpDocumentor\Reflection\Types;
use phpDocumentor\Reflection\Type;
/**
* Value Object representing a Float.
*/
final class Float_ implements Type
{
/**
* Returns a rendered output of the Type as it would be used in a DocBlock.
*
* @return string
*/
public function __toString()
{
return 'float';
}
}
TypeResolver-0.2.1/src/Types/Integer.php 0000664 0000000 0000000 00000001216 13015760036 0020157 0 ustar 00root root 0000000 0000000
* @license http://www.opensource.org/licenses/mit-license.php MIT
* @link http://phpdoc.org
*/
namespace phpDocumentor\Reflection\Types;
use phpDocumentor\Reflection\Type;
final class Integer implements Type
{
/**
* Returns a rendered output of the Type as it would be used in a DocBlock.
*
* @return string
*/
public function __toString()
{
return 'int';
}
}
TypeResolver-0.2.1/src/Types/Mixed.php 0000664 0000000 0000000 00000001317 13015760036 0017632 0 ustar 00root root 0000000 0000000
* @license http://www.opensource.org/licenses/mit-license.php MIT
* @link http://phpdoc.org
*/
namespace phpDocumentor\Reflection\Types;
use phpDocumentor\Reflection\Type;
/**
* Value Object representing an unknown, or mixed, type.
*/
final class Mixed implements Type
{
/**
* Returns a rendered output of the Type as it would be used in a DocBlock.
*
* @return string
*/
public function __toString()
{
return 'mixed';
}
}
TypeResolver-0.2.1/src/Types/Null_.php 0000664 0000000 0000000 00000001310 13015760036 0017626 0 ustar 00root root 0000000 0000000
* @license http://www.opensource.org/licenses/mit-license.php MIT
* @link http://phpdoc.org
*/
namespace phpDocumentor\Reflection\Types;
use phpDocumentor\Reflection\Type;
/**
* Value Object representing a null value or type.
*/
final class Null_ implements Type
{
/**
* Returns a rendered output of the Type as it would be used in a DocBlock.
*
* @return string
*/
public function __toString()
{
return 'null';
}
}
TypeResolver-0.2.1/src/Types/Object_.php 0000664 0000000 0000000 00000003553 13015760036 0020135 0 ustar 00root root 0000000 0000000
* @license http://www.opensource.org/licenses/mit-license.php MIT
* @link http://phpdoc.org
*/
namespace phpDocumentor\Reflection\Types;
use phpDocumentor\Reflection\Fqsen;
use phpDocumentor\Reflection\Type;
/**
* Value Object representing an object.
*
* An object can be either typed or untyped. When an object is typed it means that it has an identifier, the FQSEN,
* pointing to an element in PHP. Object types that are untyped do not refer to a specific class but represent objects
* in general.
*/
final class Object_ implements Type
{
/** @var Fqsen|null */
private $fqsen;
/**
* Initializes this object with an optional FQSEN, if not provided this object is considered 'untyped'.
*
* @param Fqsen $fqsen
*/
public function __construct(Fqsen $fqsen = null)
{
if (strpos((string)$fqsen, '::') !== false || strpos((string)$fqsen, '()') !== false) {
throw new \InvalidArgumentException(
'Object types can only refer to a class, interface or trait but a method, function, constant or '
. 'property was received: ' . (string)$fqsen
);
}
$this->fqsen = $fqsen;
}
/**
* Returns the FQSEN associated with this object.
*
* @return Fqsen|null
*/
public function getFqsen()
{
return $this->fqsen;
}
/**
* Returns a rendered output of the Type as it would be used in a DocBlock.
*
* @return string
*/
public function __toString()
{
if ($this->fqsen) {
return (string)$this->fqsen;
}
return 'object';
}
}
TypeResolver-0.2.1/src/Types/Resource.php 0000664 0000000 0000000 00000001316 13015760036 0020352 0 ustar 00root root 0000000 0000000
* @license http://www.opensource.org/licenses/mit-license.php MIT
* @link http://phpdoc.org
*/
namespace phpDocumentor\Reflection\Types;
use phpDocumentor\Reflection\Type;
/**
* Value Object representing the 'resource' Type.
*/
final class Resource implements Type
{
/**
* Returns a rendered output of the Type as it would be used in a DocBlock.
*
* @return string
*/
public function __toString()
{
return 'resource';
}
}
TypeResolver-0.2.1/src/Types/Scalar.php 0000664 0000000 0000000 00000001404 13015760036 0017766 0 ustar 00root root 0000000 0000000
* @license http://www.opensource.org/licenses/mit-license.php MIT
* @link http://phpdoc.org
*/
namespace phpDocumentor\Reflection\Types;
use phpDocumentor\Reflection\Type;
/**
* Value Object representing the 'scalar' pseudo-type, which is either a string, integer, float or boolean.
*/
final class Scalar implements Type
{
/**
* Returns a rendered output of the Type as it would be used in a DocBlock.
*
* @return string
*/
public function __toString()
{
return 'scalar';
}
}
TypeResolver-0.2.1/src/Types/Self_.php 0000664 0000000 0000000 00000001434 13015760036 0017614 0 ustar 00root root 0000000 0000000
* @license http://www.opensource.org/licenses/mit-license.php MIT
* @link http://phpdoc.org
*/
namespace phpDocumentor\Reflection\Types;
use phpDocumentor\Reflection\Type;
/**
* Value Object representing the 'self' type.
*
* Self, as a Type, represents the class in which the associated element was defined.
*/
final class Self_ implements Type
{
/**
* Returns a rendered output of the Type as it would be used in a DocBlock.
*
* @return string
*/
public function __toString()
{
return 'self';
}
}
TypeResolver-0.2.1/src/Types/Static_.php 0000664 0000000 0000000 00000002125 13015760036 0020150 0 ustar 00root root 0000000 0000000
* @license http://www.opensource.org/licenses/mit-license.php MIT
* @link http://phpdoc.org
*/
namespace phpDocumentor\Reflection\Types;
use phpDocumentor\Reflection\Type;
/**
* Value Object representing the 'static' type.
*
* Self, as a Type, represents the class in which the associated element was called. This differs from self as self does
* not take inheritance into account but static means that the return type is always that of the class of the called
* element.
*
* See the documentation on late static binding in the PHP Documentation for more information on the difference between
* static and self.
*/
final class Static_ implements Type
{
/**
* Returns a rendered output of the Type as it would be used in a DocBlock.
*
* @return string
*/
public function __toString()
{
return 'static';
}
}
TypeResolver-0.2.1/src/Types/String_.php 0000664 0000000 0000000 00000001311 13015760036 0020163 0 ustar 00root root 0000000 0000000
* @license http://www.opensource.org/licenses/mit-license.php MIT
* @link http://phpdoc.org
*/
namespace phpDocumentor\Reflection\Types;
use phpDocumentor\Reflection\Type;
/**
* Value Object representing the type 'string'.
*/
final class String_ implements Type
{
/**
* Returns a rendered output of the Type as it would be used in a DocBlock.
*
* @return string
*/
public function __toString()
{
return 'string';
}
}
TypeResolver-0.2.1/src/Types/This.php 0000664 0000000 0000000 00000001651 13015760036 0017474 0 ustar 00root root 0000000 0000000
* @license http://www.opensource.org/licenses/mit-license.php MIT
* @link http://phpdoc.org
*/
namespace phpDocumentor\Reflection\Types;
use phpDocumentor\Reflection\Type;
/**
* Value Object representing the '$this' pseudo-type.
*
* $this, as a Type, represents the instance of the class associated with the element as it was called. $this is
* commonly used when documenting fluent interfaces since it represents that the same object is returned.
*/
final class This implements Type
{
/**
* Returns a rendered output of the Type as it would be used in a DocBlock.
*
* @return string
*/
public function __toString()
{
return '$this';
}
}
TypeResolver-0.2.1/src/Types/Void_.php 0000664 0000000 0000000 00000001527 13015760036 0017627 0 ustar 00root root 0000000 0000000
* @license http://www.opensource.org/licenses/mit-license.php MIT
* @link http://phpdoc.org
*/
namespace phpDocumentor\Reflection\Types;
use phpDocumentor\Reflection\Type;
/**
* Value Object representing the pseudo-type 'void'.
*
* Void is generally only used when working with return types as it signifies that the method intentionally does not
* return any value.
*/
final class Void_ implements Type
{
/**
* Returns a rendered output of the Type as it would be used in a DocBlock.
*
* @return string
*/
public function __toString()
{
return 'void';
}
}
TypeResolver-0.2.1/tests/ 0000775 0000000 0000000 00000000000 13015760036 0015320 5 ustar 00root root 0000000 0000000 TypeResolver-0.2.1/tests/unit/ 0000775 0000000 0000000 00000000000 13015760036 0016277 5 ustar 00root root 0000000 0000000 TypeResolver-0.2.1/tests/unit/TypeResolverTest.php 0000664 0000000 0000000 00000033660 13015760036 0022323 0 ustar 00root root 0000000 0000000
* @license http://www.opensource.org/licenses/mit-license.php MIT
* @link http://phpdoc.org
*/
namespace phpDocumentor\Reflection;
use Mockery as m;
use phpDocumentor\Reflection\Types\Array_;
use phpDocumentor\Reflection\Types\Compound;
use phpDocumentor\Reflection\Types\Context;
use phpDocumentor\Reflection\Types\Object_;
/**
* @coversDefaultClass phpDocumentor\Reflection\TypeResolver
*/
class TypeResolverTest extends \PHPUnit_Framework_TestCase
{
/**
* @param string $keyword
* @param string $expectedClass
*
* @covers ::__construct
* @covers ::resolve
* @covers ::
*
* @uses phpDocumentor\Reflection\Types\Context
* @uses phpDocumentor\Reflection\Types\Array_
* @uses phpDocumentor\Reflection\Types\Object_
*
* @dataProvider provideKeywords
*/
public function testResolvingKeywords($keyword, $expectedClass)
{
$fixture = new TypeResolver();
$resolvedType = $fixture->resolve($keyword, new Context(''));
$this->assertInstanceOf($expectedClass, $resolvedType);
}
/**
* @param string $fqsen
*
* @covers ::__construct
* @covers ::resolve
* @covers ::
*
* @uses phpDocumentor\Reflection\Types\Context
* @uses phpDocumentor\Reflection\Types\Object_
* @uses phpDocumentor\Reflection\Fqsen
* @uses phpDocumentor\Reflection\FqsenResolver
*
* @dataProvider provideFqcn
*/
public function testResolvingFQSENs($fqsen)
{
$fixture = new TypeResolver();
/** @var Object_ $resolvedType */
$resolvedType = $fixture->resolve($fqsen, new Context(''));
$this->assertInstanceOf('phpDocumentor\Reflection\Types\Object_', $resolvedType);
$this->assertInstanceOf('phpDocumentor\Reflection\Fqsen', $resolvedType->getFqsen());
$this->assertSame($fqsen, (string)$resolvedType);
}
/**
* @covers ::__construct
* @covers ::resolve
* @covers ::
*
* @uses phpDocumentor\Reflection\Types\Context
* @uses phpDocumentor\Reflection\Types\Object_
* @uses phpDocumentor\Reflection\Fqsen
* @uses phpDocumentor\Reflection\FqsenResolver
*/
public function testResolvingRelativeQSENsBasedOnNamespace()
{
$fixture = new TypeResolver();
/** @var Object_ $resolvedType */
$resolvedType = $fixture->resolve('DocBlock', new Context('phpDocumentor\Reflection'));
$this->assertInstanceOf('phpDocumentor\Reflection\Types\Object_', $resolvedType);
$this->assertInstanceOf('phpDocumentor\Reflection\Fqsen', $resolvedType->getFqsen());
$this->assertSame('\phpDocumentor\Reflection\DocBlock', (string)$resolvedType);
}
/**
* @covers ::__construct
* @covers ::resolve
* @covers ::
*
* @uses phpDocumentor\Reflection\Types\Context
* @uses phpDocumentor\Reflection\Types\Object_
* @uses phpDocumentor\Reflection\Fqsen
* @uses phpDocumentor\Reflection\FqsenResolver
*/
public function testResolvingRelativeQSENsBasedOnNamespaceAlias()
{
$fixture = new TypeResolver();
/** @var Object_ $resolvedType */
$resolvedType = $fixture->resolve(
'm\MockInterface',
new Context('phpDocumentor\Reflection', ['m' => '\Mockery'])
);
$this->assertInstanceOf('phpDocumentor\Reflection\Types\Object_', $resolvedType);
$this->assertInstanceOf('phpDocumentor\Reflection\Fqsen', $resolvedType->getFqsen());
$this->assertSame('\Mockery\MockInterface', (string)$resolvedType);
}
/**
* @covers ::__construct
* @covers ::resolve
* @covers ::
*
* @uses phpDocumentor\Reflection\Types\Context
* @uses phpDocumentor\Reflection\Types\Array_
* @uses phpDocumentor\Reflection\Types\String_
*/
public function testResolvingTypedArrays()
{
$fixture = new TypeResolver();
/** @var Array_ $resolvedType */
$resolvedType = $fixture->resolve('string[]', new Context(''));
$this->assertInstanceOf('phpDocumentor\Reflection\Types\Array_', $resolvedType);
$this->assertSame('string[]', (string)$resolvedType);
$this->assertInstanceOf('phpDocumentor\Reflection\Types\Compound', $resolvedType->getKeyType());
$this->assertInstanceOf('phpDocumentor\Reflection\Types\String_', $resolvedType->getValueType());
}
/**
* @covers ::__construct
* @covers ::resolve
* @covers ::
*
* @uses phpDocumentor\Reflection\Types\Context
* @uses phpDocumentor\Reflection\Types\Array_
* @uses phpDocumentor\Reflection\Types\String_
*/
public function testResolvingNestedTypedArrays()
{
$fixture = new TypeResolver();
/** @var Array_ $resolvedType */
$resolvedType = $fixture->resolve('string[][]', new Context(''));
/** @var Array_ $childValueType */
$childValueType = $resolvedType->getValueType();
$this->assertInstanceOf('phpDocumentor\Reflection\Types\Array_', $resolvedType);
$this->assertSame('string[][]', (string)$resolvedType);
$this->assertInstanceOf('phpDocumentor\Reflection\Types\Compound', $resolvedType->getKeyType());
$this->assertInstanceOf('phpDocumentor\Reflection\Types\Array_', $childValueType);
$this->assertSame('string[]', (string)$childValueType);
$this->assertInstanceOf('phpDocumentor\Reflection\Types\Compound', $childValueType->getKeyType());
$this->assertInstanceOf('phpDocumentor\Reflection\Types\String_', $childValueType->getValueType());
}
/**
* @covers ::__construct
* @covers ::resolve
* @covers ::
*
* @uses phpDocumentor\Reflection\Types\Context
* @uses phpDocumentor\Reflection\Types\Compound
* @uses phpDocumentor\Reflection\Types\String_
* @uses phpDocumentor\Reflection\Types\Object_
* @uses phpDocumentor\Reflection\Fqsen
* @uses phpDocumentor\Reflection\FqsenResolver
*/
public function testResolvingCompoundTypes()
{
$fixture = new TypeResolver();
/** @var Compound $resolvedType */
$resolvedType = $fixture->resolve('string|Reflection\DocBlock', new Context('phpDocumentor'));
$this->assertInstanceOf('phpDocumentor\Reflection\Types\Compound', $resolvedType);
$this->assertSame('string|\phpDocumentor\Reflection\DocBlock', (string)$resolvedType);
/** @var String $secondType */
$firstType = $resolvedType->get(0);
/** @var Object_ $secondType */
$secondType = $resolvedType->get(1);
$this->assertInstanceOf('phpDocumentor\Reflection\Types\String_', $firstType);
$this->assertInstanceOf('phpDocumentor\Reflection\Types\Object_', $secondType);
$this->assertInstanceOf('phpDocumentor\Reflection\Fqsen', $secondType->getFqsen());
}
/**
* @covers ::__construct
* @covers ::resolve
* @covers ::
*
* @uses phpDocumentor\Reflection\Types\Context
* @uses phpDocumentor\Reflection\Types\Compound
* @uses phpDocumentor\Reflection\Types\Array_
* @uses phpDocumentor\Reflection\Types\Object_
* @uses phpDocumentor\Reflection\Fqsen
* @uses phpDocumentor\Reflection\FqsenResolver
*/
public function testResolvingCompoundTypedArrayTypes()
{
$fixture = new TypeResolver();
/** @var Compound $resolvedType */
$resolvedType = $fixture->resolve('\stdClass[]|Reflection\DocBlock[]', new Context('phpDocumentor'));
$this->assertInstanceOf('phpDocumentor\Reflection\Types\Compound', $resolvedType);
$this->assertSame('\stdClass[]|\phpDocumentor\Reflection\DocBlock[]', (string)$resolvedType);
/** @var Array_ $secondType */
$firstType = $resolvedType->get(0);
/** @var Array_ $secondType */
$secondType = $resolvedType->get(1);
$this->assertInstanceOf('phpDocumentor\Reflection\Types\Array_', $firstType);
$this->assertInstanceOf('phpDocumentor\Reflection\Types\Array_', $secondType);
$this->assertInstanceOf('phpDocumentor\Reflection\Types\Object_', $firstType->getValueType());
$this->assertInstanceOf('phpDocumentor\Reflection\Types\Object_', $secondType->getValueType());
}
/**
* This test asserts that the parameter order is correct.
*
* When you pass two arrays separated by the compound operator (i.e. 'integer[]|string[]') then we always split the
* expression in its compound parts and then we parse the types with the array operators. If we were to switch the
* order around then 'integer[]|string[]' would read as an array of string or integer array; which is something
* other than what we intend.
*
* @covers ::__construct
* @covers ::resolve
* @covers ::
*
* @uses phpDocumentor\Reflection\Types\Context
* @uses phpDocumentor\Reflection\Types\Compound
* @uses phpDocumentor\Reflection\Types\Array_
* @uses phpDocumentor\Reflection\Types\Integer
* @uses phpDocumentor\Reflection\Types\String_
*/
public function testResolvingCompoundTypesWithTwoArrays()
{
$fixture = new TypeResolver();
/** @var Compound $resolvedType */
$resolvedType = $fixture->resolve('integer[]|string[]', new Context(''));
$this->assertInstanceOf('phpDocumentor\Reflection\Types\Compound', $resolvedType);
$this->assertSame('int[]|string[]', (string)$resolvedType);
/** @var Array_ $firstType */
$firstType = $resolvedType->get(0);
/** @var Array_ $secondType */
$secondType = $resolvedType->get(1);
$this->assertInstanceOf('phpDocumentor\Reflection\Types\Array_', $firstType);
$this->assertInstanceOf('phpDocumentor\Reflection\Types\Integer', $firstType->getValueType());
$this->assertInstanceOf('phpDocumentor\Reflection\Types\Array_', $secondType);
$this->assertInstanceOf('phpDocumentor\Reflection\Types\String_', $secondType->getValueType());
}
/**
* @covers ::__construct
* @covers ::addKeyword
* @uses phpDocumentor\Reflection\TypeResolver::resolve
* @uses phpDocumentor\Reflection\TypeResolver::
* @uses phpDocumentor\Reflection\Types\Context
*/
public function testAddingAKeyword()
{
// Assign
$typeMock = m::mock(Type::class);
// Act
$fixture = new TypeResolver();
$fixture->addKeyword('mock', get_class($typeMock));
// Assert
$result = $fixture->resolve('mock', new Context(''));
$this->assertInstanceOf(get_class($typeMock), $result);
$this->assertNotSame($typeMock, $result);
}
/**
* @covers ::__construct
* @covers ::addKeyword
* @uses phpDocumentor\Reflection\Types\Context
* @expectedException \InvalidArgumentException
*/
public function testAddingAKeywordFailsIfTypeClassDoesNotExist()
{
$fixture = new TypeResolver();
$fixture->addKeyword('mock', 'IDoNotExist');
}
/**
* @covers ::__construct
* @covers ::addKeyword
* @uses phpDocumentor\Reflection\Types\Context
* @expectedException \InvalidArgumentException
*/
public function testAddingAKeywordFailsIfTypeClassDoesNotImplementTypeInterface()
{
$fixture = new TypeResolver();
$fixture->addKeyword('mock', 'stdClass');
}
/**
* @covers ::__construct
* @covers ::resolve
* @uses phpDocumentor\Reflection\Types\Context
*
* @expectedException \InvalidArgumentException
*/
public function testExceptionIsThrownIfTypeIsEmpty()
{
$fixture = new TypeResolver();
$fixture->resolve(' ', new Context(''));
}
/**
* @covers ::__construct
* @covers ::resolve
* @uses phpDocumentor\Reflection\Types\Context
*
* @expectedException \InvalidArgumentException
*/
public function testExceptionIsThrownIfTypeIsNotAString()
{
$fixture = new TypeResolver();
$fixture->resolve(['a'], new Context(''));
}
/**
* Returns a list of keywords and expected classes that are created from them.
*
* @return string[][]
*/
public function provideKeywords()
{
return [
['string', 'phpDocumentor\Reflection\Types\String_'],
['int', 'phpDocumentor\Reflection\Types\Integer'],
['integer', 'phpDocumentor\Reflection\Types\Integer'],
['float', 'phpDocumentor\Reflection\Types\Float_'],
['double', 'phpDocumentor\Reflection\Types\Float_'],
['bool', 'phpDocumentor\Reflection\Types\Boolean'],
['boolean', 'phpDocumentor\Reflection\Types\Boolean'],
['resource', 'phpDocumentor\Reflection\Types\Resource'],
['null', 'phpDocumentor\Reflection\Types\Null_'],
['callable', 'phpDocumentor\Reflection\Types\Callable_'],
['callback', 'phpDocumentor\Reflection\Types\Callable_'],
['array', 'phpDocumentor\Reflection\Types\Array_'],
['scalar', 'phpDocumentor\Reflection\Types\Scalar'],
['object', 'phpDocumentor\Reflection\Types\Object_'],
['mixed', 'phpDocumentor\Reflection\Types\Mixed'],
['void', 'phpDocumentor\Reflection\Types\Void_'],
['$this', 'phpDocumentor\Reflection\Types\This'],
['static', 'phpDocumentor\Reflection\Types\Static_'],
['self', 'phpDocumentor\Reflection\Types\Self_'],
];
}
/**
* Provides a list of FQSENs to test the resolution patterns with.
*
* @return string[][]
*/
public function provideFqcn()
{
return [
'namespace' => ['\phpDocumentor\Reflection'],
'class' => ['\phpDocumentor\Reflection\DocBlock'],
];
}
}
TypeResolver-0.2.1/tests/unit/Types/ 0000775 0000000 0000000 00000000000 13015760036 0017403 5 ustar 00root root 0000000 0000000 TypeResolver-0.2.1/tests/unit/Types/ContextFactoryTest.php 0000664 0000000 0000000 00000013250 13015760036 0023731 0 ustar 00root root 0000000 0000000
* @license http://www.opensource.org/licenses/mit-license.php MIT
* @link http://phpdoc.org
*/
namespace phpDocumentor\Reflection\Types {
// Added imports on purpose as mock for the unit tests, please do not remove.
use Mockery as m;
use phpDocumentor\Reflection\DocBlock,
phpDocumentor\Reflection\DocBlock\Tag;
use phpDocumentor;
use \ReflectionClass; // yes, the slash is part of the test
/**
* @coversDefaultClass \phpDocumentor\Reflection\Types\ContextFactory
* @covers ::
*/
class ContextFactoryTest extends \PHPUnit_Framework_TestCase
{
/**
* @covers ::createFromReflector
* @covers ::createForNamespace
* @uses phpDocumentor\Reflection\Types\Context
*/
public function testReadsNamespaceFromClassReflection()
{
$fixture = new ContextFactory();
$context = $fixture->createFromReflector(new ReflectionClass($this));
$this->assertSame(__NAMESPACE__, $context->getNamespace());
}
/**
* @covers ::createFromReflector
* @covers ::createForNamespace
* @uses phpDocumentor\Reflection\Types\Context
*/
public function testReadsAliasesFromClassReflection()
{
$fixture = new ContextFactory();
$expected = [
'm' => 'Mockery',
'DocBlock' => 'phpDocumentor\Reflection\DocBlock',
'Tag' => 'phpDocumentor\Reflection\DocBlock\Tag',
'phpDocumentor' => 'phpDocumentor',
'ReflectionClass' => 'ReflectionClass'
];
$context = $fixture->createFromReflector(new ReflectionClass($this));
$this->assertSame($expected, $context->getNamespaceAliases());
}
/**
* @covers ::createForNamespace
* @uses phpDocumentor\Reflection\Types\Context
*/
public function testReadsNamespaceFromProvidedNamespaceAndContent()
{
$fixture = new ContextFactory();
$context = $fixture->createForNamespace(__NAMESPACE__, file_get_contents(__FILE__));
$this->assertSame(__NAMESPACE__, $context->getNamespace());
}
/**
* @covers ::createForNamespace
* @uses phpDocumentor\Reflection\Types\Context
*/
public function testReadsAliasesFromProvidedNamespaceAndContent()
{
$fixture = new ContextFactory();
$expected = [
'm' => 'Mockery',
'DocBlock' => 'phpDocumentor\Reflection\DocBlock',
'Tag' => 'phpDocumentor\Reflection\DocBlock\Tag',
'phpDocumentor' => 'phpDocumentor',
'ReflectionClass' => 'ReflectionClass'
];
$context = $fixture->createForNamespace(__NAMESPACE__, file_get_contents(__FILE__));
$this->assertSame($expected, $context->getNamespaceAliases());
}
/**
* @covers ::createForNamespace
* @uses phpDocumentor\Reflection\Types\Context
*/
public function testTraitUseIsNotDetectedAsNamespaceUse()
{
$php = "createForNamespace('Foo', $php);
$this->assertSame([], $context->getNamespaceAliases());
}
/**
* @covers ::createForNamespace
* @uses phpDocumentor\Reflection\Types\Context
*/
public function testAllOpeningBracesAreCheckedWhenSearchingForEndOfClass()
{
$php = 'createForNamespace('Foo', $php);
$this->assertSame([], $context->getNamespaceAliases());
}
/**
* @covers ::createFromReflector
*/
public function testEmptyFileName()
{
$fixture = new ContextFactory();
$context = $fixture->createFromReflector(new \ReflectionClass('stdClass'));
$this->assertSame([], $context->getNamespaceAliases());
}
/**
* @covers ::createFromReflector
*/
public function testEvalDClass()
{
eval(<<createFromReflector(new \ReflectionClass('Foo\Bar'));
$this->assertSame([], $context->getNamespaceAliases());
}
}
}
namespace phpDocumentor\Reflection\Types\Mock {
// the following import should not show in the tests above
use phpDocumentor\Reflection\DocBlock\Description;
}
TypeResolver-0.2.1/tests/unit/Types/ContextTest.php 0000664 0000000 0000000 00000003111 13015760036 0022374 0 ustar 00root root 0000000 0000000
* @license http://www.opensource.org/licenses/mit-license.php MIT
* @link http://phpdoc.org
*/
namespace phpDocumentor\Reflection\Types;
use Mockery as m;
/**
* @coversDefaultClass \phpDocumentor\Reflection\Types\Context
*/
class ContextTest extends \PHPUnit_Framework_TestCase
{
/**
* @covers ::__construct
* @covers ::getNamespace
*/
public function testProvidesANormalizedNamespace()
{
$fixture = new Context('\My\Space');
$this->assertSame('My\Space', $fixture->getNamespace());
}
/**
* @covers ::__construct
* @covers ::getNamespace
*/
public function testInterpretsNamespaceNamedGlobalAsRootNamespace()
{
$fixture = new Context('global');
$this->assertSame('', $fixture->getNamespace());
}
/**
* @covers ::__construct
* @covers ::getNamespace
*/
public function testInterpretsNamespaceNamedDefaultAsRootNamespace()
{
$fixture = new Context('default');
$this->assertSame('', $fixture->getNamespace());
}
/**
* @covers ::__construct
* @covers ::getNamespaceAliases
*/
public function testProvidesNormalizedNamespaceAliases()
{
$fixture = new Context('', ['Space' => '\My\Space']);
$this->assertSame(['Space' => 'My\Space'], $fixture->getNamespaceAliases());
}
}