ApiContext::findMagicMethodResponse() - Code Metrics - Inspection of "Adds integration test for method tag" - phpDocumentor/phpDocumentor - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — develop ( ab0bed...ddf638 )

by Jaap
created 2017-12-31 14:06 UTC
ApiContext::findMagicMethodResponse() A

↳ Parent: ApiContext
Complexity

Conditions	3
Paths	3
Size

Total Lines	17
Code Lines	9
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	3
eloc	9
nc	3
nop	2
dl	0
loc	17
rs	9.4285
c	0
b	0
f	0
<?php
/**
 * This file is part of phpDocumentor.
 *
 *  For the full copyright and license information, please view the LICENSE
 *  file that was distributed with this source code.
 *
 * @copyright 2010-2017 Mike van Riel<[email protected]>
 * @license   http://www.opensource.org/licenses/mit-license.php MIT
 * @link      http://phpdoc.org
 */

namespace phpDocumentor\Behat\Contexts\Ast;

use Behat\Behat\Context\Context;
use Behat\Behat\Tester\Exception\PendingException;
use Behat\Gherkin\Node\PyStringNode;
use phpDocumentor\Descriptor\ArgumentDescriptor;
use phpDocumentor\Descriptor\ClassDescriptor;
use phpDocumentor\Descriptor\Collection;
use phpDocumentor\Descriptor\ConstantDescriptor;
use phpDocumentor\Descriptor\DescriptorAbstract;
use phpDocumentor\Descriptor\FileDescriptor;
use phpDocumentor\Descriptor\MethodDescriptor;
use phpDocumentor\Descriptor\Tag\ParamDescriptor;
use phpDocumentor\Descriptor\Tag\ReturnDescriptor;
use phpDocumentor\Descriptor\Tag\VersionDescriptor;
use phpDocumentor\Descriptor\TraitDescriptor;
use PHPUnit\Framework\Assert;

class ApiContext extends BaseContext implements Context
{
    /**
     * @Then /^the AST has a class named "([^"]*)" in file "([^"]*)"$/
     * @throws \Exception
     */
    public function theASTHasAclassNamedInFile($class, $file)
    {
        $ast = $this->getAst();

        $file = $this->processFilePath($file);
        /** @var FileDescriptor $fileDescriptor */
        $fileDescriptor = $ast->getFiles()->get($file);

        /** @var ClassDescriptor $classDescriptor */
        foreach ($fileDescriptor->getClasses() as $classDescriptor) {
            if ($classDescriptor->getName() === $class) {
                return;
            }
        }

        throw new \Exception(sprintf('Didn\'t find expected class "%s" in "%s"', $class, $file));
    }

    /**
     * @Then /^the class named "([^"]*)" is in the default package$/
     * @throws \Exception
     */
    public function theASTHasAClassInDefaultPackage($class)
    {
        $class = $this->findClassByName($class);

        Assert::assertEquals('Default', $class->getPackage()->getName());
    }

    /**
     * @Then /^the AST has a trait named "([^"]*)" in file "([^"]*)"$/
     * @throws \Exception
     */
    public function theASTHasATraitNamedInFile($trait, $file)
    {
        $ast = $this->getAst();

        $file = $this->processFilePath($file);
        /** @var FileDescriptor $fileDescriptor */
        $fileDescriptor = $ast->getFiles()->get($file);

        /** @var TraitDescriptor $classDescriptor */
        foreach ($fileDescriptor->getTraits() as $classDescriptor) {
            if ($classDescriptor->getName() === $trait) {
                return;
            }
        }

        throw new \Exception(sprintf('Didn\'t find expected trait "%s" in "%s"', $trait, $file));
    }

    /**
     * @param $class
     * @param $expectedContent
     * @Then the class named ":class" has docblock with content:
     */
    public function classHasDocblockWithContent($class, PyStringNode $expectedContent)
    {
        $class = $this->findClassByName($class);

        Assert::assertEquals($expectedContent->getRaw(), $class->getDescription());
    }

    /**
     * @param $classFqsen
     * @param $docElement
     * @param $value
     * @Then class ":classFqsen" has :docElement:
     * @throws \Exception
     */
    public function classHasDocblockContent($classFqsen, $docElement, PyStringNode $value)
    {
        $class = $this->findClassByFqsen($classFqsen);

        $method = 'get' . $docElement;

        Assert::assertEquals($value->getRaw(), $class->$method());
    }

