Response - Code Metrics - mschindler83/fints-hbci-php - Measure and Improve Code Quality continuously with Scrutinizer

Response B
last analyzed 2018-06-28 21:25 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	364
Duplicated Lines	2.75 %

Coupling/Cohesion

Components	2
Dependencies	2

Test Coverage

Coverage

10.27%

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
wmc	50
lcom	2
cbo	2
dl	10
loc	364
ccs	15
cts	146
cp	0.1027
rs	8.4
c	2
b	0
f	0

21 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	2
A	getDialogId()	0	10	2
A	getBankName()	0	13	3
A	getTouchDowns()	0	23	5
A	getSupportedTanMechanisms()	0	19	5
A	getHksalMaxVersion()	0	4	1
A	getHkkazMaxVersion()	0	4	1
A	isSuccess()	0	12	3
A	getMessageSummary()	0	4	1
A	getSegmentSummary()	0	4	1
A	getSummaryBySegment()	0	17	3
A	getSegmentMaxVersion()	0	15	3
A	getSystemId()	0	10	2
A	humanReadable()	10	10	2
A	findSegmentForReference()	0	14	3
A	findSegment()	0	4	1
A	findSegments()	0	17	5
A	splitSegment()	0	10	2
A	splitDeg()	0	4	1
A	getSegmentIndex()	0	9	2
A	unwrapEncryptedMsg()	0	8	2

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Response often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Response, and based on these observations, apply Extract Interface, too.

<?php

namespace Fhp\Response;

use Fhp\Message\AbstractMessage;
use Fhp\Segment\AbstractSegment;
use Fhp\Segment\NameMapping;

/**
 * Class Response
 *
 * @package Fhp\Response
 */
class Response
{
    /** @var string */
    public $rawResponse;

    /** @var string */
    protected $response;

    /** @var array */
    protected $segments = array();

    /** @var string */
    protected $dialogId;

    /** @var string */
    protected $systemId;

    /**
     * Response constructor.
     *
     * @param string $rawResponse
     */
    public function __construct($rawResponse)
    {
        if ($rawResponse instanceof Initialization) {
            $rawResponse = $rawResponse->rawResponse;
        }

        $this->rawResponse = $rawResponse;
        $this->response = $this->unwrapEncryptedMsg($rawResponse);
        $this->segments = preg_split("#'(?=[A-Z]{4,}:\d|')#", $rawResponse);
    }

    /**
     * Extracts dialog ID from response.
     *
     * @return string|null
     * @throws \Exception
     */
    public function getDialogId()
    {
        $segment = $this->findSegment('HNHBK');

        if (null === $segment) {
            throw new \Exception('Could not find element HNHBK. Invalid response?');
        }

        return $this->getSegmentIndex(4, $segment);
    }

    /**
     * Extracts bank name from response.
     *
     * @return string|null
     */
    public function getBankName()
    {
        $bankName = null;
        $segment = $this->findSegment('HIBPA');
        if (null != $segment) {

            $split = $this->splitSegment($segment);
            if (isset($split[3])) {
                $bankName = $split[3];
            }
        }

        return $bankName;
    }

    /**
     * Some kind of HBCI pagination.
     *
     * @param AbstractMessage $message
     *
     * @return array
     */
    public function getTouchDowns(AbstractMessage $message)
    {
        $touchdown = array();
        $messageSegments = $message->getEncryptedSegments();
abstract class User
{
    /** @return string */
    abstract public function getPassword();
}

class MyUser extends User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
        /** @var AbstractSegment $msgSeg */
        foreach ($messageSegments as $msgSeg) {
            $segment = $this->findSegmentForReference('HIRMS', $msgSeg);
            if (null != $segment) {

                $parts = $this->splitSegment($segment);
                // remove header
                array_shift($parts);
                foreach ($parts as $p) {
                    $pSplit = $this->splitDeg($p);
                    if ($pSplit[0] == 3040) {
                        $td = $pSplit[3];
                        $touchdown[$msgSeg->getName()] = $td;
                    }
                }
            }
        }

        return $touchdown;
    }

