SkeletonFilter::substituteFunctionHeaders() - Code Metrics - Inspection of "Merge pull request #46 from wick-ed/hotfix/1121" - appserver-io/doppelgaenger - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 75665e...742229 )

by Bernhard

created 2019-05-14 09:44 UTC

SkeletonFilter::substituteFunctionHeaders() B

↳ Parent: SkeletonFilter

Complexity

Conditions	6
Paths	10

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	44
rs	8.5937
c	0
b	0
f	0
cc	6
nc	10
nop	2

<?php

/**
 * \AppserverIo\Doppelgaenger\StreamFilters\SkeletonFilter
 *
 * NOTICE OF LICENSE
 *
 * This source file is subject to the Open Software License (OSL 3.0)
 * that is available through the world-wide-web at this URL:
 * http://opensource.org/licenses/osl-3.0.php
 *
 * PHP version 5
 *
 * @author    Bernhard Wick <[email protected]>
 * @copyright 2015 TechDivision GmbH - <[email protected]>
 * @license   http://opensource.org/licenses/osl-3.0.php Open Software License (OSL 3.0)
 * @link      https://github.com/appserver-io/doppelgaenger
 * @link      http://www.appserver.io/
 */

namespace AppserverIo\Doppelgaenger\StreamFilters;

use AppserverIo\Doppelgaenger\Entities\Definitions\FunctionDefinition;
use AppserverIo\Doppelgaenger\Exceptions\GeneratorException;
use AppserverIo\Doppelgaenger\Dictionaries\Placeholders;
use AppserverIo\Doppelgaenger\Dictionaries\ReservedKeywords;
use AppserverIo\Doppelgaenger\Interfaces\StructureDefinitionInterface;
use AppserverIo\Doppelgaenger\Utils\Parser;
use AppserverIo\Doppelgaenger\Entities\Definitions\ClassDefinition;
use AppserverIo\Doppelgaenger\Entities\Definitions\InterfaceDefinition;
use AppserverIo\Doppelgaenger\Entities\Definitions\TraitDefinition;

/**
 * This filter is the most important one!
 * It will analyze the need to act upon the content we get and prepare placeholder for coming filters so they
 * do not have to do the analyzing part again.
 * This placeholder system also makes them highly optional, configur- and interchangeable.
 *
 * @author    Bernhard Wick <[email protected]>
 * @copyright 2015 TechDivision GmbH - <[email protected]>
 * @license   http://opensource.org/licenses/osl-3.0.php Open Software License (OSL 3.0)
 * @link      https://github.com/appserver-io/doppelgaenger
 * @link      http://www.appserver.io/
 */
class SkeletonFilter extends AbstractFilter
{

    /**
     * Order number if filters are used as a stack, higher means below others
     *
     * @const integer FILTER_ORDER
     */
    const FILTER_ORDER = 0;

    /**
     * Will filter portions of incoming stream content.
     * Will always contain false to enforce buffering of all buckets.
     *
     * @param string $content The content to be filtered
     *
     * @return boolean
     */
    public function filterContent($content)
    {
        return false;
    }

    /**
     * Preparation hook which is intended to be called at the start of the first filter() iteration.
     * We will inject the original path hint here
     *
     * @param string $bucketData Payload of the first filtered bucket
     *
     * @return void
     */
    public function firstBucket(&$bucketData)
    {
        $this->injectOriginalPathHint($bucketData, $this->structureDefinition->getPath());
    }

    /**
     * Will find the index of the last character within a structure
     *
     * @param string $code          The structure code to search in
     * @param string $structureName Name of the structure to get the last index for
     * @param string $structureType Type of the structure in question
     *
     * @return integer
     */
    protected function findLastStructureIndex($code, $structureName, $structureType)
    {
        // determine which keyword we should search for
        switch ($structureType) {
            case InterfaceDefinition::TYPE:
                $structureKeyword = 'interface';
                break;

            case TraitDefinition::TYPE:
                $structureKeyword = 'trait';
                break;

            default:
                $structureKeyword = 'class';
                break;
        }

        // cut everything in front of the first bracket so we have a better start
        $matches = array();
        preg_match('/.*' . $structureKeyword . '\s+' . $structureName . '.+?{/s', $code, $matches);
        if (count($matches) != 1) {
            throw new GeneratorException(sprintf('Could not find last index for stucture %s. Cannot generate proxy skeleton.', $structureName));
        }

        $offset = (strlen(reset($matches)) - 1);
        // get a parser util and get the bracket span
        $parserUtil = new Parser();
        $structureSpan = $parserUtil->getBracketSpan($code, '{', $offset);

        return (($structureSpan + $offset) - 1);
    }

