Ciandt\Behat\PlaceholdersExtension\Transformation\RuntimePlaceholdersTransformation

Complexity

Total Complexity

13

Size/Duplication

Total Lines	51
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	3

Importance

Changes	1
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__toString()	0	3	1
A	getPattern()	0	3	1
A	replaceStringPlaceholders()	0	9	2
A	replaceTablePlaceholders()	0	3	1
A	supportsDefinitionAndArgument()	0	9	4
A	tableHasPlaceholders()	0	3	1
A	transformArgument()	0	9	3

<?php


namespace Ciandt\Behat\PlaceholdersExtension\Transformation;

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

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

    const USER_DEFINED_PLACEHOLDER_REGEX = '/\${(?P<placeholder>[a-zA-Z0-9_-]+)}/';

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

    public function getPattern() {
        return self::USER_DEFINED_PLACEHOLDER_REGEX;
    }

    private static function replaceStringPlaceholders($string, PlaceholdersRepository $repository, $tags) {
        preg_match_all(self::USER_DEFINED_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, $tags);
            $string = str_replace('${' . $placeholder . '}', $replacement, $string);
        }
        return $string;
    }

    private static function replaceTablePlaceholders(TableNode $table, PlaceholdersRepository $repository, PlaceholderContainerStepNode $container) {

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

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

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

        //@todo
    }

    public static function supportsDefinitionAndArgument($tags, $argumentValue) {
            if (is_string($argumentValue) && preg_match(self::USER_DEFINED_PLACEHOLDER_REGEX, $argumentValue) === 1) {
                return true;
            }
            if ($argumentValue instanceof TableNode) {
                return false;
            }
        return false;
    }

    private static function tableHasPlaceholders(TableNode $table) {

This method is not used, and could be removed.

        return (preg_match(self::USER_DEFINED_PLACEHOLDER_REGEX, $table->getTableAsString()) === 1);
    }

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

        if ($argumentValue instanceof TableNode) {
            return self::replaceTablePlaceholders($table, $repository, $tags);

The variable $table does not exist. Did you forget to declare it?

        }
    }

}