hanneskod\readmetester\Gherkish\FeatureContext

Complexity

Total Complexity

16

Size/Duplication

Total Lines	117
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__destruct()	0	4	2
A	on()	0	11	2
A	__call()	0	9	2
A	teardown()	0	11	2
A	getScenario()	0	3	1
A	setup()	0	11	2
A	__get()	0	7	2
A	do()	0	9	2
A	__set()	0	3	1

<?php

/**
 * The Gherkish subpackage contains experimental support classes to implement
 * feature testing with a Gherkin inspired syntax.
 *
 * WARNING Classes in these package are not covered by semver and may change
 * without notice.
 *
 * See features/ for example usage
 */

declare(strict_types=1);

namespace hanneskod\readmetester\Gherkish;

final class FeatureContext
{
    /** @var array<string, \Closure> */
    private array $steps = [];

    /** @var array<string, mixed> */
    private array $properties = [];

    private \Closure $onTeardown;

    /**
     * Register closure to be called before step registration
     */
    public function setup(\Closure $setup): self
    {
        $setup = $setup->bindTo($this);

        if (!$setup) {

$setup is of type Closure, thus it always evaluated to true.

            throw new \LogicException('Unable to register setup');
        }

        $setup();

        return $this;
    }

    /**
     * Register closure to be called after scenario execution
     */
    public function teardown(\Closure $teardown): self
    {
        $teardown = $teardown->bindTo($this);

        if (!$teardown) {

$teardown is of type Closure, thus it always evaluated to true.

            throw new \LogicException('Unable to register teardown');
        }

        $this->onTeardown = $teardown;

        return $this;
    }

    /**
     * Register step
     */
    public function on(string $name, \Closure $step): self
    {
        $step = $step->bindTo($this);

        if (!$step) {

$step is of type Closure, thus it always evaluated to true.

            throw new \LogicException('Unable to register step');
        }

        $this->steps[strtolower($name)] = $step;

        return $this;
    }

    /**
     * Register step using method overloading
     *
     * @param array<mixed> $arguments
     */
    public function __call(string $name, array $arguments): self
    {
        $step = $arguments[0] ?? null;

        if (!$step instanceof \Closure) {
            throw new \LogicException('Step must be registered with a closure');
        }

        return $this->on($name, $step);
    }

    /**
     * Execute step
     *
     * @param array<mixed> $arguments
     */
    public function do(string $name, array $arguments): void
    {
        $name = strtolower($name);

        if (!isset($this->steps[$name])) {
            throw new \Exception("No step $name");
        }

        ($this->steps[$name])(...$arguments);
    }

    public function __destruct()
    {
        if (isset($this->onTeardown)) {
            ($this->onTeardown)();
        }
    }

    public function __set(string $name, mixed $value): void

The type hanneskod\readmetester\Gherkish\mixed was not found. Maybe you did not declare it correctly or list all dependencies?

    {
        $this->properties[$name] = $value;
    }

    public function &__get(string $name): mixed
    {
        if (!isset($this->properties[$name])) {
            throw new \Exception("no propery $name");
        }

        return $this->properties[$name];
    }

    /**
     * Get scenario for configuration
     */
    public function getScenario(): Scenario
    {
        return new Scenario($this);
    }
}