XMLReaderElement::__get() - Code Metrics - Inspection of "Refactored the get magic function to be less compl..." - andrewfenn/XMLReaderElement - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( f85170...1d219c )

by Andrew

created 2017-01-30 07:38 UTC

XMLReaderElement::__get() A

↳ Parent: XMLReaderElement

Complexity

Conditions	3
Paths	3

Size

Total Lines	10
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes	6
Bugs	0	Features	0

Metric	Value
c	6
b	0
f	0
dl	0
loc	10
rs	9.4285
cc	3
eloc	5
nc	3
nop	1

<?php
namespace Sabre\Xml;

class XMLReaderElement implements \Iterator {

    protected $namespace;
    protected $name;
    protected $attributes;
    protected $value;

    public function rewind() {
        reset($this->value);
    }

    public function current() {
        return current($this->value);
    }

    public function key() {
        return key($this->value);
    }

    public function next() {
        return next($this->value);
    }

    public function valid() {
        $key = key($this->value);
        return ($key !== NULL && $key !== FALSE);
    }

    public function parse($data) {
        $this->parseNameSpace($data);
        $this->attributes = (object) $this->convertAttributes($data['attributes']);

        if ($this->isElementArray($data['value'])) {
            $this->value = [];

            foreach ($data['value'] as $value) {
                $this->value[] = (new XMLReaderElement())->parse($value);
            }
        } elseif ($this->isElementValue($data['value'])) {
            $this->value = $this->convertValue($data['value']);
        } else {
            $this->value = (new XMLReaderElement())->parse($data['value']);
        }

        return $this;
    }

    protected function isElementArray($value) {
        return is_array($value) && !array_key_exists('name', $value) && array_key_exists('name', current($value));
    }

    protected function isElementValue($value) {
        return !is_array($value) || !array_key_exists('name', $value);
    }

    protected function parseNameSpace($data) {
        $namespace = [];
        preg_match_all('/{(.*?)}/', $data['name'], $namespace);

        if (count($namespace) === 2) {
            $this->namespace = $namespace[1][0];
            $this->name      = str_replace($namespace[0][0], '', $data['name']);
        } else {
            $this->name      = $data['name'];
        }
    }

    protected function convertAttributes($attributes) {
        foreach ($attributes as $k=>$attribute) {
            $attributes[$k] = $this->convertValue($attribute);
        }

        return $attributes;
    }

    protected function convertValue($value) {
        if (!is_string($value)) {
            return $value;
        }

        if ($this->isBool($value)) {
            return filter_var($value, FILTER_VALIDATE_BOOLEAN);
        }

        if ($this->isInteger($value)) {
            return (int) $value;
        }

        return $value;
    }

    /* Very specific type of integer checking to ensure
    that we have a number value, and not one that has been
    mistakenly casted by PHP. Examples below.

    var_dump(isInteger(23));    //bool(true)
    var_dump(isInteger("23"));  //bool(true)
    var_dump(isInteger(23.5));  //bool(false)
    var_dump(isInteger(NULL));  //bool(false)
    var_dump(isInteger(""));    //bool(false)
    */
    protected function isInteger($input) {
        return (ctype_digit(strval($input)));
    }

    /* Very specific type of boolean checking to ensure
    that we have a bool value, and not one that has been
    mistakenly casted by PHP. Examples below.

    var_dump(isBool(true));     //bool(true)
    var_dump(isBool("false"));  //bool(true)
    var_dump(isBool(0));        //bool(false)
    var_dump(isBool(NULL));     //bool(false)
    var_dump(isBool(""));       //bool(false)
    */
    protected function isBool($input) {
        return in_array(strtolower($input), ['true', 'false']) !== false;
    }

    public function children() {
        if ($this->value instanceof XMLReaderElement) {
            return [$this->value];
        }

        if (is_array($this->value)) {
            $results = [];
            foreach ($this->value as $value) {
                if ($value instanceof XMLReaderElement) {
                    $results[] = $value;
                }
            }
            return $results;
        }

        return [];
    }

    public function hasChildren() {
        return !empty($this->children());
    }

    public function findFirst($search) {
        return current($this->find($search));
    }

    public function find($search) {

        $results = [];

        if ($this->name == $search) {
            $results[] = $this;
        }

        foreach ($this->children() as $child) {
            $results = array_merge($results, $child->find($search));
        }

        if ($search[0] == '@') {
            $search = substr($search, 1);
            $results = array_merge($results, $this->findAttribute($search));
        }

        return $results;
    }

    protected function findAttribute($search) {

        $results = [];
        if (property_exists($this->attributes, $search)) {
            $results[] = $this->attributes->$search;
        }

        return $results;
    }

    public function __get($name) {
        /* Access the Elements Attributes */
        foreach($this->children() as $child) {
            if ($child->name == $name) {
                return $child;
            }
        }

        return $this->$name;
    }

    public function __debugInfo() {

        $arr = ['name'       => $this->name,
                'namespace'  => $this->namespace,
                'attributes' => $this->attributes
                ];

        if ($this->hasChildren()) {
            $names = [];
            foreach ($this->children() as $child) {
                $names[] = $child->name;
            }

            $arr += ['children' => implode(',', $names)];
        } else {
            $arr += ['value' => $this->value];
        }

        return $arr;
    }
}


