ParseInetAddress::from() - Code Metrics - Inspection of "New: support for parsing a single, complete net in..." - ganbarodigital/php-operating-system - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( a3c683...8c914c )

by Stuart

created 2016-01-31 15:53 UTC

ParseInetAddress::from() A

↳ Parent: ParseInetAddress

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

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

<?php

/**
 * Copyright (c) 2016-present Ganbaro Digital Ltd
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   * Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *
 *   * Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in
 *     the documentation and/or other materials provided with the
 *     distribution.
 *
 *   * Neither the names of the copyright holders nor the names of his
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * 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.
 *
 * @category  Libraries
 * @package   OperatingSystem/NetInterface/Parsers
 * @author    Stuart Herbert <[email protected]>
 * @copyright 2016-present Ganbaro Digital Ltd www.ganbarodigital.com
 * @license   http://www.opensource.org/licenses/bsd-license.php  BSD License
 * @link      http://code.ganbarodigital.com/php-operating-system
 */

namespace GanbaroDigital\OperatingSystem\IpRoute\Parsers;

use GanbaroDigital\ArrayTools\Filters\ExtractFirstItem;
use GanbaroDigital\ArrayTools\Parsers\ConvertKeyValuePairsToArray;
use GanbaroDigital\ArrayTools\ValueBuilders\ConvertToArray;
use GanbaroDigital\OperatingSystem\Exceptions\E4xx_CannotParseInetAddressLine;
use GanbaroDigital\OperatingSystem\Exceptions\E4xx_UnsupportedType;
use GanbaroDigital\OperatingSystem\IpRoute\Classifiers\ClassifyIpAddrLine;
use GanbaroDigital\OperatingSystem\NetInterfaces\Values\InetAddress;
use GanbaroDigital\Reflection\Maps\MapTypeToMethod;
use GanbaroDigital\Reflection\ValueBuilders\SimpleType;

class ParseInetAddress
{
    /**
     * parse an inet (IPv4) address block from the output of 'ip addr show'
     *
     * @param  mixed $inetLines
     *         the line(s) to parse
     * @return InetAddress
     *         the inet address defined in the output
     */
    public function __invoke($inetLines)
    {
        return self::from($inetLines);
    }

    /**
     * parse an inet (IPv4) address block from the output of 'ip addr show'
     *
     * @param  mixed $inetLines
     *         the line(s) to parse
     * @return InetAddress
     *         the inet address defined in the output
     */
    public static function from($inetLines)
    {
        $method = MapTypeToMethod::using($inetLines, self::$dispatchMap);
        return self::$method($inetLines);
    }

    /**
     * a map of which types we support, and how to process them
     * @var array
     */
    private static $dispatchMap = [
        "String" => "fromString",
        "Traversable" => "fromTraversable",
    ];

    /**
     * called when we've been given a data type that we do not support
     *
     * @param  mixed $output
     *         the unsupported data
     * @return void
     * @throws E4xx_UnsupportedType
     */
    private static function nothingMatchesTheInputType($output)
    {
        throw new E4xx_UnsupportedType(SimpleType::from($output));
    }

    /**
     * parse an inet (IPv4) address block from the output of 'ip addr show'
     *
     * @param  string $inetLines
     *         the line(s) to parse
     * @return InetAddress
     *         the inet address defined in the output
     */
    private static function fromString($inetLines)
    {
        $lines = explode("\n", $inetLines);
        return self::fromTraversable($lines);
    }

    /**
     * parse an inet (IPv4) address block from the output of 'ip addr show'
     *
     * @param  array|Traversable $inetLines
     *         the line(s) to parse
     * @return InetAddress
     *         the inet address defined in the output
     */
    private static function fromTraversable($inetLines)
    {
        // we want a real PHP array for this
        $inetLines = ConvertToArray::from($inetLines);

        // line 0 is the inet line itself
        $inetDetails = self::parseFirstLine(array_shift($inetLines));

        // if there is a line 1, it contains additional flags
        while (!empty($inetLines)) {
            $inetDetails['properties'] = array_merge(self::parseSecondLine(array_shift($inetLines)), $inetDetails['properties']);
        }

        // now to convert this into an InetAddress value
        $retval = new InetAddress(
            $inetDetails['address'],
            $inetDetails['netmask'],
            $inetDetails['broadcast'],
            $inetDetails['scope'],
            $inetDetails['addressLabel'],
            $inetDetails['linkDevice'],
            $inetDetails['properties']
        );

        // all done
        return $retval;
    }