    /**
     * Extracts supported TAN mechanisms from response.
     *
     * @return array
     */
    public function getSupportedTanMechanisms()
    {
        $segments = $this->findSegments('HIRMS');
        // @todo create method to get reference element from request
        foreach ($segments as $segment) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
            $segment = $this->splitSegment($segment);
            array_shift($segment);
            foreach ($segment as $seg) {
                list($id, $msg) = explode('::', $seg, 2);
                if ("3920" == $id) {
                    if (preg_match_all('/\d{3}/', $msg, $matches)) {
                        return $matches[0];
                    }
                }
            }
        }

        return array();
    }

    /**
     * @return int
     */
    public function getHksalMaxVersion()
    {
        return $this->getSegmentMaxVersion('HISALS');
    }

    /**
     * @return int
     */
    public function getHkkazMaxVersion()
    {
        return $this->getSegmentMaxVersion('HIKAZS');
    }

    /**
     * Checks if request / response was successful.
     *
     * @return bool
     */
    public function isSuccess()
    {
        $summary = $this->getMessageSummary();

        foreach ($summary as $code => $message) {
            if ("9" == substr($code, 0, 1)) {
                return false;
            }
        }

        return true;
    }

    /**
     * @return array
     * @throws \Exception
     */
    public function getMessageSummary()
    {
        return $this->getSummaryBySegment('HIRMG');
    }

    /**
     * @return array
     * @throws \Exception
     */
    public function getSegmentSummary()
    {
        return $this->getSummaryBySegment('HIRMS');
    }

    /**
     * @param string $name
     *
     * @return array
     * @throws \Exception
     */
    protected function getSummaryBySegment($name)
    {
        if (!in_array($name, array('HIRMS', 'HIRMG'))) {
            throw new \Exception('Invalid segment for message summary. Only HIRMS and HIRMG supported');
        }

        $result = array();
        $segment = $this->findSegment($name);
        $segment = $this->splitSegment($segment);
        array_shift($segment);
        foreach ($segment as $de) {
            $de = $this->splitDeg($de);
            $result[$de[0]] = $de[2];
        }

        return $result;
    }

    /**
     * @param string $segmentName
     *
     * @return int
     */
    public function getSegmentMaxVersion($segmentName)
    {
        $version = 3;
        $segments = $this->findSegments($segmentName);
        foreach ($segments as $s) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
            $parts = $this->splitSegment($s);
            $segmentHeader = $this->splitDeg($parts[0]);
            $curVersion = (int) $segmentHeader[2];
            if ($curVersion > $version) {
                $version = $curVersion;
            }
        }

        return $version;
    }

    /**
     * @return string
     * @throws \Exception
     */
    public function getSystemId()
    {
        $segment = $this->findSegment('HISYN');

        if (!preg_match('/HISYN:\d+:\d+:\d+\+(.+)/', $segment, $matches)) {
            throw new \Exception('Could not determine system id.');
        }

        return $matches[1];
    }

    /**
     * @param bool $translateCodes
     *
     * @return string
     */
    public function humanReadable($translateCodes = false)

    {
        return str_replace(
            array("'", '+'),
            array(PHP_EOL, PHP_EOL . "  "),
            $translateCodes
                ? NameMapping::translateResponse($this->rawResponse)
                : $this->rawResponse
        );
    }

    /**
     * @param string          $name
     * @param AbstractSegment $reference
     *
     * @return string|null
     */
    protected function findSegmentForReference($name, AbstractSegment $reference)
    {
        $segments = $this->findSegments($name);
        foreach ($segments as $seg) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
            $segSplit = $this->splitSegment($seg);
            $segSplit = array_shift($segSplit);
            $segSplit = $this->splitDeg($segSplit);
            if ($segSplit[3] == $reference->getSegmentNumber()) {
                return $seg;
            }
        }

        return null;
    }

    /**
     * @param string $name
     *
     * @return string|null
     */
    protected function findSegment($name)
    {
        return $this->findSegments($name, true);
    }

    /**
     * @param string $name
     * @param bool   $one
     *
     * @return array|null|string
     */
    protected function findSegments($name, $one = false)
    {
        $found = $one ? null : array();

        foreach ($this->segments as $segment) {
            $split = explode(':', $segment, 2);

            if ($split[0] == $name) {
                if ($one) {
                    return $segment;
                }
                $found[] = $segment;
            }
        }

        return $found;
    }

    /**
     * @param $segment
     *
     * @return array
     */
    protected function splitSegment($segment)
    {
        $parts = preg_split('/\+(?<!\?\+)/', $segment);

        foreach ($parts as &$part) {
            $part = str_replace('?+', '+', $part);
        }

        return $parts;
    }

    /**
     * @param $deg
     *
     * @return array
     */
    protected function splitDeg($deg)
    {
        return explode(':', $deg);
    }

    /**
     * @param int $idx
     * @param     $segment
     *
     * @return string|null
     */
    protected function getSegmentIndex($idx, $segment)
    {
        $segment = $this->splitSegment($segment);
        if (isset($segment[$idx - 1])) {
            return $segment[$idx - 1];
        }

        return null;
    }

    /**
     * @param string $response
     *
     * @return string
     */
    protected function unwrapEncryptedMsg($response)
    {
        if (preg_match('/HNVSD:\d+:\d+\+@\d+@(.+)\'\'/', $response, $matches)) {
            return $matches[1];
        }

        return $response;
    }
}