1			<?php
2			namespace Sabre\Xml;
3
4			class XMLReaderElement implements \Iterator {
5
6			protected $namespace;
7			protected $name;
8			protected $attributes;
9			protected $value;
10
11			public function rewind() {
12			reset($this->value);
13			}
14
15			public function current() {
16			return current($this->value);
17			}
18
19			public function key() {
20			return key($this->value);
21			}
22
23			public function next() {
24			return next($this->value);
25			}
26
27			public function valid() {
28			$key = key($this->value);
29			return ($key !== NULL && $key !== FALSE);
30			}
31
32			public function parse($data) {
33			$this->parseNameSpace($data);
34			$this->attributes = (object) $this->convertAttributes($data['attributes']);
35
36			if ($this->isElementArray($data['value'])) {
37			$this->value = [];
38
39			foreach ($data['value'] as $value) {
40			$this->value[] = (new XMLReaderElement())->parse($value);
41			}
42			} elseif ($this->isElementValue($data['value'])) {
43			$this->value = $this->convertValue($data['value']);
44			} else {
45			$this->value = (new XMLReaderElement())->parse($data['value']);
46			}
47
48			return $this;
49			}
50
51			protected function isElementArray($value) {
52			return is_array($value) && !array_key_exists('name', $value) && array_key_exists('name', current($value));
53			}
54
55			protected function isElementValue($value) {
56			return !is_array($value) \|\| !array_key_exists('name', $value);
57			}
58
59			protected function parseNameSpace($data) {
60			$namespace = [];
61			preg_match_all('/{(.*?)}/', $data['name'], $namespace);
62
63			if (count($namespace) === 2) {
64			$this->namespace = $namespace[1][0];
65			$this->name = str_replace($namespace[0][0], '', $data['name']);
66			} else {
67			$this->name = $data['name'];
68			}
69			}
70
71			protected function convertAttributes($attributes) {
72			foreach ($attributes as $k=>$attribute) {
73			$attributes[$k] = $this->convertValue($attribute);
74			}
75
76			return $attributes;
77			}
78
79			protected function convertValue($value) {
80			if (!is_string($value)) {
81			return $value;
82			}
83
84			if ($this->isBool($value)) {
85			return filter_var($value, FILTER_VALIDATE_BOOLEAN);
86			}
87
88			if ($this->isInteger($value)) {
89			return (int) $value;
90			}
91
92			return $value;
93			}
94
95			/* Very specific type of integer checking to ensure
96			that we have a number value, and not one that has been
97			mistakenly casted by PHP. Examples below.
98
99			var_dump(isInteger(23)); //bool(true)
100			var_dump(isInteger("23")); //bool(true)
101			var_dump(isInteger(23.5)); //bool(false)
102			var_dump(isInteger(NULL)); //bool(false)
103			var_dump(isInteger("")); //bool(false)
104			*/
105			protected function isInteger($input) {
106			return (ctype_digit(strval($input)));
107			}
108
109			/* Very specific type of boolean checking to ensure
110			that we have a bool value, and not one that has been
111			mistakenly casted by PHP. Examples below.
112
113			var_dump(isBool(true)); //bool(true)
114			var_dump(isBool("false")); //bool(true)
115			var_dump(isBool(0)); //bool(false)
116			var_dump(isBool(NULL)); //bool(false)
117			var_dump(isBool("")); //bool(false)
118			*/
119			protected function isBool($input) {
120			return in_array(strtolower($input), ['true', 'false']) !== false;
121			}
122
123			public function children() {
124			if ($this->value instanceof XMLReaderElement) {
125			return [$this->value];
126			}
127
128			if (is_array($this->value)) {
129			$results = [];
130			foreach ($this->value as $value) {
131			if ($value instanceof XMLReaderElement) {
132			$results[] = $value;
133			}
134			}
135			return $results;
136			}
137
138			return [];
139			}
140
141			public function hasChildren() {
142			return !empty($this->children());
143			}
144
145			public function findFirst($search) {
146			return current($this->find($search));
147			}
148
149			public function find($search) {
150
151			$results = [];
152
153			if ($this->name == $search) {
154			$results[] = $this;
155			}
156
157			foreach ($this->children() as $child) {
158			$results = array_merge($results, $child->find($search));
159			}
160
161			if ($search[0] == '@') {
162			$search = substr($search, 1);
163			$results = array_merge($results, $this->findAttribute($search));
164			}
165
166			return $results;
167			}
168
169			protected function findAttribute($search) {
170
171			$results = [];
172			if (property_exists($this->attributes, $search)) {
173			$results[] = $this->attributes->$search;
174			}
175
176			return $results;
177			}
178
179			public function __get($name) {
180			/* Access the Elements Attributes */
181			foreach($this->children() as $child) {
182			if ($child->name == $name) {
183			return $child;
184			}
185			}
186
187			return $this->$name;
188			}
189
190			public function __debugInfo() {
191
192			$arr = ['name' => $this->name,
193			'namespace' => $this->namespace,
194			'attributes' => $this->attributes
195			];
196
197			if ($this->hasChildren()) {
198			$names = [];
199			foreach ($this->children() as $child) {
200			$names[] = $child->name;
201			}
202
203			$arr += ['children' => implode(',', $names)];
204			} else {
205			$arr += ['value' => $this->value];
206			}
207
208			return $arr;
209			}
210			}
211

andrewfenn / XMLReaderElement

Push — master ( f85170...1d219c )

XMLReaderElement::__get() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like