Ciandt\Behat\PlaceholdersExtension\Transformation\RuntimePlaceholdersTransformation

Complexity

Total Complexity

17

Size/Duplication

Total Lines	64
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	4

Importance

Changes	1
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__toString()	0	3	1
A	getPattern()	0	3	1
A	replaceStringPlaceholders()	0	9	2
B	transformArgument()	0	19	5
A	replaceTablePlaceholders()	0	3	1
B	supportsArgument()	0	18	7

<?php


namespace Ciandt\Behat\PlaceholdersExtension\Transformation;

use Behat\Behat\Definition\Call\DefinitionCall;
use Behat\Gherkin\Node\PyStringNode;
use Behat\Gherkin\Node\TableNode;
use Behat\Testwork\Call\RuntimeCallee;
use Ciandt\Behat\PlaceholdersExtension\Config\PlaceholdersRepository;

/**
 *
 */
 class RuntimePlaceholdersTransformation extends RuntimeCallee implements PlaceholdersTransformation {

    public function __toString() {
        return 'UserDefinedPlaceholderTransform';
    }

    public function getPattern() {
        return PlaceholdersRepository::PLACEHOLDER_REGEX;
    }

    protected static function replaceStringPlaceholders(&$string, PlaceholdersRepository $repository) {
        preg_match_all(PlaceholdersRepository::PLACEHOLDER_REGEX, $string, $matches, PREG_SET_ORDER);
        foreach ($matches as $match) {

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

            $placeholder = $match['placeholder'];
            $replacement = $repository->getReplacement($placeholder);
            $string = str_replace('${' . $placeholder . '}', $replacement, $string);
        }
        return $string;
    }

    public static function transformArgument($argument, $repository) {
        if (is_string($argument)) {
            return self::replaceStringPlaceholders($argument, $repository);
        }

        if ($argument instanceof PyStringNode) {
            $strings = $argument->getStrings();
            foreach ($strings as &$string){
                self::replaceStringPlaceholders($string, $repository);
            }
            return new PyStringNode($strings, $argument->getLine());
        }
        
        if ($argument instanceof TableNode) {
            $table = $argument->getTable();
            array_walk_recursive($table, 'self::replaceTablePlaceholders', $repository);
            return new TableNode($table);
        }
    }
    
    private static function replaceTablePlaceholders(&$item, $key, $repository){

This method is not used, and could be removed.

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

        $item = self::replaceStringPlaceholders($item, $repository);
    }
    

    public static function supportsArgument($argument)
    {
        if (is_string($argument) && preg_match(PlaceholdersRepository::PLACEHOLDER_REGEX, $argument) === 1) {
            return true;
        }

        if ($argument instanceof PyStringNode &&
            preg_match(PlaceholdersRepository::PLACEHOLDER_REGEX, $argument->getRaw()) === 1) {
            return true;
        }
        
        if ($argument instanceof TableNode &&
            preg_match(PlaceholdersRepository::PLACEHOLDER_REGEX, $argument->getTableAsString()) === 1) {
            return true;
        }
        
        return false;
    }
}