DataType::getRefId() - Code Metrics - Inspection of "Fix more inspections" - phingofficial/phing - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 045f45...2c73e4 )

by Michiel

created 2019-08-06 14:18 UTC

DataType::getRefId() A

↳ Parent: DataType

Complexity

Conditions	2
Paths	2

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	6

Importance

Changes

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

<?php
/**
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * This software consists of voluntary contributions made by many individuals
 * and is licensed under the LGPL. For more information please see
 * <http://phing.info>.
 */

/**
 * Base class for those classes that can appear inside the build file
 * as stand alone data types.
 *
 * This class handles the common description attribute and provides
 * a default implementation for reference handling and checking for
 * circular references that is appropriate for types that can not be
 * nested inside elements of the same type (i.e. patternset but not path)
 *
 * {@inheritdoc}
 *
 * @package phing.types
 */
class DataType extends ProjectComponent
{
    /**
     * Value to the refid attribute.
     *
     * @var Reference $ref
     */
    private $ref;

    /**
     * Are we sure we don't hold circular references?
     *
     * Subclasses are responsible for setting this value to false
     * if we'd need to investigate this condition (usually because a
     * child element has been added that is a subclass of DataType).
     *
     * @var boolean
     */
    protected $checked = true;

    /**
     * Has the refid attribute of this element been set?
     *
     * @return bool
     */
    public function isReference()
    {
        return ($this->ref !== null);
    }

    /**
     * @return string|null
     */
    public function getRefId()
    {
        return ($this->ref !== null ? $this->ref->getRefId() : null);
    }

    /**
     * Set the value of the refid attribute.
     *
     * Subclasses may need to check whether any other attributes
     * have been set as well or child elements have been created and
     * thus override this method. if they do they must call parent::setRefid()
     *
     * @param Reference $r
     *
     * @return void
     */
    public function setRefid(Reference $r)
    {
        $this->ref = $r;
        $this->checked = false;
    }

    /**
     * @param bool $checked
     */
    public function setChecked($checked)
    {
        $this->checked = $checked;
    }

    /**
     * Check to see whether any DataType we hold references to is
     * included in the Stack (which holds all DataType instances that
     * directly or indirectly reference this instance, including this
     * instance itself).
     *
     * If one is included, throw a BuildException created by circularReference
     *
     * This implementation is appropriate only for a DataType that
     * cannot hold other DataTypes as children.
     *
     * The general contract of this method is that it shouldn't do
     * anything if checked is true and set it to true on exit.
     *
     * @param $stk
     * @param Project $p
     *
     * @return void
     *
     * @throws BuildException
     */
    public function dieOnCircularReference(&$stk, Project $p = null)
    {
        if ($this->checked || !$this->isReference()) {
            return;
        }

        $o = $this->ref->getReferencedObject($p);

        if ($o instanceof DataType) {
            // TESTME - make sure that in_array() works just as well here
            //
            // check if reference is in stack
            //$contains = false;
            //for ($i=0, $size=count($stk); $i < $size; $i++) {
            //    if ($stk[$i] === $o) {
            //        $contains = true;
            //        break;
            //    }
            //}

            if (in_array($o, $stk, true)) {
                // throw build exception
                throw $this->circularReference();
            } else {
                $stk[] = $o;
                $o->dieOnCircularReference($stk, $p);
                array_pop($stk);
            }
        }
        $this->checked = true;
    }

    public static function pushAndInvokeCircularReferenceCheck(DataType $dt, &$stk, Project $p)
    {
        $stk[] = $dt;
        $dt->dieOnCircularReference($stk, $p);
        array_pop($stk);
    }

    /**
     * Performs the check for circular references and returns the referenced object.
     *
     * @param $requiredClass
     * @param $dataTypeName
     *
     * @throws BuildException
     *
     * @return mixed
     */
    public function getCheckedRef($requiredClass, $dataTypeName)
    {
        if (!$this->checked) {
            // should be in stack
            $stk = [];
            $stk[] = $this;
            $this->dieOnCircularReference($stk, $this->getProject());
        }

        $o = $this->ref->getReferencedObject($this->getProject());
        if (!($o instanceof $requiredClass)) {
            throw new BuildException($this->ref->getRefId() . " doesn't denote a " . $dataTypeName);
        } else {
            return $o;
        }
    }

