BitWasp\Bitcoin\Script\Path\ScriptBranch

Complexity

Total Complexity

15

Size/Duplication

Total Lines	120
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

45.71%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	getFullScript()	0	4	1
A	getPath()	0	4	1
A	getSegments()	0	4	1
A	getOps()	0	8	2
A	getNeuteredScript()	0	4	1
A	getScript()	0	6	1
A	__debugInfo()	0	17	4
A	getSignSteps()	0	11	3

<?php

namespace BitWasp\Bitcoin\Script\Path;

use BitWasp\Bitcoin\Script\Parser\Operation;
use BitWasp\Bitcoin\Script\ScriptFactory;
use BitWasp\Bitcoin\Script\ScriptInterface;

class ScriptBranch
{
    /**
     * @var ScriptInterface
     */
    private $fullScript;

    /**
     * @var array|\array[]
     */
    private $segments;

    /**
     * @var array|\bool[]
     */
    private $branch;

    /**
     * ScriptBranch constructor.
     * @param ScriptInterface $fullScript
     * @param array $logicalPath
     * @param PathTrace $segments
     */
    public function __construct(ScriptInterface $fullScript, array $logicalPath, PathTrace $segments)
    {
        $this->fullScript = $fullScript;
        $this->branch = $logicalPath;
        $this->segments = $segments;

It seems like $segments of type object<BitWasp\Bitcoin\Script\Path\PathTrace> is incompatible with the declared type array of property $segments.

    }

    /**
     * @return ScriptInterface
     */
    public function getFullScript()
    {
        return $this->fullScript;
    }

    /**
     * @return array|\bool[]
     */
    public function getPath()
    {
        return $this->branch;
    }

    /**
     * @return array|\array[]|PathTrace
     */
    public function getSegments()
    {
        return $this->segments;
    }

    /**
     * @return array
     */
    public function getOps()
    {
        $sequence = [];
        foreach ($this->segments as $segment) {
            $sequence = array_merge($sequence, $segment->all());
        }
        return $sequence;
    }

    /**
     * @return ScriptInterface
     */
    public function getNeuteredScript()
    {
        return ScriptFactory::fromOperations($this->getOps());
    }

    /**
     * @return ScriptInterface
     */
    public function getScript()
    {
        return ScriptFactory::fromOperations(array_filter($this->getOps(), function (Operation $operation) {
            return !$operation->isLogical();
        }));
    }

    /**
     * @return array
     */
    public function __debugInfo()
    {
        $m = [];
        foreach ($this->segments as $segment) {
            $m[] = ScriptFactory::fromOperations($segment->all());
        }

        $path = [];
        foreach ($this->branch as $flag) {
            $path[] = $flag ? 'true' : 'false';
        }

        return [
            'branch' => implode(", ", $path),
            'segments' => $m,
        ];
    }

    /**
     * @return OperationContainer[]
     */
    public function getSignSteps()
    {
        $steps = [];
        foreach ($this->segments as $segment) {
            if (!$segment->isLoneLogicalOp()) {
                $steps[] = $segment;
            }
        }

        return $steps;
    }
}