    /**
     * Preparation hook which is intended to be called at the start of the first filter() iteration.
     * We will inject the original path hint here
     *
     * @return void
     */
    public function finish()
    {
        // we have to substitute magic __DIR__ and __FILE__ constants
        $this->substituteLocationConstants($this->bucketBuffer, $this->structureDefinition->getPath());

        // substitute the original function declarations for the renamed ones
        $this->substituteFunctionHeaders($this->bucketBuffer, $this->structureDefinition);

        // mark the end of the structure as this is an important hook for other things to be woven
        $lastIndex = $this->findLastStructureIndex($this->bucketBuffer, $this->structureDefinition->getName(), $this->structureDefinition->getType());
        $this->bucketBuffer = substr_replace($this->bucketBuffer, Placeholders::STRUCTURE_END, $lastIndex, 0);

        // inject the code for the function skeletons
        $this->injectFunctionSkeletons($this->bucketBuffer, $this->structureDefinition, true);
    }

    /**
     * The main filter method.
     * Implemented according to \php_user_filter class. Will loop over all stream buckets, buffer them and perform
     * the needed actions.
     *
     * @param resource $in       Incoming bucket brigade we need to filter
     * @param resource $out      Outgoing bucket brigade with already filtered content
     * @param integer  $consumed The count of altered characters as buckets pass the filter
     * @param boolean  $closing  Is the stream about to close?
     *
     * @throws \AppserverIo\Doppelgaenger\Exceptions\GeneratorException
     *
     * @return integer
     *
     * @link http://www.php.net/manual/en/php-user-filter.filter.php
     */
    public function filter($in, $out, &$consumed, $closing)
    {
        // make the params more prominent
        $this->structureDefinition = $this->params;

        // use the parent filter method to allow for proper hook usage
        return parent::filter($in, $out, $consumed, $closing);
    }

    /**
     * Will inject condition checking code in front and behind the functions body.
     *
     * @param string                                                             $bucketData          Payload of the currently filtered bucket
     * @param \AppserverIo\Doppelgaenger\Interfaces\StructureDefinitionInterface $structureDefinition The original path we have to place as our constants
     * @param boolean                                                            $beautify            Whether or not the injected code should be beautified first
     *
     * @return boolean
     */
    protected function injectFunctionSkeletons(& $bucketData, StructureDefinitionInterface $structureDefinition, $beautify = false)

    {

        // generate the skeleton code for all known functions
        $functionSkeletonsCode = '';
        foreach ($structureDefinition->getFunctionDefinitions() as $functionDefinition) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
            // we do not have to act on abstract methods
            if ($functionDefinition->isAbstract()) {
                continue;
            }

            // __get and __set need some special steps so we can inject our own logic into them
            $injectNeeded = false;
            if ($functionDefinition->getName() === '__get' || $functionDefinition->getName() === '__set') {
                $injectNeeded = true;
            }

            // get the code used before the original body
            $functionSkeletonsCode .= $this->generateSkeletonCode($injectNeeded, $functionDefinition);
        }

        // inject the new code at the end of the original structure body
        $bucketData = str_replace(Placeholders::STRUCTURE_END, Placeholders::STRUCTURE_END . $functionSkeletonsCode, $bucketData);