1			<?php
2
3			namespace Fhp\Response;
4
5			use Fhp\Message\AbstractMessage;
6			use Fhp\Segment\AbstractSegment;
7			use Fhp\Segment\NameMapping;
8
9			/**
10			* Class Response
11			*
12			* @package Fhp\Response
13			*/
14			class Response
15			{
16			/** @var string */
17			public $rawResponse;
18
19			/** @var string */
20			protected $response;
21
22			/** @var array */
23			protected $segments = array();
24
25			/** @var string */
26			protected $dialogId;
27
28			/** @var string */
29			protected $systemId;
30
31			/**
32			* Response constructor.
33			*
34			* @param string $rawResponse
35			*/
36	1		public function __construct($rawResponse)
37			{
38	1		if ($rawResponse instanceof Initialization) {
39			$rawResponse = $rawResponse->rawResponse;
40			}
41
42	1		$this->rawResponse = $rawResponse;
43	1		$this->response = $this->unwrapEncryptedMsg($rawResponse);
44	1		$this->segments = preg_split("#'(?=[A-Z]{4,}:\d\|')#", $rawResponse);
45	1		}
46
47			/**
48			* Extracts dialog ID from response.
49			*
50			* @return string\|null
51			* @throws \Exception
52			*/
53			public function getDialogId()
54			{
55			$segment = $this->findSegment('HNHBK');
56
57			if (null === $segment) {
58			throw new \Exception('Could not find element HNHBK. Invalid response?');
59			}
60
61			return $this->getSegmentIndex(4, $segment);
62			}
63
64			/**
65			* Extracts bank name from response.
66			*
67			* @return string\|null
68			*/
69			public function getBankName()
70			{
71			$bankName = null;
72			$segment = $this->findSegment('HIBPA');
73			if (null != $segment) {
			0 ignored issues – show Bug introduced 2016-09-05 20:43 UTC by Report Bug Copy Issue Report It seems like you are loosely comparing `$segment` of type `array\|null\|string` against `null`; this is ambiguous if the string can be empty. Consider using a strict comparison `!==` instead. Loading history...
74			$split = $this->splitSegment($segment);
75			if (isset($split[3])) {
76			$bankName = $split[3];
77			}
78			}
79
80			return $bankName;
81			}
82
83			/**
84			* Some kind of HBCI pagination.
85			*
86			* @param AbstractMessage $message
87			*
88			* @return array
89			*/
90			public function getTouchDowns(AbstractMessage $message)
91			{
92			$touchdown = array();
93			$messageSegments = $message->getEncryptedSegments();
			0 ignored issues – show Bug introduced 2016-09-05 20:43 UTC by Report Bug Copy Issue Report It seems like you code against a specific sub-type and not the parent class `Fhp\Message\AbstractMessage` as the method `getEncryptedSegments()` does only exist in the following sub-classes of `Fhp\Message\AbstractMessage`: `Fhp\Message\Message`. Maybe you want to `instanceof` check for one of these explicitly? Let’s take a look at an example: abstract class User { /** @return string / abstract public function getPassword(); } class MyUser extends User { public function getPassword() { // return something } public function getDisplayName() { // return some name. } } class AuthSystem { public function authenticate(User $user) { $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName())); // do something. } } In the above example, the authenticate() method works fine as long as you just pass instances of MyUser. However, if you now also want to pass a different sub-classes of User which does not have a getDisplayName() method, the code will break. Available Fixes Change the type-hint for the parameter: class AuthSystem { public function authenticate(MyUser $user) { / ... / } } Add an additional type-check: class AuthSystem { public function authenticate(User $user) { if ($user instanceof MyUser) { $this->logger->info(/* ... /); } // or alternatively if ( ! $user instanceof MyUser) { throw new \LogicException( '$user must be an instance of MyUser, ' .'other instances are not supported.' ); } } } Note:* PHP Analyzer uses reverse abstract interpretation to narrow down the types inside the if block in such a case. Add the method to the parent class: abstract class User { /** @return string / abstract public function getPassword(); /* @return string */ abstract public function getDisplayName(); } Loading history...
94			/** @var AbstractSegment $msgSeg */
95			foreach ($messageSegments as $msgSeg) {
96			$segment = $this->findSegmentForReference('HIRMS', $msgSeg);
97			if (null != $segment) {
			0 ignored issues – show Bug introduced 2016-09-05 20:43 UTC by Report Bug Copy Issue Report It seems like you are loosely comparing `$segment` of type `string\|null` against `null`; this is ambiguous if the string can be empty. Consider using a strict comparison `!==` instead. Loading history...
98			$parts = $this->splitSegment($segment);
99			// remove header
100			array_shift($parts);
101			foreach ($parts as $p) {
102			$pSplit = $this->splitDeg($p);
103			if ($pSplit[0] == 3040) {
104			$td = $pSplit[3];
105			$touchdown[$msgSeg->getName()] = $td;
106			}
107			}
108			}
109			}
110
111			return $touchdown;
112			}
113
114			/**
115			* Extracts supported TAN mechanisms from response.
116			*
117			* @return array
118			*/
119			public function getSupportedTanMechanisms()
120			{
121			$segments = $this->findSegments('HIRMS');
122			// @todo create method to get reference element from request
123			foreach ($segments as $segment) {
			0 ignored issues – show Bug introduced 2016-09-05 20:43 UTC by Report Bug Copy Issue Report The expression `$segments` of type `array\|null\|string` is not guaranteed to be traversable. How about adding an additional type check? There are different options of fixing this problem. If you want to be on the safe side, you can add an additional type-check: $collection = json_decode($data, true); if ( ! is_array($collection)) { throw new \RuntimeException('$collection must be an array.'); } foreach ($collection as $item) { /** ... / } If you are sure that the expression is traversable, you might want to add a doc comment cast* to improve IDE auto-completion and static analysis: /** @var array $collection / $collection = json_decode($data, true); foreach ($collection as $item) { /* .. / } Mark the issue as a false-positive*: Just hover the remove button, in the top-right corner of this issue for more options. Loading history...
124			$segment = $this->splitSegment($segment);
125			array_shift($segment);
126			foreach ($segment as $seg) {
127			list($id, $msg) = explode('::', $seg, 2);
128			if ("3920" == $id) {
129			if (preg_match_all('/\d{3}/', $msg, $matches)) {
130			return $matches[0];
131			}
132			}
133			}
134			}
135
136			return array();
137			}
138
139			/**
140			* @return int
141			*/
142			public function getHksalMaxVersion()
143			{
144			return $this->getSegmentMaxVersion('HISALS');
145			}
146
147			/**
148			* @return int
149			*/
150			public function getHkkazMaxVersion()
151			{
152			return $this->getSegmentMaxVersion('HIKAZS');
153			}
154
155			/**
156			* Checks if request / response was successful.
157			*
158			* @return bool
159			*/
160			public function isSuccess()
161			{
162			$summary = $this->getMessageSummary();
163
164			foreach ($summary as $code => $message) {
165			if ("9" == substr($code, 0, 1)) {
166			return false;
167			}
168			}
169
170			return true;
171			}
172
173			/**
174			* @return array
175			* @throws \Exception
176			*/
177			public function getMessageSummary()
178			{
179			return $this->getSummaryBySegment('HIRMG');
180			}
181
182			/**
183			* @return array
184			* @throws \Exception
185			*/
186			public function getSegmentSummary()
187			{
188			return $this->getSummaryBySegment('HIRMS');
189			}
190
191			/**
192			* @param string $name
193			*
194			* @return array
195			* @throws \Exception
196			*/
197			protected function getSummaryBySegment($name)
198			{
199			if (!in_array($name, array('HIRMS', 'HIRMG'))) {
200			throw new \Exception('Invalid segment for message summary. Only HIRMS and HIRMG supported');
201			}
202
203			$result = array();
204			$segment = $this->findSegment($name);
205			$segment = $this->splitSegment($segment);
206			array_shift($segment);
207			foreach ($segment as $de) {
208			$de = $this->splitDeg($de);
209			$result[$de[0]] = $de[2];
210			}
211
212			return $result;
213			}
214
215			/**
216			* @param string $segmentName
217			*
218			* @return int
219			*/
220			public function getSegmentMaxVersion($segmentName)
221			{
222			$version = 3;
223			$segments = $this->findSegments($segmentName);
224			foreach ($segments as $s) {
			0 ignored issues – show Bug introduced 2016-09-05 20:43 UTC by Report Bug Copy Issue Report The expression `$segments` of type `array\|null\|string` is not guaranteed to be traversable. How about adding an additional type check? There are different options of fixing this problem. If you want to be on the safe side, you can add an additional type-check: $collection = json_decode($data, true); if ( ! is_array($collection)) { throw new \RuntimeException('$collection must be an array.'); } foreach ($collection as $item) { /** ... / } If you are sure that the expression is traversable, you might want to add a doc comment cast* to improve IDE auto-completion and static analysis: /** @var array $collection / $collection = json_decode($data, true); foreach ($collection as $item) { /* .. / } Mark the issue as a false-positive*: Just hover the remove button, in the top-right corner of this issue for more options. Loading history...
225			$parts = $this->splitSegment($s);
226			$segmentHeader = $this->splitDeg($parts[0]);
227			$curVersion = (int) $segmentHeader[2];
228			if ($curVersion > $version) {
229			$version = $curVersion;
230			}
231			}
232
233			return $version;
234			}
235
236			/**
237			* @return string
238			* @throws \Exception
239			*/
240			public function getSystemId()
241			{
242			$segment = $this->findSegment('HISYN');
243
244			if (!preg_match('/HISYN:\d+:\d+:\d+\+(.+)/', $segment, $matches)) {
245			throw new \Exception('Could not determine system id.');
246			}
247
248			return $matches[1];
249			}
250
251			/**
252			* @param bool $translateCodes
253			*
254			* @return string
255			*/
256		View Code Duplication	public function humanReadable($translateCodes = false)
			0 ignored issues – show Duplication introduced 2017-08-07 08:54 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
257			{
258			return str_replace(
259			array("'", '+'),
260			array(PHP_EOL, PHP_EOL . " "),
261			$translateCodes
262			? NameMapping::translateResponse($this->rawResponse)
263			: $this->rawResponse
264			);
265			}
266
267			/**
268			* @param string $name
269			* @param AbstractSegment $reference
270			*
271			* @return string\|null
272			*/
273			protected function findSegmentForReference($name, AbstractSegment $reference)
274			{
275			$segments = $this->findSegments($name);
276			foreach ($segments as $seg) {
			0 ignored issues – show Bug introduced 2016-09-05 20:43 UTC by Report Bug Copy Issue Report The expression `$segments` of type `array\|null\|string` is not guaranteed to be traversable. How about adding an additional type check? There are different options of fixing this problem. If you want to be on the safe side, you can add an additional type-check: $collection = json_decode($data, true); if ( ! is_array($collection)) { throw new \RuntimeException('$collection must be an array.'); } foreach ($collection as $item) { /** ... / } If you are sure that the expression is traversable, you might want to add a doc comment cast* to improve IDE auto-completion and static analysis: /** @var array $collection / $collection = json_decode($data, true); foreach ($collection as $item) { /* .. / } Mark the issue as a false-positive*: Just hover the remove button, in the top-right corner of this issue for more options. Loading history...
277			$segSplit = $this->splitSegment($seg);
278			$segSplit = array_shift($segSplit);
279			$segSplit = $this->splitDeg($segSplit);
280			if ($segSplit[3] == $reference->getSegmentNumber()) {
281			return $seg;
282			}
283			}
284
285			return null;
286			}
287
288			/**
289			* @param string $name
290			*
291			* @return string\|null
292			*/
293			protected function findSegment($name)
294			{
295			return $this->findSegments($name, true);
296			}
297
298			/**
299			* @param string $name
300			* @param bool $one
301			*
302			* @return array\|null\|string
303			*/
304			protected function findSegments($name, $one = false)
305			{
306			$found = $one ? null : array();
307
308			foreach ($this->segments as $segment) {
309			$split = explode(':', $segment, 2);
310
311			if ($split[0] == $name) {
312			if ($one) {
313			return $segment;
314			}
315			$found[] = $segment;
316			}
317			}
318
319			return $found;
320			}
321
322			/**
323			* @param $segment
324			*
325			* @return array
326			*/
327	1		protected function splitSegment($segment)
328			{
329	1		$parts = preg_split('/\+(?<!\?\+)/', $segment);
330
331	1		foreach ($parts as &$part) {
332	1		$part = str_replace('?+', '+', $part);
333	1		}
334
335	1		return $parts;
336			}
337
338			/**
339			* @param $deg
340			*
341			* @return array
342			*/
343			protected function splitDeg($deg)
344			{
345			return explode(':', $deg);
346			}
347
348			/**
349			* @param int $idx
350			* @param $segment
351			*
352			* @return string\|null
353			*/
354			protected function getSegmentIndex($idx, $segment)
355			{
356			$segment = $this->splitSegment($segment);
357			if (isset($segment[$idx - 1])) {
358			return $segment[$idx - 1];
359			}
360
361			return null;
362			}
363
364			/**
365			* @param string $response
366			*
367			* @return string
368			*/
369	1		protected function unwrapEncryptedMsg($response)
370			{
371	1		if (preg_match('/HNVSD:\d+:\d+\+@\d+@(.+)\'\'/', $response, $matches)) {
372			return $matches[1];
373			}
374
375	1		return $response;
376			}
377			}
378

mschindler83 / fints-hbci-php

Response B last analyzed 2018-06-28 21:25 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

21 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Duplication Side-by-Side

Filter issues like

Response B
last analyzed 2018-06-28 21:25 UTC