Factory::Caa() - Code Metrics - Inspection of "Rdata: add new CAA record type and unit test" - Badcow/DNS - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#26)

unknown

created 2019-02-17 09:56 UTC

Factory::Caa() A

↳ Parent: Factory

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	9
ccs	6
cts	6
cp	1
rs	9.9666
c	0
b	0
f	0
cc	1
nc	1
nop	3
crap	1

<?php

/*
 * This file is part of Badcow DNS Library.
 *
 * (c) Samuel Williams <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Badcow\DNS\Rdata;

use Badcow\DNS\Rdata\DNSSEC\DNSKEY;
use Badcow\DNS\Rdata\DNSSEC\DS;
use Badcow\DNS\Rdata\DNSSEC\NSEC;
use Badcow\DNS\Rdata\DNSSEC\RRSIG;

class Factory
{
    /**
     * Creates a new RData object from a name.
     *
     * @param string $name
     *
     * @throws UnsupportedTypeException
     *
     * @return RdataInterface
     */
    public static function newRdataFromName(string $name): RdataInterface
    {
        if (!self::isTypeImplemented($name)) {
            throw new UnsupportedTypeException($name);
        }

        $namespace = '\\Badcow\\DNS\\Rdata\\';
        $className = $namespace.strtoupper($name);

        if (!class_exists($className)) {
            $className = $namespace.'DNSSEC\\'.strtoupper($name);
        }

        return new $className();
    }

    /**
     * @param string $name
     *
     * @return bool
     */
    public static function isTypeImplemented(string $name): bool
    {
        $namespace = '\\Badcow\\DNS\\Rdata\\';
        $name = strtoupper($name);

        return class_exists($namespace.$name) || class_exists($namespace.'DNSSEC\\'.$name);
    }

    /**
     * Create a new AAAA R-Data object.
     *
     * @param string $address
     *
     * @return AAAA
     */
    public static function Aaaa($address)
    {
        $rdata = new AAAA();
        $rdata->setAddress($address);

        return $rdata;
    }

    /**
     * Create a new A R-Data object.
     *
     * @param string $address
     *
     * @return A
     */
    public static function A($address)
    {
        $rdata = new A();
        $rdata->setAddress($address);

        return $rdata;
    }

    /**
     * Create a new CNAME object.
     *
     * @param string $cname
     *
     * @return CNAME
     */
    public static function Cname($cname)
    {
        $rdata = new CNAME();
        $rdata->setTarget($cname);

        return $rdata;
    }

    /**
     * @param string $cpu
     * @param string $os
     *
     * @return HINFO
     */
    public static function Hinfo($cpu, $os)
    {
        $rdata = new HINFO();
        $rdata->setCpu($cpu);
        $rdata->setOs($os);

        return $rdata;
    }

    /**
     * @param int    $preference
     * @param string $exchange
     *
     * @return MX
     */
    public static function Mx($preference, $exchange)
    {
        $rdata = new MX();
        $rdata->setPreference($preference);
        $rdata->setExchange($exchange);

        return $rdata;
    }

    /**
     * @param string $mname
     * @param string $rname
     * @param int    $serial
     * @param int    $refresh
     * @param int    $retry
     * @param int    $expire
     * @param int    $minimum
     *
     * @return SOA
     */
    public static function Soa($mname, $rname, $serial, $refresh, $retry, $expire, $minimum)
    {
        $rdata = new SOA();
        $rdata->setMname($mname);
        $rdata->setRname($rname);
        $rdata->setSerial($serial);
        $rdata->setRefresh($refresh);
        $rdata->setRetry($retry);
        $rdata->setExpire($expire);
        $rdata->setMinimum($minimum);

        return $rdata;
    }

    /**
     * @param string $nsdname
     *
     * @return NS
     */
    public static function Ns($nsdname)
    {
        $rdata = new NS();
        $rdata->setTarget($nsdname);

        return $rdata;
    }

    /**
     * @param string $text
     *
     * @return TXT
     */
    public static function txt($text)
    {
        $rdata = new TXT();
        $rdata->setText($text);

        return $rdata;
    }

    /**
     * @param string $target
     *
     * @return DNAME
     */
    public static function Dname($target)
    {
        $rdata = new DNAME();
        $rdata->setTarget($target);

        return $rdata;
    }

    /**
     * @param $lat
     * @param $lon
     * @param float $alt
     * @param float $size
     * @param float $hp
     * @param float $vp
     *
     * @return LOC
     */
    public static function Loc($lat, $lon, $alt = 0.0, $size = 1.0, $hp = 10000.0, $vp = 10.0)
    {
        $rdata = new LOC();
        $rdata->setLatitude($lat);
        $rdata->setLongitude($lon);
        $rdata->setAltitude($alt);
        $rdata->setSize($size);
        $rdata->setHorizontalPrecision($hp);
        $rdata->setVerticalPrecision($vp);

        return $rdata;
    }

    /**
     * @param string $target
     *
     * @return PTR
     */
    public static function Ptr($target)
    {
        $rdata = new PTR();
        $rdata->setTarget($target);

        return $rdata;
    }

    /**
     * @param int    $flags
     * @param int    $algorithm
     * @param string $publicKey
     *
     * @return DNSKEY
     */
    public static function Dnskey($flags, $algorithm, $publicKey)
    {
        $rdata = new DNSKEY();
        $rdata->setFlags($flags);
        $rdata->setAlgorithm($algorithm);
        $rdata->setPublicKey($publicKey);

        return $rdata;
    }

    /**
     * @param int    $keyTag
     * @param int    $algorithm
     * @param string $digest
     * @param int    $digestType
     *
     * @return DS
     */
    public static function Ds(int $keyTag, int $algorithm, string $digest, int $digestType = DS::DIGEST_SHA1)
    {
        $rdata = new DS();
        $rdata->setKeyTag($keyTag);
        $rdata->setAlgorithm($algorithm);
        $rdata->setDigest($digest);
        $rdata->setDigestType($digestType);

        return $rdata;
    }

    /**
     * @param string $nextDomainName
     * @param array  $typeBitMaps
     *
     * @return NSEC
     */
    public static function Nsec(string $nextDomainName, array $typeBitMaps)
    {
        $rdata = new NSEC();
        $rdata->setNextDomainName($nextDomainName);
        array_map([$rdata, 'addTypeBitMap'], $typeBitMaps);

        return $rdata;
    }

    /**
     * @param $typeCovered
     * @param $algorithm
     * @param $labels
     * @param $originalTtl
     * @param $signatureExpiration
     * @param $signatureInception
     * @param $keyTag
     * @param $signersName
     * @param $signature
     *
     * @return RRSIG
     */
    public static function Rrsig($typeCovered, $algorithm, $labels, $originalTtl,
                          $signatureExpiration, $signatureInception, $keyTag,
                          $signersName, $signature)
    {
        $rdata = new RRSIG();
        $rdata->setTypeCovered($typeCovered);
        $rdata->setAlgorithm($algorithm);
        $rdata->setLabels($labels);
        $rdata->setOriginalTtl($originalTtl);
        $rdata->setSignatureExpiration($signatureExpiration);
        $rdata->setSignatureInception($signatureInception);
        $rdata->setKeyTag($keyTag);
        $rdata->setSignersName($signersName);
        $rdata->setSignature($signature);

        return $rdata;
    }

    /**
     * @param int    $priority
     * @param int    $weight
     * @param int    $port
     * @param string $target
     *
     * @return SRV
     */
    public static function Srv(int $priority, int $weight, int $port, string $target)
    {
        $rdata = new SRV();
        $rdata->setPriority($priority);
        $rdata->setWeight($weight);
        $rdata->setPort($port);
        $rdata->setTarget($target);

        return $rdata;
    }

    /**
     * @param \IPBlock[] $includedRanges
     * @param \IPBlock[] $excludedRanges
     *
     * @return APL
     */
    public static function Apl(array $includedRanges = [], array $excludedRanges = []): APL
    {
        $rdata = new APL();

        foreach ($includedRanges as $ipBlock) {
            $rdata->addAddressRange($ipBlock, true);
        }

        foreach ($excludedRanges as $ipBlock) {
            $rdata->addAddressRange($ipBlock, false);
        }

        return $rdata;
    }

    /**
     * @param integer $flag
     * @param string  $tag
     * @param string  $target
     *
     * @return CAA
     */
    public static function Caa($flag, $tag, $target)
    {
        $rdata = new CAA();
        $rdata->setFlag($flag);
        $rdata->setTag($tag);
        $rdata->setTarget($target);

        return $rdata;
    }
}