        // if we are still here we seem to have succeeded
        return true;
    }

    /**
     * Will generate the skeleton code for the passed function definition.
     * Will result in a string resembling the following example:
     *
     *      <FUNCTION_DOCBLOCK>
     *      <FUNCTION_MODIFIERS> function <FUNCTION_NAME>(<FUNCTION_PARAMS>)
     *      {
     *          $dgStartLine = <FUNCTION_START_LINE>;
     *          $dgEndLine = <FUNCTION_END_LINE>;
     *          / DOPPELGAENGER_FUNCTION_BEGIN_PLACEHOLDER <FUNCTION_NAME> /
     *          / DOPPELGAENGER_BEFORE_JOINPOINT <FUNCTION_NAME> /
     *          $dgOngoingContract = \AppserverIo\Doppelgaenger\ContractContext::open();
     *          / DOPPELGAENGER_INVARIANT_PLACEHOLDER /
     *          / DOPPELGAENGER_PRECONDITION_PLACEHOLDER <FUNCTION_NAME> /
     *          / DOPPELGAENGER_OLD_SETUP_PLACEHOLDER <FUNCTION_NAME> /
     *          $dgResult = null;
     *          try {
     *              / DOPPELGAENGER_AROUND_JOINPOINT <FUNCTION_NAME> /
     *
     *          } catch (\Exception $dgThrownExceptionObject) {
     *              / DOPPELGAENGER_AFTERTHROWING_JOINPOINT <FUNCTION_NAME> /
     *
     *              // rethrow the exception
     *              throw $dgThrownExceptionObject;
     *
     *          } finally {
     *              / DOPPELGAENGER_AFTER_JOINPOINT <FUNCTION_NAME> /
     *
     *          }
     *          / DOPPELGAENGER_POSTCONDITION_PLACEHOLDER <FUNCTION_NAME> /
     *          / DOPPELGAENGER_INVARIANT_PLACEHOLDER /
     *          if ($dgOngoingContract) {
     *              \AppserverIo\Doppelgaenger\ContractContext::close();
     *          } / DOPPELGAENGER_AFTERRETURNING_JOINPOINT <FUNCTION_NAME> /
     *
     *          return $dgResult;
     *      }
     *
     * @param boolean            $injectNeeded       Determine if we have to use a try...catch block
     * @param FunctionDefinition $functionDefinition The function definition object
     *
     * @return string
     */
    protected function generateSkeletonCode($injectNeeded, FunctionDefinition $functionDefinition)
    {

        // first of all: the docblock
        $code = '
        ' . $functionDefinition->getDocBlock() . '
        ' . $functionDefinition->getHeader('definition') . '
        {
            ' . ReservedKeywords::START_LINE_VARIABLE . ' = ' . (integer) $functionDefinition->getStartLine() . ';
            ' . ReservedKeywords::END_LINE_VARIABLE . ' = ' . (integer) $functionDefinition->getEndLine() . ';
            ' . Placeholders::FUNCTION_BEGIN . $functionDefinition->getName() . Placeholders::PLACEHOLDER_CLOSE . '
            ';

        // right after: the "before" join-point
        $code .= Placeholders::BEFORE_JOINPOINT . $functionDefinition->getName() . Placeholders::PLACEHOLDER_CLOSE . '
            ';

        // open the contract context so we are able to avoid endless recursion
        $code .= ReservedKeywords::CONTRACT_CONTEXT . ' = \AppserverIo\Doppelgaenger\ContractContext::open();
            ';

        // Invariant is not needed in private or static functions.
        // Also make sure that there is none in front of the constructor check
        if ($functionDefinition->getVisibility() !== 'private' &&
            !$functionDefinition->isStatic() && $functionDefinition->getName() !== '__construct'
        ) {
            $code .= Placeholders::INVARIANT_CALL_START . '
            ';
        }

        $code .= Placeholders::PRECONDITION . $functionDefinition->getName() . Placeholders::PLACEHOLDER_CLOSE . '
            ' . Placeholders::OLD_SETUP . $functionDefinition->getName() . Placeholders::PLACEHOLDER_CLOSE. '
            ';

        // we will wrap code execution in order to provide a "finally" and "after throwing" placeholder hook.
        // we will also predefine the result as NULL to avoid warnings
        $code .= ReservedKeywords::RESULT . ' = null;
            try {
                ' .  Placeholders::AROUND_JOINPOINT . $functionDefinition->getName() . Placeholders::PLACEHOLDER_CLOSE . '
        ';

        // add the second part of the try/catch/finally block
        $code .= '
            } catch (\Exception ' . ReservedKeywords::THROWN_EXCEPTION_OBJECT . ') {
                ' . Placeholders::AFTERTHROWING_JOINPOINT . $functionDefinition->getName() . Placeholders::PLACEHOLDER_CLOSE . '
                // rethrow the exception
                throw ' . ReservedKeywords::THROWN_EXCEPTION_OBJECT . ';
            } finally {
        ';

        // if we have to inject additional code, we might do so here
        if ($injectNeeded === true) {
            $code .= Placeholders::METHOD_INJECT . $functionDefinition->getName() . Placeholders::PLACEHOLDER_CLOSE;
        }

        // finish of the block
        $code .= '        ' . Placeholders::AFTER_JOINPOINT . $functionDefinition->getName() . Placeholders::PLACEHOLDER_CLOSE . '
            }
        ';

        // now just place all the other placeholder for other filters to come
        $code .= '    ' . Placeholders::POSTCONDITION . $functionDefinition->getName() . Placeholders::PLACEHOLDER_CLOSE;

        // Invariant is not needed in private or static functions
        if ($functionDefinition->getVisibility() !== 'private' && !$functionDefinition->isStatic()) {
            $code .= '
            ' . Placeholders::INVARIANT_CALL_END . '
            ';
        }

        // close of the contract context
        $code .= 'if (' . ReservedKeywords::CONTRACT_CONTEXT . ') {
                \AppserverIo\Doppelgaenger\ContractContext::close();
            }
        ';

        // last of all: the "after returning" join-point and the final return from the proxy
        $code .= '    ' . Placeholders::AFTERRETURNING_JOINPOINT . $functionDefinition->getName() . Placeholders::PLACEHOLDER_CLOSE . '
            return ' . ReservedKeywords::RESULT . ';
        }
        ';

        return $code;
    }

    /**
     * Will substitute all function headers (we know about) with function headers indicating an original implementation by appending
     * a specific suffix
     *
     * @param string                                                             $bucketData          Payload of the currently filtered bucket
     * @param \AppserverIo\Doppelgaenger\Interfaces\StructureDefinitionInterface $structureDefinition The original path we have to place as our constants
     *
     * @return boolean
     *
     * @throws GeneratorException
     */
    protected function substituteFunctionHeaders(& $bucketData, StructureDefinitionInterface $structureDefinition)
    {
        // is there event anything to substitute?
        if ($structureDefinition->getFunctionDefinitions()->count() <= 0) {
            return true;
        }

        // first of all we have to collect all functions we have to substitute
        $functionSubstitutes = array();
        $functionPatterns = array();
        foreach ($structureDefinition->getFunctionDefinitions() as $functionDefinition) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
            // we do not have to act on abstract methods
            if ($functionDefinition->isAbstract()) {
                continue;
            }

            $functionPatterns[] = '/function\s+' . $functionDefinition->getName() . '\s*\(/';
            $functionSubstitutes[] = 'function ' . $functionDefinition->getName() . ReservedKeywords::ORIGINAL_FUNCTION_SUFFIX . '(';
        }

        // do the actual replacing and propagate the result in success
        $replacementCounter = 0;
        $result = preg_replace($functionPatterns, $functionSubstitutes, $bucketData, -1, $replacementCounter);

        // if we have more (or less) things to substitute than substitutes, something has gone wrong
        if ($replacementCounter !== count($functionPatterns)) {
            throw new GeneratorException(
                sprintf(
                    'Failed to substitute original function headers for "%s": Mismatching count of found and substituted function headers. Expected %s, got %s',
                    $structureDefinition->getQualifiedName(),
                    count($functionPatterns),
                    $replacementCounter
                )
            );
        }

        if (!is_null($result)) {
            $bucketData = $result;
            return true;
        }

        // still here? That seems to be wrong
        return false;
    }

    /**
     * Will substitute all magic __DIR__ and __FILE__ constants with our prepared substitutes to
     * emulate original original filesystem context when in cache folder.
     *
     * @param string $bucketData Payload of the currently filtered bucket
     * @param string $file       The original path we have to place as our constants
     *
     * @return boolean
     */
    protected function substituteLocationConstants(& $bucketData, $file)
    {
        $dir = dirname($file);
        // Inject the code
        $bucketData = str_replace(
            array('__DIR__', '__FILE__'),
            array('\'' . $dir . '\'', '\'' . $file . '\''),
            $bucketData
        );

        // Still here? Success then
        return true;
    }

    /**
     * Will inject a placeholder that is used to store metadata about the original file
     *
     * @param string $bucketData Payload of the currently filtered bucket
     * @param string $file       The original file path we have to inject
     *
     * @return boolean
     */
    protected function injectOriginalPathHint(& $bucketData, $file)
    {
        // Do need to do this?
        if (strpos($bucketData, '<?php') === false) {
            return false;
        }

        // Build up the needed code for our hint
        $code = ' ' . Placeholders::PLACEHOLDER_OPEN . Placeholders::ORIGINAL_PATH_HINT . $file . '#' .
            filemtime(
                $file
            ) . Placeholders::ORIGINAL_PATH_HINT . Placeholders::PLACEHOLDER_CLOSE;

        // Inject the code
        $index = strpos($bucketData, '<?php');
        $bucketData = substr_replace($bucketData, $code, $index + 5, 0);

        // Still here? Success then.
        return true;
    }
}