    /**
     * @param $classFqsen
     * @param $elementType
     * @param $elementName
     * @param $docElement
     * @param PyStringNode $value
     * @Then class ":classFqsen" has :elementType :elementName with :docElement:
     */
    public function classHasElementWithDocblockContent($classFqsen, $elementType, $elementName, $docElement, PyStringNode $value)
    {
        $class = $this->findClassByFqsen($classFqsen);

        switch ($elementType) {
            case 'method':
            case 'constant':
                $method = $method = 'get' . $elementType . 's';
                break;
            case 'property':
                $method = 'getProperties';
                break;
            default:
                $method = 'get' . $elementType;
                break;
        }

        $element = $class-> $method()->get($elementName);

        $method = 'get' . $docElement;
        $actual = $element->$method();

        Assert::assertEquals($value->getRaw(), $actual,  sprintf('"%s" does not match "%s"', $actual, $value->getRaw()));

    }

    /**
     * @param $classFqsen
     * @param $value
     * @Then class ":classFqsen" has version :value
     */
    public function classHasVersion($classFqsen, $value)
    {
        $class = $this->findClassByFqsen($classFqsen);

        /** @var VersionDescriptor $tag */
        foreach ($class->getVersion() as $tag) {
            if ($tag->getVersion() === $value) {
                return;
            }
        }

        Assert::fail(sprintf('Didn\'t find expected version "%s"', $value));
    }

    /**
     * @param $classFqsen
     * @param $tagName
     * @Then class ":classFqsen" without tag :tagName
     */
    public function classWithoutTag($classFqsen, $tagName)
    {
        $this->classHasTag($classFqsen, $tagName, 0);
    }

    /**
     * @param string $classFqsen
     * @param string $tagName
     * @param int $expectedNumber
     * @Then class ":classFqsen" has exactly :expectedNumber tag :tagName
     */
    public function classHasTag($classFqsen, $tagName, $expectedNumber)
    {
        $class = $this->findClassByFqsen($classFqsen);
        static::AssertTagCount($class, $tagName, $expectedNumber);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
    }

    /**
     * @param string $classFqsen
     * @param string $tagName
     * @param string $method
     * @Then class ":classFqsen" has a method named :method without tag :tagName
     */
    public function classHasMethodWithoutTag($classFqsen, $tagName, $method)
    {
        $this->classHasMethodWithExpectedCountTag($classFqsen, $tagName, $method, 0);
    }

    /**
     * @param string $classFqsen
     * @param string $tagName
     * @param string $methodName
     * @Then class ":classFqsen" has a method named :method with exactly :expected tag :tagName
     */
    public function classHasMethodWithExpectedCountTag($classFqsen, $tagName, $methodName, $expectedCount)
    {
        $class = $this->findClassByFqsen($classFqsen);
        $method = $class->getMethods()->get($methodName);

        static::AssertTagCount($method, $tagName, $expectedCount);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
    }

    /**
     * @param string $classFqsen
     * @param string $tagName
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     * @param string $methodName
     * @Then class ":classFqsen" has a method :method with argument ":argument is variadic
     */
    public function classHasMethodWithAgumentVariadic($classFqsen, $methodName, $argument)
    {
        $class = $this->findClassByFqsen($classFqsen);
        /** @var MethodDescriptor $method */
        $method = $class->getMethods()->get($methodName);
        Assert::assertArrayHasKey($argument, $method->getArguments());
        /** @var ArgumentDescriptor $argumentD */
        $argumentD = $method->getArguments()[$argument];
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}

