Node::isWritable() - Code Metrics - Inspection of "Small Scrutinizer offence fixes" - ama-team/php-tree-access - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — feature/cleanup ( f97f45 )

by Fike

created 2018-01-11 09:40 UTC

Node::isWritable() A

↳ Parent: Node

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	4
ccs	2
cts	2
cp	1
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	0
crap	1

<?php

namespace AmaTeam\TreeAccess;

use AmaTeam\TreeAccess\API\NodeInterface;

class Node implements NodeInterface
{
    /**
     * @var string[]
     */
    private $path;
    /**
     * @var mixed
     */
    private $value;
    /**
     * @var bool
     */
    private $readable;
    /**
     * @var bool
     */
    private $writable;

    /**
     * @param string[] $path
     * @param mixed $value
     * @param bool $readable
     * @param bool $writable
     *
     * @SuppressWarnings(PHPMD.BooleanArgumentFlag)
     */
    public function __construct(
        array $path,
        &$value,
        $readable = true,
        $writable = true
    ) {
        $this->path = $path;
        $this->value = &$value;
        $this->readable = $readable;
        $this->writable = $writable;
    }

    /**
     * @return string[]
     */
    public function getPath()
    {
        return $this->path;
    }

    /**
     * @inheritDoc
     */
    public function getKey()
    {
        return empty($this->path) ? null : $this->path[sizeof($this->path) - 1];
    }

    /**
     * @return mixed
     */
    public function &getValue()
    {
        return $this->value;
    }

    /**
     * @return bool
     */
    public function isReadable()
    {
        return $this->readable;
    }

    /**
     * @return bool
     */
    public function isWritable()
    {
        return $this->writable;
    }

    /**
     * @param NodeInterface $node
     * @param string[] $path
     * @return Node
     */
    public static function withPath(NodeInterface $node, array $path)
    {
        return new Node(
            $path,
            $node->getValue(),
            $node->isReadable(),
            $node->isWritable()
        );
    }
}


1		<?php
2
3		namespace AmaTeam\TreeAccess;
4
5		use AmaTeam\TreeAccess\API\NodeInterface;
6
7		class Node implements NodeInterface
8		{
9		/**
10		* @var string[]
11		*/
12		private $path;
13		/**
14		* @var mixed
15		*/
16		private $value;
17		/**
18		* @var bool
19		*/
20		private $readable;
21		/**
22		* @var bool
23		*/
24		private $writable;
25
26		/**
27		* @param string[] $path
28		* @param mixed $value
29		* @param bool $readable
30		* @param bool $writable
31		*
32		* @SuppressWarnings(PHPMD.BooleanArgumentFlag)
33		*/
34	30	public function __construct(
35		array $path,
36		&$value,
37		$readable = true,
38		$writable = true
39		) {
40	30	$this->path = $path;
41	30	$this->value = &$value;
42	30	$this->readable = $readable;
43	30	$this->writable = $writable;
44	30	}
45
46		/**
47		* @return string[]
48		*/
49	13	public function getPath()
50		{
51	13	return $this->path;
52		}
53
54		/**
55		* @inheritDoc
56		*/
57	1	public function getKey()
58		{
59	1	return empty($this->path) ? null : $this->path[sizeof($this->path) - 1];
60		}
61
62		/**
63		* @return mixed
64		*/
65	30	public function &getValue()
66		{
67	30	return $this->value;
68		}
69
70		/**
71		* @return bool
72		*/
73	23	public function isReadable()
74		{
75	23	return $this->readable;
76		}
77
78		/**
79		* @return bool
80		*/
81	23	public function isWritable()
82		{
83	23	return $this->writable;
84		}
85
86		/**
87		* @param NodeInterface $node
88		* @param string[] $path
89		* @return Node
90		*/
91	13	public static function withPath(NodeInterface $node, array $path)
92		{
93	13	return new Node(
94	13	$path,
95	13	$node->getValue(),
96	13	$node->isReadable(),
97	13	$node->isWritable()
98		);
99		}
100		}
101

ama-team / php-tree-access

Push — feature/cleanup ( f97f45 )

Node::isWritable() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like