Ciandt\Behat\PlaceholdersExtension\Tester\PlaceholdersReplacer

Complexity

Total Complexity

16

Size/Duplication

Total Lines	147
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	setUp()	0	15	3
A	test()	0	10	2
A	reconstructStep()	0	13	1
A	replacePlaceholders()	0	10	2
A	getReplacement()	0	14	1
B	recursivePlaceholderSearch()	0	14	5
A	tearDown()	0	4	1

<?php
namespace Ciandt\Behat\PlaceholdersExtension\Tester;

use Ciandt\Behat\PlaceholdersExtension\Config\PlaceholdersRepository;
use Behat\Behat\Tester\Result\StepResult;
use Behat\Behat\Tester\StepTester;
use Behat\Gherkin\Node\FeatureNode;
use Behat\Gherkin\Node\StepNode;
use Behat\Testwork\Environment\Environment;
use Behat\Testwork\Tester\Setup\SuccessfulSetup;
use Behat\Testwork\Tester\Setup\SuccessfulTeardown;
use Behat\Behat\Tester\ServiceContainer\TesterExtension;

/**
 * Tester executing step tests in the runtime.
 *
 */
class PlaceholdersReplacer implements StepTester
{

    /**
     * @var StepTester
     */
    private $baseTester;

    /**
     * @var array
     */
    private $variantTags;

    /**
     * @var array
     */
    private $variant;

    /**
     * @var array
     */
    private $placeholdersRepository;

    /**
     * @var array
     */
    private $placeholders = false;

    /**
     * @var string
     */
    private $configPath;

    /**
     * @var string
     */
    private $configSection;

    /**
     * @var string
     */
    private $environment;

    public function __construct(StepTester $baseTester, $variantTags, PlaceholdersRepository $placeholdersRepository)
    {
        $this->baseTester = $baseTester;
        $this->placeholdersRepository = $placeholdersRepository;

It seems like $placeholdersRepository of type object<Ciandt\Behat\PlaceholdersExtension\Config\PlaceholdersRepository> is incompatible with the declared type array of property $placeholdersRepository.

        $this->variantTags = $variantTags;
    }

    /**
     * {@inheritdoc}
     * @todo use the tag to get correct section, not always the default one
     */
    public function setUp(Environment $env, FeatureNode $feature, StepNode $step, $skip)
    {
        $this->environment = $this->placeholdersRepository->getEnvironment();

The method getEnvironment cannot be called on $this->placeholdersRepository (of type array).

        if ($this->placeholdersRepository->hasTag($step->configTag)) {

The method hasTag cannot be called on $this->placeholdersRepository (of type array).

            $this->configSection = 'default';
            $this->placeholders = $this->placeholdersRepository->

The method getConfigSection cannot be called on $this->placeholdersRepository (of type array).

                getConfigSection($step->configTag, $this->configSection)['placeholders'];

The property configTag does not seem to exist in Behat\Gherkin\Node\StepNode.

            $this->configPath = $this->placeholdersRepository->getFilePath($step->configTag);

The method getFilePath cannot be called on $this->placeholdersRepository (of type array).

            if ($step->variant) {
                $this->variant = $step->variant;

The property variant does not seem to exist in Behat\Gherkin\Node\StepNode.

            }
        }

        return new SuccessfulSetup();
    }

    /**
     * {@inheritdoc}
     */
    public function test(Environment $env, FeatureNode $feature, StepNode $step, $skip = false)
    {
        $tester = $this->baseTester;
        if ($this->placeholders) {

The expression $this->placeholders of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            $result = $tester->test($env, $feature, $this->reconstructStep($step), $skip);
            return $result;
        } else {
            return $tester->test($env, $feature, $step, $skip);
        }
    }

    private function reconstructStep(StepNode $step)
    {
        //@todo replace placeholders on arguments (tablenode)
        $arguments = $step->getArguments();
        $text = $this->replacePlaceholders($step->getText(), $step->variant, $this->environment);

The property variant does not seem to exist in Behat\Gherkin\Node\StepNode.

        return new StepNode(
            $step->getKeyword(),
            $text,
            $arguments,
            $step->getLine(),
            $step->getKeywordType()
        );
    }

    private function replacePlaceholders($string, $var, $env)

The parameter $var is not used and could be removed.

The parameter $env is not used and could be removed.

    {
        preg_match_all('/\${(?P<key>[^}]+)}/i', $string, $placeholders, PREG_SET_ORDER);
        foreach ($placeholders as $placeholder) {

The expression $placeholders of type null|array<integer,array<integer,string>> is not guaranteed to be traversable. How about adding an additional type check?

            $key = $placeholder['key'];
            $value = $this->getReplacement($key);
            $string = str_replace('${' . $key . '}', $value, $string);
        }
        return $string;
    }

    private function getReplacement($placeholderKey)
    {

        $values = $this->placeholders;
        $configPath = $this->configPath;
        $section = $this->configSection;
        $variant = $this->variant;
        $environment = $this->environment;

        $keys = array('$' . $variant, '$' . $environment, $placeholderKey);
        $treePosition = "$configPath>$section>placeholders";

        return $this->recursivePlaceholderSearch($keys, $values, $treePosition);
    }

    private function recursivePlaceholderSearch($keys, $values, $treePosition)
    {
        if (empty($keys) || !is_array($values)) {
            return $values;
        }
        $key = array_pop($keys);
        if (key_exists($key, $values)) {
            return $this->recursivePlaceholderSearch($keys, $values[$key], "$treePosition>$key");
        } elseif (key_exists('$default', $values)) {
            return $this->recursivePlaceholderSearch($keys, $values['$default'], $treePosition . '>$default');
        } else {
            throw new \Exception("no placeholder is defined on $treePosition>$key");
        }
    }

    /**
     * {@inheritdoc}
     */
    public function tearDown(Environment $env, FeatureNode $feature, StepNode $step, $skip, StepResult $result)
    {
        return new SuccessfulTeardown();
    }
}