    /**
     * extract data from the first line of the inet address definition
     *
     * @param  string $line
     *         the line to parse
     * @return array
     *         the extracted data
     */
    private static function parseFirstLine($line)
    {
        // this regex will parse everything we know to expect from the first
        // line of an inet definition
        $regex = "~inet (?<addr>[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3})(?<netmask>/[0-9]{1,3})( brd (?<broadcast>[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3})){0,1}( scope (?<scope>[a-z]+)){0,1}( (?<addressLabel>secondary|dynamic|deprecated|tentative)){0,1}( (?<linkDevice>.*)){0,1}$~";
        $matches = [];
        if (!preg_match_all($regex, $line, $matches)) {
            throw new E4xx_CannotParseInetAddressLine($line);
        }

        return [
            'address' => $matches['addr'][0],
            'netmask' => $matches['netmask'][0],
            'broadcast' => ExtractFirstItem::from($matches['broadcast'], null),
            'scope' => ExtractFirstItem::from($matches['scope'], null),
            'addressLabel' => ExtractFirstItem::from($matches['addressLabel'], null),
            'linkDevice' => ExtractFirstItem::from($matches['linkDevice'], null),
            'properties' => [],
        ];
    }

    /**
     * extract data from the second line of the inet address definition
     *
     * @param  string $line
     *         the line to parse
     * @return array
     *         the extracted data, as key/value pairs
     */
    private static function parseSecondLine($line)
    {
        return ConvertKeyValuePairsToArray::from($line, ' ', ' ');
    }
}