    /**
     * Creates an exception that indicates that refid has to be the
     * only attribute if it is set.
     *
     * @return BuildException
     */
    public function tooManyAttributes()
    {
        return new BuildException("You must not specify more than one attribute when using refid");
    }

    /**
     * Creates an exception that indicates that this XML element must
     * not have child elements if the refid attribute is set.
     *
     * @return BuildException
     */
    public function noChildrenAllowed()
    {
        return new BuildException("You must not specify nested elements when using refid");
    }

    /**
     * Creates an exception that indicates the user has generated a
     * loop of data types referencing each other.
     *
     * @return BuildException
     */
    public function circularReference()
    {
        return new BuildException("This data type contains a circular reference.");
    }

    /**
     * Template method being called when the data type has been
     * parsed completely.
     *
     * {@inheritdoc}
     *
     * @return void
     */
    public function parsingComplete()
    {
    }

    /**
     * Gets as descriptive as possible a name used for this datatype instance.
     *
     * @return string name.
     */
    protected function getDataTypeName()
    {
        return ComponentHelper::getElementName($this->getProject(), $this, true);
    }

    /**
     * Basic DataType toString().
     *
     * @return string this DataType formatted as a String.
     */
    public function __toString()
    {
        $d = $this->getDescription();
        return $d === null ? $this->getDataTypeName() : $this->getDataTypeName() . " " . $d;

    }
}