1		<?php
2
3		/*
4		* This file is part of Badcow DNS Library.
5		*
6		* (c) Samuel Williams <[email protected]>
7		*
8		* For the full copyright and license information, please view the LICENSE
9		* file that was distributed with this source code.
10		*/
11
12		namespace Badcow\DNS\Rdata;
13
14		use Badcow\DNS\Rdata\DNSSEC\DNSKEY;
15		use Badcow\DNS\Rdata\DNSSEC\DS;
16		use Badcow\DNS\Rdata\DNSSEC\NSEC;
17		use Badcow\DNS\Rdata\DNSSEC\RRSIG;
18
19		class Factory
20		{
21		/**
22		* Creates a new RData object from a name.
23		*
24		* @param string $name
25		*
26		* @throws UnsupportedTypeException
27		*
28		* @return RdataInterface
29		*/
30	1	public static function newRdataFromName(string $name): RdataInterface
31		{
32	1	if (!self::isTypeImplemented($name)) {
33	1	throw new UnsupportedTypeException($name);
34		}
35
36	1	$namespace = '\\Badcow\\DNS\\Rdata\\';
37	1	$className = $namespace.strtoupper($name);
38
39	1	if (!class_exists($className)) {
40	1	$className = $namespace.'DNSSEC\\'.strtoupper($name);
41		}
42
43	1	return new $className();
44		}
45
46		/**
47		* @param string $name
48		*
49		* @return bool
50		*/
51	1	public static function isTypeImplemented(string $name): bool
52		{
53	1	$namespace = '\\Badcow\\DNS\\Rdata\\';
54	1	$name = strtoupper($name);
55
56	1	return class_exists($namespace.$name) \|\| class_exists($namespace.'DNSSEC\\'.$name);
57		}
58
59		/**
60		* Create a new AAAA R-Data object.
61		*
62		* @param string $address
63		*
64		* @return AAAA
65		*/
66	9	public static function Aaaa($address)
67		{
68	9	$rdata = new AAAA();
69	9	$rdata->setAddress($address);
70
71	9	return $rdata;
72		}
73
74		/**
75		* Create a new A R-Data object.
76		*
77		* @param string $address
78		*
79		* @return A
80		*/
81	10	public static function A($address)
82		{
83	10	$rdata = new A();
84	10	$rdata->setAddress($address);
85
86	10	return $rdata;
87		}
88
89		/**
90		* Create a new CNAME object.
91		*
92		* @param string $cname
93		*
94		* @return CNAME
95		*/
96	8	public static function Cname($cname)
97		{
98	8	$rdata = new CNAME();
99	8	$rdata->setTarget($cname);
100
101	8	return $rdata;
102		}
103
104		/**
105		* @param string $cpu
106		* @param string $os
107		*
108		* @return HINFO
109		*/
110	7	public static function Hinfo($cpu, $os)
111		{
112	7	$rdata = new HINFO();
113	7	$rdata->setCpu($cpu);
114	7	$rdata->setOs($os);
115
116	7	return $rdata;
117		}
118
119		/**
120		* @param int $preference
121		* @param string $exchange
122		*
123		* @return MX
124		*/
125	9	public static function Mx($preference, $exchange)
126		{
127	9	$rdata = new MX();
128	9	$rdata->setPreference($preference);
129	9	$rdata->setExchange($exchange);
130
131	9	return $rdata;
132		}
133
134		/**
135		* @param string $mname
136		* @param string $rname
137		* @param int $serial
138		* @param int $refresh
139		* @param int $retry
140		* @param int $expire
141		* @param int $minimum
142		*
143		* @return SOA
144		*/
145	12	public static function Soa($mname, $rname, $serial, $refresh, $retry, $expire, $minimum)
146		{
147	12	$rdata = new SOA();
148	12	$rdata->setMname($mname);
149	12	$rdata->setRname($rname);
150	12	$rdata->setSerial($serial);
151	12	$rdata->setRefresh($refresh);
152	12	$rdata->setRetry($retry);
153	12	$rdata->setExpire($expire);
154	12	$rdata->setMinimum($minimum);
155
156	12	return $rdata;
157		}
158
159		/**
160		* @param string $nsdname
161		*
162		* @return NS
163		*/
164	11	public static function Ns($nsdname)
165		{
166	11	$rdata = new NS();
167	11	$rdata->setTarget($nsdname);
168
169	11	return $rdata;
170		}
171
172		/**
173		* @param string $text
174		*
175		* @return TXT
176		*/
177	8	public static function txt($text)
178		{
179	8	$rdata = new TXT();
180	8	$rdata->setText($text);
181
182	8	return $rdata;
183		}
184
185		/**
186		* @param string $target
187		*
188		* @return DNAME
189		*/
190	7	public static function Dname($target)
191		{
192	7	$rdata = new DNAME();
193	7	$rdata->setTarget($target);
194
195	7	return $rdata;
196		}
197
198		/**
199		* @param $lat
200		* @param $lon
201		* @param float $alt
202		* @param float $size
203		* @param float $hp
204		* @param float $vp
205		*
206		* @return LOC
207		*/
208	8	public static function Loc($lat, $lon, $alt = 0.0, $size = 1.0, $hp = 10000.0, $vp = 10.0)
209		{
210	8	$rdata = new LOC();
211	8	$rdata->setLatitude($lat);
212	8	$rdata->setLongitude($lon);
213	8	$rdata->setAltitude($alt);
214	8	$rdata->setSize($size);
215	8	$rdata->setHorizontalPrecision($hp);
216	8	$rdata->setVerticalPrecision($vp);
217
218	8	return $rdata;
219		}
220
221		/**
222		* @param string $target
223		*
224		* @return PTR
225		*/
226	2	public static function Ptr($target)
227		{
228	2	$rdata = new PTR();
229	2	$rdata->setTarget($target);
230
231	2	return $rdata;
232		}
233
234		/**
235		* @param int $flags
236		* @param int $algorithm
237		* @param string $publicKey
238		*
239		* @return DNSKEY
240		*/
241	1	public static function Dnskey($flags, $algorithm, $publicKey)
242		{
243	1	$rdata = new DNSKEY();
244	1	$rdata->setFlags($flags);
245	1	$rdata->setAlgorithm($algorithm);
246	1	$rdata->setPublicKey($publicKey);
247
248	1	return $rdata;
249		}
250
251		/**
252		* @param int $keyTag
253		* @param int $algorithm
254		* @param string $digest
255		* @param int $digestType
256		*
257		* @return DS
258		*/
259	1	public static function Ds(int $keyTag, int $algorithm, string $digest, int $digestType = DS::DIGEST_SHA1)
260		{
261	1	$rdata = new DS();
262	1	$rdata->setKeyTag($keyTag);
263	1	$rdata->setAlgorithm($algorithm);
264	1	$rdata->setDigest($digest);
265	1	$rdata->setDigestType($digestType);
266
267	1	return $rdata;
268		}
269
270		/**
271		* @param string $nextDomainName
272		* @param array $typeBitMaps
273		*
274		* @return NSEC
275		*/
276	1	public static function Nsec(string $nextDomainName, array $typeBitMaps)
277		{
278	1	$rdata = new NSEC();
279	1	$rdata->setNextDomainName($nextDomainName);
280	1	array_map([$rdata, 'addTypeBitMap'], $typeBitMaps);
281
282	1	return $rdata;
283		}
284
285		/**
286		* @param $typeCovered
287		* @param $algorithm
288		* @param $labels
289		* @param $originalTtl
290		* @param $signatureExpiration
291		* @param $signatureInception
292		* @param $keyTag
293		* @param $signersName
294		* @param $signature
295		*
296		* @return RRSIG
297		*/
298	1	public static function Rrsig($typeCovered, $algorithm, $labels, $originalTtl,
299		$signatureExpiration, $signatureInception, $keyTag,
300		$signersName, $signature)
301		{
302	1	$rdata = new RRSIG();
303	1	$rdata->setTypeCovered($typeCovered);
304	1	$rdata->setAlgorithm($algorithm);
305	1	$rdata->setLabels($labels);
306	1	$rdata->setOriginalTtl($originalTtl);
307	1	$rdata->setSignatureExpiration($signatureExpiration);
308	1	$rdata->setSignatureInception($signatureInception);
309	1	$rdata->setKeyTag($keyTag);
310	1	$rdata->setSignersName($signersName);
311	1	$rdata->setSignature($signature);
312
313	1	return $rdata;
314		}
315
316		/**
317		* @param int $priority
318		* @param int $weight
319		* @param int $port
320		* @param string $target
321		*
322		* @return SRV
323		*/
324	1	public static function Srv(int $priority, int $weight, int $port, string $target)
325		{
326	1	$rdata = new SRV();
327	1	$rdata->setPriority($priority);
328	1	$rdata->setWeight($weight);
329	1	$rdata->setPort($port);
330	1	$rdata->setTarget($target);
331
332	1	return $rdata;
333		}
334
335		/**
336		* @param \IPBlock[] $includedRanges
337		* @param \IPBlock[] $excludedRanges
338		*
339		* @return APL
340		*/
341	2	public static function Apl(array $includedRanges = [], array $excludedRanges = []): APL
342		{
343	2	$rdata = new APL();
344
345	2	foreach ($includedRanges as $ipBlock) {
346	2	$rdata->addAddressRange($ipBlock, true);
347		}
348
349	2	foreach ($excludedRanges as $ipBlock) {
350	2	$rdata->addAddressRange($ipBlock, false);
351		}
352
353	2	return $rdata;
354		}
355
356		/**
357		* @param integer $flag
358		* @param string $tag
359		* @param string $target
360		*
361		* @return CAA
362		*/
363	1	public static function Caa($flag, $tag, $target)
364		{
365	1	$rdata = new CAA();
366	1	$rdata->setFlag($flag);
367	1	$rdata->setTag($tag);
368	1	$rdata->setTarget($target);
369
370	1	return $rdata;
371		}
372		}
373

Badcow / DNS

Pull Request — master (#26)

Factory::Caa() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like