        //TODO: enable this check when we support variadic arguments.
        //Assert::assertTrue($argumentD->isVariadic(), 'Expected argument to be variadic');
    }

    /**
     * @param string $classFqsen
     * @param string $tagName
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     * @param string $methodName
     * @Then class ":classFqsen" has a method :method
     */
    public function classHasMethod($classFqsen, $methodName)
    {
        $class = $this->findClassByFqsen($classFqsen);
        /** @var MethodDescriptor $method */
        $method = $class->getMethods()->get($methodName, null);
        Assert::assertInstanceOf(MethodDescriptor::class, $method);
        Assert::assertEquals($methodName, $method->getName());
    }

    /**
     * @param string $classFqsen
     * @param string $methodName
     * @param string $argument
     * @param string $type
     * @Then class ":classFqsen" has a method :method with argument :argument of type ":type"
     */
    public function classHasMethodWithAgumentOfType($classFqsen, $methodName, $argument, $type)
    {
        $class = $this->findClassByFqsen($classFqsen);
        /** @var MethodDescriptor $method */
        $method = $class->getMethods()->get($methodName);
        Assert::assertArrayHasKey($argument, $method->getArguments());
        /** @var ArgumentDescriptor $argumentDescriptor */
        $argumentDescriptor = $method->getArguments()[$argument];

        Assert::assertEquals($type, (string)$argumentDescriptor->getTypes());
    }

    /**
     * @param string $classFqsen
     * @param string $methodName
     * @param string $param
     * @param string $type
     * @Then class ":classFqsen" has a method :method with param :param of type ":type"
     */
    public function classHasMethodWithParamOfType($classFqsen, $methodName, $param, $type)
    {
        $class = $this->findClassByFqsen($classFqsen);
        /** @var MethodDescriptor $method */
        $method = $class->getMethods()->get($methodName);
        /** @var ParamDescriptor $paramDescriptor */
        foreach ($method->getParam() as $paramDescriptor) {
            if($paramDescriptor->getName() === $param) {

                Assert::assertEquals($type, (string)$paramDescriptor->getTypes());
            }
        }
    }

    /**
     * @param string $classFqsen
     * @param string $constantName
     * @Then class ":classFqsen" has a constant :constantName
     */
    public function classHasConstant($classFqsen, $constantName)
    {
        /** @var ClassDescriptor $class */
        $class = $this->findClassByFqsen($classFqsen);
        $constant = $class->getConstants()->get($constantName);
        Assert::assertInstanceOf(ConstantDescriptor::class, $constant);
    }

    /**
     * @param string $className
     * @return ClassDescriptor
     * @throws \Exception
     */
    private function findClassByName($className)
    {
        $ast = $this->getAst();
        foreach ($ast->getFiles() as $file) {
            foreach ($file->getClasses() as $classDescriptor) {
                if ($classDescriptor->getName() === $className) {
                    return $classDescriptor;
                }
            }
        }

        throw new \Exception(sprintf('Didn\'t find expected class "%s"', $className));
    }

    /**
     * @param string $tagName
     * @param int $expectedNumber
     * @param DescriptorAbstract $element
     */
    private static function AssertTagCount($element, $tagName, $expectedNumber)

    {
        /** @var Collection $tagCollection */
        $tagCollection = $element->getTags()->get($tagName, new Collection());

        Assert::assertEquals((int)$expectedNumber, $tagCollection->count());
        if ($expectedNumber > 0) {
            Assert::assertEquals($tagName, $tagCollection[0]->getName());
        }
    }

    /**
     * @Then /^the ast has a file named "([^"]*)" with a summary:$/
     * @throws \Exception
     */
    public function theAstHasAFileNamedWithASummary(string $fileName, PyStringNode $string)
    {
        $ast = $this->getAst();
        /** @var FileDescriptor $file */
        $file = $ast->getFiles()->get($fileName);

        Assert::assertEquals($string->getRaw(), $file->getSummary());
    }

    /**
     * @param string $classFqsen
     * @param string $methodName
     * @param $returnType
     * @throws \Exception
     * @Then class ":classFqsen" has a method :method with returntype :returnType
     * @Then class ":classFqsen" has a method :method with returntype :returnType without description
     */
    public function classHasMethodWithReturnType($classFqsen, $methodName, $returnType)
    {
        $response = $this->findMethodResponse($classFqsen, $methodName);

        Assert::assertEquals($returnType, (string)$response->getTypes());
        Assert::assertEquals('', (string)$response->getDescription());
    }

    /**
     * @param string $classFqsen
     * @param string $methodName
     * @param $returnType
     * @throws \Exception
     * @Then class ":classFqsen" has a magic method :method with returntype :returnType
     * @Then class ":classFqsen" has a magic method :method with returntype :returnType without description
     */
    public function classHasMagicMethodWithReturnType($classFqsen, $methodName, $returnType)
    {
        $response = $this->findMagicMethodResponse($classFqsen, $methodName);

        Assert::assertEquals($returnType, (string)$response->getTypes());
        Assert::assertEquals('', (string)$response->getDescription());
    }

    /**
     * @param string $classFqsen
     * @param string $methodName
     * @param $returnType
     * @throws \Exception
     * @Then class ":classFqsen" has a method :method with returntype :returnType with description:
     */
    public function classHasMethodWithReturnTypeAndDescription($classFqsen, $methodName, $returnType, PyStringNode $description)
    {
        $response = $this->findMethodResponse($classFqsen, $methodName);

        Assert::assertEquals($returnType, (string)$response->getTypes());
        Assert::assertEquals($description, (string)$response->getDescription());
    }

    /**
     * @Then class ":classFqsen" has a method ":method" without returntype
     * @throws \Exception
     */
    public function classReturnTaggetReturnWithoutAnyWithoutReturntype($classFqsen, $methodName)
    {
        $response = $this->findMethodResponse($classFqsen, $methodName);
        Assert::assertEquals('mixed', (string)$response->getTypes());
        Assert::assertEquals('', $response->getDescription());
    }

    /**
     * @param $fqsen
     * @param $returnType
     * @throws \Exception
     * @Then has function :fqsen with returntype :returnType
     * @Then has function :fqsen with returntype :returnType without description
     */
    public function functionWithReturnType($fqsen, $returnType)
    {
        $response = $this->findFunctionResponse($fqsen);

        Assert::assertEquals($returnType, (string)$response->getTypes());
        Assert::assertEquals('', (string)$response->getDescription());
    }

    /**
     * @param $fqsen
     * @param $returnType
     * @param PyStringNode $description
     * @throws \Exception
     * @Then has function :fqsen with returntype :returnType with description:
     */
    public function functionWithReturnTypeAndDescription($fqsen, $returnType, PyStringNode $description)
    {
        $response = $this->findFunctionResponse($fqsen);

        Assert::assertEquals($returnType, (string)$response->getTypes());
        Assert::assertEquals($description, (string)$response->getDescription());
    }

    /**
     * @Then has function :fqsen without returntype
     * @throws \Exception
     */
    public function functionWithoutReturntype($fqsen)
    {
        $response = $this->findFunctionResponse($fqsen);
        Assert::assertEquals('mixed', (string)$response->getTypes());
        Assert::assertEquals('', $response->getDescription());
    }

    /**
     * @param $classFqsen
     * @param $methodName
     * @return ReturnDescriptor
     * @throws \Exception
     */
    private function findMethodResponse($classFqsen, $methodName): ReturnDescriptor
    {
        $class = $this->findClassByFqsen($classFqsen);
        /** @var MethodDescriptor $method */
        $method = $class->getMethods()->get($methodName, null);
        Assert::assertInstanceOf(MethodDescriptor::class, $method);
        Assert::assertEquals($methodName, $method->getName());

        $response = $method->getResponse();
        return $response;
    }

    /**
     * @param $classFqsen
     * @param $methodName
     * @return ReturnDescriptor
     * @throws \Exception
     */
    private function findMagicMethodResponse($classFqsen, $methodName): ReturnDescriptor
    {
        $class = $this->findClassByFqsen($classFqsen);
        $match = null;

        /** @var MethodDescriptor $method */
        foreach ($class->getMagicMethods() as $method) {
            if ($method->getName() === $methodName) {
                $match = $method;
            }
        }

        Assert::assertInstanceOf(MethodDescriptor::class, $match);
        Assert::assertEquals($methodName, $match->getName());

        return $match->getResponse();
    }

    /**
     * @param string $fqsen
     * @return ReturnDescriptor
     * @throws \Exception
     */
    private function findFunctionResponse(string $fqsen): ReturnDescriptor
    {
        $function = $this->findFunctionByFqsen($fqsen);
        return $function->getResponse();
    }

    /**
     * @Then class ":classFqsen" has a magic method :method with argument ":argument" of type :type
     */
    public function classHasMagicMethodWithArgument($classFqsen, $methodName, $argument, $type)

    {
        $class = $this->findClassByFqsen($classFqsen);
        $match = null;

        /** @var MethodDescriptor $method */
        foreach ($class->getMagicMethods() as $method) {
            if ($method->getName() === $methodName) {
                $match = $method;
            }
        }

        Assert::assertInstanceOf(MethodDescriptor::class, $match);
        Assert::assertNotNull($match->getArguments()->get($argument));
    }
}

phpDocumentor / phpDocumentor

Push — develop ( ab0bed...ddf638 )

ApiContext::findMagicMethodResponse() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