1		<?php
2		/**
3		* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
4		* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
5		* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
6		* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
7		* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
8		* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
9		* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
10		* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
11		* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
12		* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
13		* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
14		*
15		* This software consists of voluntary contributions made by many individuals
16		* and is licensed under the LGPL. For more information please see
17		* <http://phing.info>.
18		*/
19
20		/**
21		* Base class for those classes that can appear inside the build file
22		* as stand alone data types.
23		*
24		* This class handles the common description attribute and provides
25		* a default implementation for reference handling and checking for
26		* circular references that is appropriate for types that can not be
27		* nested inside elements of the same type (i.e. patternset but not path)
28		*
29		* {@inheritdoc}
30		*
31		* @package phing.types
32		*/
33		class DataType extends ProjectComponent
34		{
35		/**
36		* Value to the refid attribute.
37		*
38		* @var Reference $ref
39		*/
40		private $ref;
41
42		/**
43		* Are we sure we don't hold circular references?
44		*
45		* Subclasses are responsible for setting this value to false
46		* if we'd need to investigate this condition (usually because a
47		* child element has been added that is a subclass of DataType).
48		*
49		* @var boolean
50		*/
51		protected $checked = true;
52
53		/**
54		* Has the refid attribute of this element been set?
55		*
56		* @return bool
57		*/
58	174	public function isReference()
59		{
60	174	return ($this->ref !== null);
61		}
62
63		/**
64		* @return string\|null
65		*/
66		public function getRefId()
67		{
68		return ($this->ref !== null ? $this->ref->getRefId() : null);
69		}
70
71		/**
72		* Set the value of the refid attribute.
73		*
74		* Subclasses may need to check whether any other attributes
75		* have been set as well or child elements have been created and
76		* thus override this method. if they do they must call parent::setRefid()
77		*
78		* @param Reference $r
79		*
80		* @return void
81		*/
82	18	public function setRefid(Reference $r)
83		{
84	18	$this->ref = $r;
85	18	$this->checked = false;
86	18	}
87
88		/**
89		* @param bool $checked
90		*/
91	7	public function setChecked($checked)
92		{
93	7	$this->checked = $checked;
94	7	}
95
96		/**
97		* Check to see whether any DataType we hold references to is
98		* included in the Stack (which holds all DataType instances that
99		* directly or indirectly reference this instance, including this
100		* instance itself).
101		*
102		* If one is included, throw a BuildException created by circularReference
103		*
104		* This implementation is appropriate only for a DataType that
105		* cannot hold other DataTypes as children.
106		*
107		* The general contract of this method is that it shouldn't do
108		* anything if checked is true and set it to true on exit.
109		*
110		* @param $stk
111		* @param Project $p
112		*
113		* @return void
114		*
115		* @throws BuildException
116		*/
117	5	public function dieOnCircularReference(&$stk, Project $p = null)
118		{
119	5	if ($this->checked \|\| !$this->isReference()) {
120	5	return;
121		}
122
123	2	$o = $this->ref->getReferencedObject($p);
124
125	2	if ($o instanceof DataType) {
126		// TESTME - make sure that in_array() works just as well here
127		//
128		// check if reference is in stack
129		//$contains = false;
130		//for ($i=0, $size=count($stk); $i < $size; $i++) {
131		// if ($stk[$i] === $o) {
132		// $contains = true;
133		// break;
134		// }
135		//}
136
137	2	if (in_array($o, $stk, true)) {
138		// throw build exception
139	1	throw $this->circularReference();
140		} else {
141	2	$stk[] = $o;
142	2	$o->dieOnCircularReference($stk, $p);
143	2	array_pop($stk);
144		}
145		}
146	2	$this->checked = true;
147	2	}
148
149	4	public static function pushAndInvokeCircularReferenceCheck(DataType $dt, &$stk, Project $p)
150		{
151	4	$stk[] = $dt;
152	4	$dt->dieOnCircularReference($stk, $p);
153	4	array_pop($stk);
154	4	}
155
156		/**
157		* Performs the check for circular references and returns the referenced object.
158		*
159		* @param $requiredClass
160		* @param $dataTypeName
161		*
162		* @throws BuildException
163		*
164		* @return mixed
165		*/
166	2	public function getCheckedRef($requiredClass, $dataTypeName)
167		{
168	2	if (!$this->checked) {
169		// should be in stack
170	2	$stk = [];
171	2	$stk[] = $this;
172	2	$this->dieOnCircularReference($stk, $this->getProject());
173		}
174
175	2	$o = $this->ref->getReferencedObject($this->getProject());
176	2	if (!($o instanceof $requiredClass)) {
177		throw new BuildException($this->ref->getRefId() . " doesn't denote a " . $dataTypeName);
178		} else {
179	2	return $o;
180		}
181		}
182
183		/**
184		* Creates an exception that indicates that refid has to be the
185		* only attribute if it is set.
186		*
187		* @return BuildException
188		*/
189	2	public function tooManyAttributes()
190		{
191	2	return new BuildException("You must not specify more than one attribute when using refid");
192		}
193
194		/**
195		* Creates an exception that indicates that this XML element must
196		* not have child elements if the refid attribute is set.
197		*
198		* @return BuildException
199		*/
200	1	public function noChildrenAllowed()
201		{
202	1	return new BuildException("You must not specify nested elements when using refid");
203		}
204
205		/**
206		* Creates an exception that indicates the user has generated a
207		* loop of data types referencing each other.
208		*
209		* @return BuildException
210		*/
211	1	public function circularReference()
212		{
213	1	return new BuildException("This data type contains a circular reference.");
214		}
215
216		/**
217		* Template method being called when the data type has been
218		* parsed completely.
219		*
220		* {@inheritdoc}
221		*
222		* @return void
223		*/
224		public function parsingComplete()
225		{
226		}
227
228		/**
229		* Gets as descriptive as possible a name used for this datatype instance.
230		*
231		* @return string name.
232		*/
233	102	protected function getDataTypeName()
234		{
235	102	return ComponentHelper::getElementName($this->getProject(), $this, true);
236		}
237
238		/**
239		* Basic DataType toString().
240		*
241		* @return string this DataType formatted as a String.
242		*/
243	5	public function __toString()
244		{
245	5	$d = $this->getDescription();
246	5	return $d === null ? $this->getDataTypeName() : $this->getDataTypeName() . " " . $d;
		0 ignored issues – show introduced 2019-07-31 09:36 UTC by Report Bug Copy Issue Report The condition `$d === null` is always `false`. Loading history...
247		}
248		}
249

phingofficial / phing

Push — master ( 045f45...2c73e4 )

DataType::getRefId() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like