1		<?php
2
3		/**
4		* \AppserverIo\Doppelgaenger\StreamFilters\SkeletonFilter
5		*
6		* NOTICE OF LICENSE
7		*
8		* This source file is subject to the Open Software License (OSL 3.0)
9		* that is available through the world-wide-web at this URL:
10		* http://opensource.org/licenses/osl-3.0.php
11		*
12		* PHP version 5
13		*
14		* @author Bernhard Wick <[email protected]>
15		* @copyright 2015 TechDivision GmbH - <[email protected]>
16		* @license http://opensource.org/licenses/osl-3.0.php Open Software License (OSL 3.0)
17		* @link https://github.com/appserver-io/doppelgaenger
18		* @link http://www.appserver.io/
19		*/
20
21		namespace AppserverIo\Doppelgaenger\StreamFilters;
22
23		use AppserverIo\Doppelgaenger\Entities\Definitions\FunctionDefinition;
24		use AppserverIo\Doppelgaenger\Exceptions\GeneratorException;
25		use AppserverIo\Doppelgaenger\Dictionaries\Placeholders;
26		use AppserverIo\Doppelgaenger\Dictionaries\ReservedKeywords;
27		use AppserverIo\Doppelgaenger\Interfaces\StructureDefinitionInterface;
28		use AppserverIo\Doppelgaenger\Utils\Parser;
29		use AppserverIo\Doppelgaenger\Entities\Definitions\ClassDefinition;
30		use AppserverIo\Doppelgaenger\Entities\Definitions\InterfaceDefinition;
31		use AppserverIo\Doppelgaenger\Entities\Definitions\TraitDefinition;
32
33		/**
34		* This filter is the most important one!
35		* It will analyze the need to act upon the content we get and prepare placeholder for coming filters so they
36		* do not have to do the analyzing part again.
37		* This placeholder system also makes them highly optional, configur- and interchangeable.
38		*
39		* @author Bernhard Wick <[email protected]>
40		* @copyright 2015 TechDivision GmbH - <[email protected]>
41		* @license http://opensource.org/licenses/osl-3.0.php Open Software License (OSL 3.0)
42		* @link https://github.com/appserver-io/doppelgaenger
43		* @link http://www.appserver.io/
44		*/
45		class SkeletonFilter extends AbstractFilter
46		{
47
48		/**
49		* Order number if filters are used as a stack, higher means below others
50		*
51		* @const integer FILTER_ORDER
52		*/
53		const FILTER_ORDER = 0;
54
55		/**
56		* Will filter portions of incoming stream content.
57		* Will always contain false to enforce buffering of all buckets.
58		*
59		* @param string $content The content to be filtered
60		*
61		* @return boolean
62		*/
63		public function filterContent($content)
64		{
65		return false;
66		}
67
68		/**
69		* Preparation hook which is intended to be called at the start of the first filter() iteration.
70		* We will inject the original path hint here
71		*
72		* @param string $bucketData Payload of the first filtered bucket
73		*
74		* @return void
75		*/
76		public function firstBucket(&$bucketData)
77		{
78		$this->injectOriginalPathHint($bucketData, $this->structureDefinition->getPath());
79		}
80
81		/**
82		* Will find the index of the last character within a structure
83		*
84		* @param string $code The structure code to search in
85		* @param string $structureName Name of the structure to get the last index for
86		* @param string $structureType Type of the structure in question
87		*
88		* @return integer
89		*/
90		protected function findLastStructureIndex($code, $structureName, $structureType)
91		{
92		// determine which keyword we should search for
93		switch ($structureType) {
94		case InterfaceDefinition::TYPE:
95		$structureKeyword = 'interface';
96		break;
97
98		case TraitDefinition::TYPE:
99		$structureKeyword = 'trait';
100		break;
101
102		default:
103		$structureKeyword = 'class';
104		break;
105		}
106
107		// cut everything in front of the first bracket so we have a better start
108		$matches = array();
109		preg_match('/.*' . $structureKeyword . '\s+' . $structureName . '.+?{/s', $code, $matches);
110		if (count($matches) != 1) {
111		throw new GeneratorException(sprintf('Could not find last index for stucture %s. Cannot generate proxy skeleton.', $structureName));
112		}
113
114		$offset = (strlen(reset($matches)) - 1);
115		// get a parser util and get the bracket span
116		$parserUtil = new Parser();
117		$structureSpan = $parserUtil->getBracketSpan($code, '{', $offset);
118
119		return (($structureSpan + $offset) - 1);
120		}
121
122		/**
123		* Preparation hook which is intended to be called at the start of the first filter() iteration.
124		* We will inject the original path hint here
125		*
126		* @return void
127		*/
128		public function finish()
129		{
130		// we have to substitute magic __DIR__ and __FILE__ constants
131		$this->substituteLocationConstants($this->bucketBuffer, $this->structureDefinition->getPath());
132
133		// substitute the original function declarations for the renamed ones
134		$this->substituteFunctionHeaders($this->bucketBuffer, $this->structureDefinition);
135
136		// mark the end of the structure as this is an important hook for other things to be woven
137		$lastIndex = $this->findLastStructureIndex($this->bucketBuffer, $this->structureDefinition->getName(), $this->structureDefinition->getType());
138		$this->bucketBuffer = substr_replace($this->bucketBuffer, Placeholders::STRUCTURE_END, $lastIndex, 0);
139
140		// inject the code for the function skeletons
141		$this->injectFunctionSkeletons($this->bucketBuffer, $this->structureDefinition, true);
142		}
143
144		/**
145		* The main filter method.
146		* Implemented according to \php_user_filter class. Will loop over all stream buckets, buffer them and perform
147		* the needed actions.
148		*
149		* @param resource $in Incoming bucket brigade we need to filter
150		* @param resource $out Outgoing bucket brigade with already filtered content
151		* @param integer $consumed The count of altered characters as buckets pass the filter
152		* @param boolean $closing Is the stream about to close?
153		*
154		* @throws \AppserverIo\Doppelgaenger\Exceptions\GeneratorException
155		*
156		* @return integer
157		*
158		* @link http://www.php.net/manual/en/php-user-filter.filter.php
159		*/
160		public function filter($in, $out, &$consumed, $closing)
161		{
162		// make the params more prominent
163		$this->structureDefinition = $this->params;
164
165		// use the parent filter method to allow for proper hook usage
166		return parent::filter($in, $out, $consumed, $closing);
167		}
168
169		/**
170		* Will inject condition checking code in front and behind the functions body.
171		*
172		* @param string $bucketData Payload of the currently filtered bucket
173		* @param \AppserverIo\Doppelgaenger\Interfaces\StructureDefinitionInterface $structureDefinition The original path we have to place as our constants
174		* @param boolean $beautify Whether or not the injected code should be beautified first
175		*
176		* @return boolean
177		*/
178		protected function injectFunctionSkeletons(& $bucketData, StructureDefinitionInterface $structureDefinition, $beautify = false)
		0 ignored issues – show Unused Code introduced 2017-11-29 17:31 UTC by Report Bug Copy Issue Report The parameter `$beautify` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
179		{
180
181		// generate the skeleton code for all known functions
182		$functionSkeletonsCode = '';
183		foreach ($structureDefinition->getFunctionDefinitions() as $functionDefinition) {
		0 ignored issues – show Bug introduced 2016-02-05 16:15 UTC by Report Bug Copy Issue Report The expression `$structureDefinition->getFunctionDefinitions()` of type `null\|object<AppserverIo\...FunctionDefinitionList>` is not guaranteed to be traversable. How about adding an additional type check? There are different options of fixing this problem. If you want to be on the safe side, you can add an additional type-check: $collection = json_decode($data, true); if ( ! is_array($collection)) { throw new \RuntimeException('$collection must be an array.'); } foreach ($collection as $item) { /** ... / } If you are sure that the expression is traversable, you might want to add a doc comment cast* to improve IDE auto-completion and static analysis: /** @var array $collection / $collection = json_decode($data, true); foreach ($collection as $item) { /* .. / } Mark the issue as a false-positive*: Just hover the remove button, in the top-right corner of this issue for more options. Loading history...
184		// we do not have to act on abstract methods
185		if ($functionDefinition->isAbstract()) {
186		continue;
187		}
188
189		// __get and __set need some special steps so we can inject our own logic into them
190		$injectNeeded = false;
191		if ($functionDefinition->getName() === '__get' \|\| $functionDefinition->getName() === '__set') {
192		$injectNeeded = true;
193		}
194
195		// get the code used before the original body
196		$functionSkeletonsCode .= $this->generateSkeletonCode($injectNeeded, $functionDefinition);
197		}
198
199		// inject the new code at the end of the original structure body
200		$bucketData = str_replace(Placeholders::STRUCTURE_END, Placeholders::STRUCTURE_END . $functionSkeletonsCode, $bucketData);
201
202		// if we are still here we seem to have succeeded
203		return true;
204		}
205
206		/**
207		* Will generate the skeleton code for the passed function definition.
208		* Will result in a string resembling the following example:
209		*
210		* <FUNCTION_DOCBLOCK>
211		* <FUNCTION_MODIFIERS> function <FUNCTION_NAME>(<FUNCTION_PARAMS>)
212		* {
213		* $dgStartLine = <FUNCTION_START_LINE>;
214		* $dgEndLine = <FUNCTION_END_LINE>;
215		* / DOPPELGAENGER_FUNCTION_BEGIN_PLACEHOLDER <FUNCTION_NAME> /
216		* / DOPPELGAENGER_BEFORE_JOINPOINT <FUNCTION_NAME> /
217		* $dgOngoingContract = \AppserverIo\Doppelgaenger\ContractContext::open();
218		* / DOPPELGAENGER_INVARIANT_PLACEHOLDER /
219		* / DOPPELGAENGER_PRECONDITION_PLACEHOLDER <FUNCTION_NAME> /
220		* / DOPPELGAENGER_OLD_SETUP_PLACEHOLDER <FUNCTION_NAME> /
221		* $dgResult = null;
222		* try {
223		* / DOPPELGAENGER_AROUND_JOINPOINT <FUNCTION_NAME> /
224		*
225		* } catch (\Exception $dgThrownExceptionObject) {
226		* / DOPPELGAENGER_AFTERTHROWING_JOINPOINT <FUNCTION_NAME> /
227		*
228		* // rethrow the exception
229		* throw $dgThrownExceptionObject;
230		*
231		* } finally {
232		* / DOPPELGAENGER_AFTER_JOINPOINT <FUNCTION_NAME> /
233		*
234		* }
235		* / DOPPELGAENGER_POSTCONDITION_PLACEHOLDER <FUNCTION_NAME> /
236		* / DOPPELGAENGER_INVARIANT_PLACEHOLDER /
237		* if ($dgOngoingContract) {
238		* \AppserverIo\Doppelgaenger\ContractContext::close();
239		* } / DOPPELGAENGER_AFTERRETURNING_JOINPOINT <FUNCTION_NAME> /
240		*
241		* return $dgResult;
242		* }
243		*
244		* @param boolean $injectNeeded Determine if we have to use a try...catch block
245		* @param FunctionDefinition $functionDefinition The function definition object
246		*
247		* @return string
248		*/
249		protected function generateSkeletonCode($injectNeeded, FunctionDefinition $functionDefinition)
250		{
251
252		// first of all: the docblock
253		$code = '
254		' . $functionDefinition->getDocBlock() . '
255		' . $functionDefinition->getHeader('definition') . '
256		{
257		' . ReservedKeywords::START_LINE_VARIABLE . ' = ' . (integer) $functionDefinition->getStartLine() . ';
258		' . ReservedKeywords::END_LINE_VARIABLE . ' = ' . (integer) $functionDefinition->getEndLine() . ';
259		' . Placeholders::FUNCTION_BEGIN . $functionDefinition->getName() . Placeholders::PLACEHOLDER_CLOSE . '
260		';
261
262		// right after: the "before" join-point
263		$code .= Placeholders::BEFORE_JOINPOINT . $functionDefinition->getName() . Placeholders::PLACEHOLDER_CLOSE . '
264		';
265
266		// open the contract context so we are able to avoid endless recursion
267		$code .= ReservedKeywords::CONTRACT_CONTEXT . ' = \AppserverIo\Doppelgaenger\ContractContext::open();
268		';
269
270		// Invariant is not needed in private or static functions.
271		// Also make sure that there is none in front of the constructor check
272	View Code Duplication	if ($functionDefinition->getVisibility() !== 'private' &&
273		!$functionDefinition->isStatic() && $functionDefinition->getName() !== '__construct'
274		) {
275		$code .= Placeholders::INVARIANT_CALL_START . '
276		';
277		}
278
279		$code .= Placeholders::PRECONDITION . $functionDefinition->getName() . Placeholders::PLACEHOLDER_CLOSE . '
280		' . Placeholders::OLD_SETUP . $functionDefinition->getName() . Placeholders::PLACEHOLDER_CLOSE. '
281		';
282
283		// we will wrap code execution in order to provide a "finally" and "after throwing" placeholder hook.
284		// we will also predefine the result as NULL to avoid warnings
285		$code .= ReservedKeywords::RESULT . ' = null;
286		try {
287		' . Placeholders::AROUND_JOINPOINT . $functionDefinition->getName() . Placeholders::PLACEHOLDER_CLOSE . '
288		';
289
290		// add the second part of the try/catch/finally block
291		$code .= '
292		} catch (\Exception ' . ReservedKeywords::THROWN_EXCEPTION_OBJECT . ') {
293		' . Placeholders::AFTERTHROWING_JOINPOINT . $functionDefinition->getName() . Placeholders::PLACEHOLDER_CLOSE . '
294		// rethrow the exception
295		throw ' . ReservedKeywords::THROWN_EXCEPTION_OBJECT . ';
296		} finally {
297		';
298
299		// if we have to inject additional code, we might do so here
300		if ($injectNeeded === true) {
301		$code .= Placeholders::METHOD_INJECT . $functionDefinition->getName() . Placeholders::PLACEHOLDER_CLOSE;
302		}
303
304		// finish of the block
305		$code .= ' ' . Placeholders::AFTER_JOINPOINT . $functionDefinition->getName() . Placeholders::PLACEHOLDER_CLOSE . '
306		}
307		';
308
309		// now just place all the other placeholder for other filters to come
310		$code .= ' ' . Placeholders::POSTCONDITION . $functionDefinition->getName() . Placeholders::PLACEHOLDER_CLOSE;
311
312		// Invariant is not needed in private or static functions
313	View Code Duplication	if ($functionDefinition->getVisibility() !== 'private' && !$functionDefinition->isStatic()) {
314		$code .= '
315		' . Placeholders::INVARIANT_CALL_END . '
316		';
317		}
318
319		// close of the contract context
320		$code .= 'if (' . ReservedKeywords::CONTRACT_CONTEXT . ') {
321		\AppserverIo\Doppelgaenger\ContractContext::close();
322		}
323		';
324
325		// last of all: the "after returning" join-point and the final return from the proxy
326		$code .= ' ' . Placeholders::AFTERRETURNING_JOINPOINT . $functionDefinition->getName() . Placeholders::PLACEHOLDER_CLOSE . '
327		return ' . ReservedKeywords::RESULT . ';
328		}
329		';
330
331		return $code;
332		}
333
334		/**
335		* Will substitute all function headers (we know about) with function headers indicating an original implementation by appending
336		* a specific suffix
337		*
338		* @param string $bucketData Payload of the currently filtered bucket
339		* @param \AppserverIo\Doppelgaenger\Interfaces\StructureDefinitionInterface $structureDefinition The original path we have to place as our constants
340		*
341		* @return boolean
342		*
343		* @throws GeneratorException
344		*/
345		protected function substituteFunctionHeaders(& $bucketData, StructureDefinitionInterface $structureDefinition)
346		{
347		// is there event anything to substitute?
348		if ($structureDefinition->getFunctionDefinitions()->count() <= 0) {
349		return true;
350		}
351
352		// first of all we have to collect all functions we have to substitute
353		$functionSubstitutes = array();
354		$functionPatterns = array();
355		foreach ($structureDefinition->getFunctionDefinitions() as $functionDefinition) {
		0 ignored issues – show Bug introduced 2016-12-02 23:50 UTC by Report Bug Copy Issue Report The expression `$structureDefinition->getFunctionDefinitions()` of type `null\|object<AppserverIo\...FunctionDefinitionList>` is not guaranteed to be traversable. How about adding an additional type check? There are different options of fixing this problem. If you want to be on the safe side, you can add an additional type-check: $collection = json_decode($data, true); if ( ! is_array($collection)) { throw new \RuntimeException('$collection must be an array.'); } foreach ($collection as $item) { /** ... / } If you are sure that the expression is traversable, you might want to add a doc comment cast* to improve IDE auto-completion and static analysis: /** @var array $collection / $collection = json_decode($data, true); foreach ($collection as $item) { /* .. / } Mark the issue as a false-positive*: Just hover the remove button, in the top-right corner of this issue for more options. Loading history...
356		// we do not have to act on abstract methods
357		if ($functionDefinition->isAbstract()) {
358		continue;
359		}
360
361		$functionPatterns[] = '/function\s+' . $functionDefinition->getName() . '\s*\(/';
362		$functionSubstitutes[] = 'function ' . $functionDefinition->getName() . ReservedKeywords::ORIGINAL_FUNCTION_SUFFIX . '(';
363		}
364
365		// do the actual replacing and propagate the result in success
366		$replacementCounter = 0;
367		$result = preg_replace($functionPatterns, $functionSubstitutes, $bucketData, -1, $replacementCounter);
368
369		// if we have more (or less) things to substitute than substitutes, something has gone wrong
370		if ($replacementCounter !== count($functionPatterns)) {
371		throw new GeneratorException(
372		sprintf(
373		'Failed to substitute original function headers for "%s": Mismatching count of found and substituted function headers. Expected %s, got %s',
374		$structureDefinition->getQualifiedName(),
375		count($functionPatterns),
376		$replacementCounter
377		)
378		);
379		}
380
381		if (!is_null($result)) {
382		$bucketData = $result;
383		return true;
384		}
385
386		// still here? That seems to be wrong
387		return false;
388		}
389
390		/**
391		* Will substitute all magic __DIR__ and __FILE__ constants with our prepared substitutes to
392		* emulate original original filesystem context when in cache folder.
393		*
394		* @param string $bucketData Payload of the currently filtered bucket
395		* @param string $file The original path we have to place as our constants
396		*
397		* @return boolean
398		*/
399		protected function substituteLocationConstants(& $bucketData, $file)
400		{
401		$dir = dirname($file);
402		// Inject the code
403		$bucketData = str_replace(
404		array('__DIR__', '__FILE__'),
405		array('\'' . $dir . '\'', '\'' . $file . '\''),
406		$bucketData
407		);
408
409		// Still here? Success then
410		return true;
411		}
412
413		/**
414		* Will inject a placeholder that is used to store metadata about the original file
415		*
416		* @param string $bucketData Payload of the currently filtered bucket
417		* @param string $file The original file path we have to inject
418		*
419		* @return boolean
420		*/
421		protected function injectOriginalPathHint(& $bucketData, $file)
422		{
423		// Do need to do this?
424		if (strpos($bucketData, '<?php') === false) {
425		return false;
426		}
427
428		// Build up the needed code for our hint
429		$code = ' ' . Placeholders::PLACEHOLDER_OPEN . Placeholders::ORIGINAL_PATH_HINT . $file . '#' .
430		filemtime(
431		$file
432		) . Placeholders::ORIGINAL_PATH_HINT . Placeholders::PLACEHOLDER_CLOSE;
433
434		// Inject the code
435		$index = strpos($bucketData, '<?php');
436		$bucketData = substr_replace($bucketData, $code, $index + 5, 0);
437
438		// Still here? Success then.
439		return true;
440		}
441		}
442

appserver-io / doppelgaenger

Push — master ( 75665e...742229 )

SkeletonFilter::substituteFunctionHeaders() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like