1			<?php
2
3			/**
4			* Copyright (c) 2016-present Ganbaro Digital Ltd
5			* All rights reserved.
6			*
7			* Redistribution and use in source and binary forms, with or without
8			* modification, are permitted provided that the following conditions
9			* are met:
10			*
11			* * Redistributions of source code must retain the above copyright
12			* notice, this list of conditions and the following disclaimer.
13			*
14			* * Redistributions in binary form must reproduce the above copyright
15			* notice, this list of conditions and the following disclaimer in
16			* the documentation and/or other materials provided with the
17			* distribution.
18			*
19			* * Neither the names of the copyright holders nor the names of his
20			* contributors may be used to endorse or promote products derived
21			* from this software without specific prior written permission.
22			*
23			* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24			* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25			* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
26			* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
27			* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
28			* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
29			* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
30			* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
31			* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
33			* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34			* POSSIBILITY OF SUCH DAMAGE.
35			*
36			* @category Libraries
37			* @package OperatingSystem/NetInterface/Parsers
38			* @author Stuart Herbert <[email protected]>
39			* @copyright 2016-present Ganbaro Digital Ltd www.ganbarodigital.com
40			* @license http://www.opensource.org/licenses/bsd-license.php BSD License
41			* @link http://code.ganbarodigital.com/php-operating-system
42			*/
43
44			namespace GanbaroDigital\OperatingSystem\IpRoute\Parsers;
45
46			use GanbaroDigital\ArrayTools\Filters\ExtractFirstItem;
47			use GanbaroDigital\ArrayTools\Parsers\ConvertKeyValuePairsToArray;
48			use GanbaroDigital\ArrayTools\ValueBuilders\ConvertToArray;
49			use GanbaroDigital\OperatingSystem\Exceptions\E4xx_CannotParseInetAddressLine;
50			use GanbaroDigital\OperatingSystem\Exceptions\E4xx_UnsupportedType;
51			use GanbaroDigital\OperatingSystem\IpRoute\Classifiers\ClassifyIpAddrLine;
52			use GanbaroDigital\OperatingSystem\NetInterfaces\Values\InetAddress;
53			use GanbaroDigital\Reflection\Maps\MapTypeToMethod;
54			use GanbaroDigital\Reflection\ValueBuilders\SimpleType;
55
56			class ParseInetAddress
57			{
58			/**
59			* parse an inet (IPv4) address block from the output of 'ip addr show'
60			*
61			* @param mixed $inetLines
62			* the line(s) to parse
63			* @return InetAddress
64			* the inet address defined in the output
65			*/
66			public function __invoke($inetLines)
67			{
68			return self::from($inetLines);
69			}
70
71			/**
72			* parse an inet (IPv4) address block from the output of 'ip addr show'
73			*
74			* @param mixed $inetLines
75			* the line(s) to parse
76			* @return InetAddress
77			* the inet address defined in the output
78			*/
79			public static function from($inetLines)
80			{
81			$method = MapTypeToMethod::using($inetLines, self::$dispatchMap);
82			return self::$method($inetLines);
83			}
84
85			/**
86			* a map of which types we support, and how to process them
87			* @var array
88			*/
89			private static $dispatchMap = [
90			"String" => "fromString",
91			"Traversable" => "fromTraversable",
92			];
93
94			/**
95			* called when we've been given a data type that we do not support
96			*
97			* @param mixed $output
98			* the unsupported data
99			* @return void
100			* @throws E4xx_UnsupportedType
101			*/
102			private static function nothingMatchesTheInputType($output)
103			{
104			throw new E4xx_UnsupportedType(SimpleType::from($output));
105			}
106
107			/**
108			* parse an inet (IPv4) address block from the output of 'ip addr show'
109			*
110			* @param string $inetLines
111			* the line(s) to parse
112			* @return InetAddress
113			* the inet address defined in the output
114			*/
115			private static function fromString($inetLines)
116			{
117			$lines = explode("\n", $inetLines);
118			return self::fromTraversable($lines);
119			}
120
121			/**
122			* parse an inet (IPv4) address block from the output of 'ip addr show'
123			*
124			* @param array\|Traversable $inetLines
125			* the line(s) to parse
126			* @return InetAddress
127			* the inet address defined in the output
128			*/
129			private static function fromTraversable($inetLines)
130			{
131			// we want a real PHP array for this
132			$inetLines = ConvertToArray::from($inetLines);
133
134			// line 0 is the inet line itself
135			$inetDetails = self::parseFirstLine(array_shift($inetLines));
136
137			// if there is a line 1, it contains additional flags
138			while (!empty($inetLines)) {
139			$inetDetails['properties'] = array_merge(self::parseSecondLine(array_shift($inetLines)), $inetDetails['properties']);
140			}
141
142			// now to convert this into an InetAddress value
143			$retval = new InetAddress(
144			$inetDetails['address'],
145			$inetDetails['netmask'],
146			$inetDetails['broadcast'],
147			$inetDetails['scope'],
148			$inetDetails['addressLabel'],
149			$inetDetails['linkDevice'],
150			$inetDetails['properties']
151			);
152
153			// all done
154			return $retval;
155			}
156
157			/**
158			* extract data from the first line of the inet address definition
159			*
160			* @param string $line
161			* the line to parse
162			* @return array
163			* the extracted data
164			*/
165			private static function parseFirstLine($line)
166			{
167			// this regex will parse everything we know to expect from the first
168			// line of an inet definition
169			$regex = "~inet (?<addr>[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3})(?<netmask>/[0-9]{1,3})( brd (?<broadcast>[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3})){0,1}( scope (?<scope>[a-z]+)){0,1}( (?<addressLabel>secondary\|dynamic\|deprecated\|tentative)){0,1}( (?<linkDevice>.*)){0,1}$~";
170			$matches = [];
171			if (!preg_match_all($regex, $line, $matches)) {
172			throw new E4xx_CannotParseInetAddressLine($line);
173			}
174
175			return [
176			'address' => $matches['addr'][0],
177			'netmask' => $matches['netmask'][0],
178			'broadcast' => ExtractFirstItem::from($matches['broadcast'], null),
179			'scope' => ExtractFirstItem::from($matches['scope'], null),
180			'addressLabel' => ExtractFirstItem::from($matches['addressLabel'], null),
181			'linkDevice' => ExtractFirstItem::from($matches['linkDevice'], null),
182			'properties' => [],
183			];
184			}
185
186			/**
187			* extract data from the second line of the inet address definition
188			*
189			* @param string $line
190			* the line to parse
191			* @return array
192			* the extracted data, as key/value pairs
193			*/
194			private static function parseSecondLine($line)
195			{
196			return ConvertKeyValuePairsToArray::from($line, ' ', ' ');
197			}
198			}
199

ganbarodigital / php-operating-system

Push — develop ( a3c683...8c914c )

ParseInetAddress::from() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like