Parser::parseMultiline() - Code Metrics - Inspection of "Fix parsing of obsolete entries." - raulferras/PHP-po-parser - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — feature/5.0.1 ( f2b49f...4d2f9f )

by Raúl

created 2018-02-03 20:11 UTC

Parser::parseMultiline() B

↳ Parent: Parser

Complexity

Conditions	6
Paths	6

Size

Total Lines	19
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	19
rs	8.8571
c	0
b	0
f	0
cc	6
eloc	13
nc	6
nop	2

<?php

namespace Sepia\PoParser;

use Sepia\PoParser\Catalog\EntryFactory;
use Sepia\PoParser\Exception\ParseException;
use Sepia\PoParser\SourceHandler\FileSystem;
use Sepia\PoParser\SourceHandler\SourceHandler;
use Sepia\PoParser\SourceHandler\StringSource;

/**
 *    Copyright (c) 2012 Raúl Ferràs [email protected]
 *    All rights reserved.
 *
 *    Redistribution and use in source and binary forms, with or without
 *    modification, are permitted provided that the following conditions
 *    are met:
 *    1. Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *    2. 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.
 *    3. Neither the name of copyright holders nor the names of its
 *       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 COPYRIGHT HOLDERS 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.
 *
 * https://github.com/raulferras/PHP-po-parser
 *
 * Class to parse .po file and extract its strings.
 *
 * @version 5.0
 */
class Parser
{
    /** @var SourceHandler */
    protected $sourceHandler;

    /** @var int */
    protected $lineNumber;

    /** @var string */
    protected $property;

    /**
     * Reads and parses a string
     *
     * @param string $string po content
     *
     * @throws \Exception.
     * @return Parser
     */
    public static function parseString($string)
    {
        $parser = new Parser(new StringSource($string));
        $parser->parse();

        return $parser;
    }

    /**
     * Reads and parses a file
     *
     * @param string $filePath
     *
     * @throws \Exception.
     * @return Catalog
     */
    public static function parseFile($filePath)
    {
        $parser = new Parser(new FileSystem($filePath));

        return $parser->parse();
    }

    public function __construct(SourceHandler $sourceHandler)
    {
        $this->sourceHandler = $sourceHandler;
    }

    /**
     * Reads and parses strings of a .po file.
     *
     * @param SourceHandler . Optional
     *
     * @throws \Exception, \InvalidArgumentException, ParseException
     * @return Catalog
     */
    public function parse()
    {
        $catalog = new Catalog();
        $this->lineNumber = 0;
        $entry = array();
        $this->mode = null;     // current mode
class MyClass { }

$x = new MyClass();
$x->foo = true;
        $this->property = null; // current property

        // Flags
        $headersFound = false;

        while (!$this->sourceHandler->ended()) {


            $line = trim($this->sourceHandler->getNextLine());

            if ($this->shouldIgnoreLine($line, $entry)) {
                $this->lineNumber++;
                continue;
            }

            if ($this->shouldCloseEntry($line, $entry)) {
                if (!$headersFound && $this->isHeader($entry)) {
                    $headersFound = true;
                    $catalog->addHeaders(
                        $this->parseHeaders($entry['msgstr'])
                    );
                } else {
                    $catalog->addEntry(EntryFactory::createFromArray($entry));
                }

                $entry = array();
                $this->property = null;

                if (empty($line)) {
                    $this->lineNumber++;
                    continue;
                }
            }

            $entry = $this->parseLine($line, $entry);

            $this->lineNumber++;
            continue;
        }
        $this->sourceHandler->close();

        // add final entry
        if (count($entry)) {
            $catalog->addEntry(EntryFactory::createFromArray($entry));
        }

        return $catalog;
    }

    /**
     * @param string $line
     * @param array  $entry
     *
     * @return array
     * @throws ParseException
     */
    protected function parseLine($line, $entry)
    {
        $firstChar = strlen($line) > 0 ? $line[0] : '';

        switch ($firstChar) {
            case '#':
                $entry = $this->parseComment($line, $entry);
                break;

            case 'm':
                $entry = $this->parseProperty($line, $entry);
                break;

            case '"':
                $entry = $this->parseMultiline($line, $entry);
                break;
        }

        return $entry;
    }

    /**
     * @param string $line
     * @param array  $entry
     *
     * @return array
     * @throws ParseException
     */
    protected function parseProperty($line, array $entry)
    {
        list($key, $value) = $this->getProperty($line);

        if (!isset($entry[$key])) {
            $entry[$key] = '';
        }

        switch (true) {
            case $key === 'msgctxt':
            case $key === 'msgid':
            case $key === 'msgid_plural':
            case $key === 'msgstr':
                $entry[$key] .= $this->unquote($value);
                $this->property = $key;
                break;

            case strpos($key, 'msgstr[') !== false:
                $entry[$key] .= $this->unquote($value);
                $this->property = $key;
                break;

            default:
                throw new ParseException(sprintf('Could not parse %s at line %d', $key, $this->lineNumber));
        }

        return $entry;
    }

    /**
     * @param string $line
     * @param array  $entry
     *
     * @return array
     * @throws ParseException
     */
    protected function parseMultiline($line, $entry)
    {
        switch (true) {
            case $this->property === 'msgctxt':
            case $this->property === 'msgid':
            case $this->property === 'msgid_plural':
            case $this->property === 'msgstr':
            case strpos($this->property, 'msgstr[') !== false:
                $entry[$this->property] .= $this->unquote($line);
                break;

            default:
                throw new ParseException(
                    sprintf('Error parsing property %s as multiline.', $this->property)
                );
        }

        return $entry;
    }

    /**
     * @param string $line
     * @param array  $entry
     *
     * @return array
     * @throws ParseException
     */
    protected function parseComment($line, $entry)
    {
        $comment = trim(substr($line, 0, 2));

        switch ($comment) {
            case '#,':
                $line = trim(substr($line, 2));
                $entry['flags'] = preg_split('/,\s*/', $line);
                break;

            case '#.':
                $entry['ccomment'] = !isset($entry['ccomment']) ? array() : $entry['ccomment'];
                $entry['ccomment'][] = trim(substr($line, 2));
                break;


            case '#|':  // Previous string
            case '#~':  // Old entry
            case '#~|': // Previous string old
                $mode = array(
                    '#|' => 'previous',
                    '#~' => 'obsolete',
                    '#~|' => 'previous-obsolete'
                );

                $line = trim(substr($line, 2));
                $property = $mode[$comment];
                if ($property === 'previous') {
                    if (!isset($entry[$property])) {
                        $subEntry = array();
                    } else {
                        $subEntry = $entry[$property];
                    }

                    $subEntry = $this->parseLine($line, $subEntry);
                    //$subEntry = $this->parseProperty($line, $subEntry);
                    $entry[$property] = $subEntry;
                } else {
                    $entry = $this->parseLine($line, $entry);
                    $entry['obsolete'] = true;
                }
                break;

            // Reference
            case '#:':
                $entry['reference'][] = trim(substr($line, 2));
                break;

            case '#':
            default:
                $entry['tcomment'] = !isset($entry['tcomment']) ? array() : $entry['tcomment'];
                $entry['tcomment'][] = trim(substr($line, 1));
                break;
        }

        return $entry;
    }

    /**
     * @param string $msgstr
     *
     * @return array
     */
    protected function parseHeaders($msgstr)
    {
        $headers = array_filter(explode('\\n', $msgstr));

        return $headers;
    }

    /**
     * @param string $line
     * @param array  $entry
     *
     * @return bool
     */
    protected function shouldIgnoreLine($line, array $entry)
    {
        return empty($line) && count($entry) === 0;
    }

    /**
     * @param string $line
     * @param array  $entry
     *
     * @return bool
     */
    protected function shouldCloseEntry($line, array $entry)
    {
        $tokens = $this->getProperty($line);
        $property = $tokens[0];

        return ($line === '' || ($property === 'msgid' && isset($entry['msgid'])));
    }

    /**
     * @param string $value
     * @return string
     */
    protected function unquote($value)
    {
        return preg_replace('/^\"|\"$/', '', $value);
    }

    /**
     * Checks if entry is a header by
     *
     * @param array $entry
     *
     * @return bool
     */
    protected function isHeader(array $entry)
    {
        if (empty($entry) || !isset($entry['msgstr'])) {
            return false;
        }

        if (!isset($entry['msgid']) || !empty($entry['msgid'])) {
            return false;
        }

        $standardHeaders = array(
            'Project-Id-Version:',
            'Report-Msgid-Bugs-To:',
            'POT-Creation-Date:',
            'PO-Revision-Date:',
            'Last-Translator:',
            'Language-Team:',
            'MIME-Version:',
            'Content-Type:',
            'Content-Transfer-Encoding:',
            'Plural-Forms:',
        );

        $headers = explode('\n', $entry['msgstr']);
        // Remove text after double colon
        $headers = array_map(
            function ($header) {
                $pattern = '/(.*?:)(.*)/i';
                $replace = '${1}';
                return preg_replace($pattern, $replace, $header);
            },
            $headers
        );

        if (count(array_intersect($standardHeaders, $headers)) > 0) {
            return true;
        }

        // If it does not contain any of the standard headers
        // Let's see if it contains any custom header.
        $customHeaders = array_filter(
            $headers,
            function ($header) {
                return preg_match('/^X\-(.*):/i', $header) === 1;
            }
        );

        return count($customHeaders) > 0;
    }

    /**
     * @param string $line
     *
     * @return array
     */
    protected function getProperty($line)
    {
        $tokens = preg_split('/\s+/ ', $line, 2);

        return $tokens;
    }
}


1			<?php
2
3			namespace Sepia\PoParser;
4
5			use Sepia\PoParser\Catalog\EntryFactory;
6			use Sepia\PoParser\Exception\ParseException;
7			use Sepia\PoParser\SourceHandler\FileSystem;
8			use Sepia\PoParser\SourceHandler\SourceHandler;
9			use Sepia\PoParser\SourceHandler\StringSource;
10
11			/**
12			* Copyright (c) 2012 Raúl Ferràs [email protected]
13			* All rights reserved.
14			*
15			* Redistribution and use in source and binary forms, with or without
16			* modification, are permitted provided that the following conditions
17			* are met:
18			* 1. Redistributions of source code must retain the above copyright
19			* notice, this list of conditions and the following disclaimer.
20			* 2. Redistributions in binary form must reproduce the above copyright
21			* notice, this list of conditions and the following disclaimer in the
22			* documentation and/or other materials provided with the distribution.
23			* 3. Neither the name of copyright holders nor the names of its
24			* contributors may be used to endorse or promote products derived
25			* from this software without specific prior written permission.
26			*
27			* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
28			* ''AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
29			* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
30			* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS OR CONTRIBUTORS
31			* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32			* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33			* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34			* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35			* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36			* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37			* POSSIBILITY OF SUCH DAMAGE.
38			*
39			* https://github.com/raulferras/PHP-po-parser
40			*
41			* Class to parse .po file and extract its strings.
42			*
43			* @version 5.0
44			*/
45			class Parser
46			{
47			/** @var SourceHandler */
48			protected $sourceHandler;
49
50			/** @var int */
51			protected $lineNumber;
52
53			/** @var string */
54			protected $property;
55
56			/**
57			* Reads and parses a string
58			*
59			* @param string $string po content
60			*
61			* @throws \Exception.
62			* @return Parser
63			*/
64			public static function parseString($string)
65			{
66			$parser = new Parser(new StringSource($string));
67			$parser->parse();
68
69			return $parser;
70			}
71
72			/**
73			* Reads and parses a file
74			*
75			* @param string $filePath
76			*
77			* @throws \Exception.
78			* @return Catalog
79			*/
80			public static function parseFile($filePath)
81			{
82			$parser = new Parser(new FileSystem($filePath));
83
84			return $parser->parse();
85			}
86
87			public function __construct(SourceHandler $sourceHandler)
88			{
89			$this->sourceHandler = $sourceHandler;
90			}
91
92			/**
93			* Reads and parses strings of a .po file.
94			*
95			* @param SourceHandler . Optional
96			*
97			* @throws \Exception, \InvalidArgumentException, ParseException
98			* @return Catalog
99			*/
100			public function parse()
101			{
102			$catalog = new Catalog();
103			$this->lineNumber = 0;
104			$entry = array();
105			$this->mode = null; // current mode
			0 ignored issues – show Bug introduced 2018-02-03 00:47 UTC by Report Bug Copy Issue Report The property `mode` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
106			$this->property = null; // current property
107
108			// Flags
109			$headersFound = false;
110
111			while (!$this->sourceHandler->ended()) {
			0 ignored issues – show Coding Style introduced 2018-02-03 00:47 UTC by Report Bug Copy Issue Report Blank line found at start of control structure Loading history...
112
113			$line = trim($this->sourceHandler->getNextLine());
114
115			if ($this->shouldIgnoreLine($line, $entry)) {
116			$this->lineNumber++;
117			continue;
118			}
119
120			if ($this->shouldCloseEntry($line, $entry)) {
121			if (!$headersFound && $this->isHeader($entry)) {
122			$headersFound = true;
123			$catalog->addHeaders(
124			$this->parseHeaders($entry['msgstr'])
125			);
126			} else {
127			$catalog->addEntry(EntryFactory::createFromArray($entry));
128			}
129
130			$entry = array();
131			$this->property = null;
132
133			if (empty($line)) {
134			$this->lineNumber++;
135			continue;
136			}
137			}
138
139			$entry = $this->parseLine($line, $entry);
140
141			$this->lineNumber++;
142			continue;
143			}
144			$this->sourceHandler->close();
145
146			// add final entry
147			if (count($entry)) {
148			$catalog->addEntry(EntryFactory::createFromArray($entry));
149			}
150
151			return $catalog;
152			}
153
154			/**
155			* @param string $line
156			* @param array $entry
157			*
158			* @return array
159			* @throws ParseException
160			*/
161			protected function parseLine($line, $entry)
162			{
163			$firstChar = strlen($line) > 0 ? $line[0] : '';
164
165			switch ($firstChar) {
166			case '#':
167			$entry = $this->parseComment($line, $entry);
168			break;
169
170			case 'm':
171			$entry = $this->parseProperty($line, $entry);
172			break;
173
174			case '"':
175			$entry = $this->parseMultiline($line, $entry);
176			break;
177			}
178
179			return $entry;
180			}
181
182			/**
183			* @param string $line
184			* @param array $entry
185			*
186			* @return array
187			* @throws ParseException
188			*/
189			protected function parseProperty($line, array $entry)
190			{
191			list($key, $value) = $this->getProperty($line);
192
193			if (!isset($entry[$key])) {
194			$entry[$key] = '';
195			}
196
197			switch (true) {
198			case $key === 'msgctxt':
199			case $key === 'msgid':
200			case $key === 'msgid_plural':
201			case $key === 'msgstr':
202			$entry[$key] .= $this->unquote($value);
203			$this->property = $key;
204			break;
205
206			case strpos($key, 'msgstr[') !== false:
207			$entry[$key] .= $this->unquote($value);
208			$this->property = $key;
209			break;
210
211			default:
212			throw new ParseException(sprintf('Could not parse %s at line %d', $key, $this->lineNumber));
213			}
214
215			return $entry;
216			}
217
218			/**
219			* @param string $line
220			* @param array $entry
221			*
222			* @return array
223			* @throws ParseException
224			*/
225			protected function parseMultiline($line, $entry)
226			{
227			switch (true) {
228			case $this->property === 'msgctxt':
229			case $this->property === 'msgid':
230			case $this->property === 'msgid_plural':
231			case $this->property === 'msgstr':
232			case strpos($this->property, 'msgstr[') !== false:
233			$entry[$this->property] .= $this->unquote($line);
234			break;
235
236			default:
237			throw new ParseException(
238			sprintf('Error parsing property %s as multiline.', $this->property)
239			);
240			}
241
242			return $entry;
243			}
244
245			/**
246			* @param string $line
247			* @param array $entry
248			*
249			* @return array
250			* @throws ParseException
251			*/
252			protected function parseComment($line, $entry)
253			{
254			$comment = trim(substr($line, 0, 2));
255
256			switch ($comment) {
257			case '#,':
258			$line = trim(substr($line, 2));
259			$entry['flags'] = preg_split('/,\s*/', $line);
260			break;
261
262			case '#.':
263			$entry['ccomment'] = !isset($entry['ccomment']) ? array() : $entry['ccomment'];
264			$entry['ccomment'][] = trim(substr($line, 2));
265			break;
266
267
268			case '#\|': // Previous string
269			case '#~': // Old entry
270			case '#~\|': // Previous string old
271			$mode = array(
272			'#\|' => 'previous',
273			'#~' => 'obsolete',
274			'#~\|' => 'previous-obsolete'
275			);
276
277			$line = trim(substr($line, 2));
278			$property = $mode[$comment];
279			if ($property === 'previous') {
280			if (!isset($entry[$property])) {
281			$subEntry = array();
282			} else {
283			$subEntry = $entry[$property];
284			}
285
286			$subEntry = $this->parseLine($line, $subEntry);
287			//$subEntry = $this->parseProperty($line, $subEntry);
288			$entry[$property] = $subEntry;
289			} else {
290			$entry = $this->parseLine($line, $entry);
291			$entry['obsolete'] = true;
292			}
293			break;
294
295			// Reference
296			case '#:':
297			$entry['reference'][] = trim(substr($line, 2));
298			break;
299
300			case '#':
301			default:
302			$entry['tcomment'] = !isset($entry['tcomment']) ? array() : $entry['tcomment'];
303			$entry['tcomment'][] = trim(substr($line, 1));
304			break;
305			}
306
307			return $entry;
308			}
309
310			/**
311			* @param string $msgstr
312			*
313			* @return array
314			*/
315			protected function parseHeaders($msgstr)
316			{
317			$headers = array_filter(explode('\\n', $msgstr));
318
319			return $headers;
320			}
321
322			/**
323			* @param string $line
324			* @param array $entry
325			*
326			* @return bool
327			*/
328			protected function shouldIgnoreLine($line, array $entry)
329			{
330			return empty($line) && count($entry) === 0;
331			}
332
333			/**
334			* @param string $line
335			* @param array $entry
336			*
337			* @return bool
338			*/
339			protected function shouldCloseEntry($line, array $entry)
340			{
341			$tokens = $this->getProperty($line);
342			$property = $tokens[0];
343
344			return ($line === '' \|\| ($property === 'msgid' && isset($entry['msgid'])));
345			}
346
347			/**
348			* @param string $value
349			* @return string
350			*/
351			protected function unquote($value)
352			{
353			return preg_replace('/^\"\|\"$/', '', $value);
354			}
355
356			/**
357			* Checks if entry is a header by
358			*
359			* @param array $entry
360			*
361			* @return bool
362			*/
363			protected function isHeader(array $entry)
364			{
365			if (empty($entry) \|\| !isset($entry['msgstr'])) {
366			return false;
367			}
368
369			if (!isset($entry['msgid']) \|\| !empty($entry['msgid'])) {
370			return false;
371			}
372
373			$standardHeaders = array(
374			'Project-Id-Version:',
375			'Report-Msgid-Bugs-To:',
376			'POT-Creation-Date:',
377			'PO-Revision-Date:',
378			'Last-Translator:',
379			'Language-Team:',
380			'MIME-Version:',
381			'Content-Type:',
382			'Content-Transfer-Encoding:',
383			'Plural-Forms:',
384			);
385
386			$headers = explode('\n', $entry['msgstr']);
387			// Remove text after double colon
388			$headers = array_map(
389			function ($header) {
390			$pattern = '/(.?:)(.)/i';
391			$replace = '${1}';
392			return preg_replace($pattern, $replace, $header);
393			},
394			$headers
395			);
396
397			if (count(array_intersect($standardHeaders, $headers)) > 0) {
398			return true;
399			}
400
401			// If it does not contain any of the standard headers
402			// Let's see if it contains any custom header.
403			$customHeaders = array_filter(
404			$headers,
405			function ($header) {
406			return preg_match('/^X\-(.*):/i', $header) === 1;
407			}
408			);
409
410			return count($customHeaders) > 0;
411			}
412
413			/**
414			* @param string $line
415			*
416			* @return array
417			*/
418			protected function getProperty($line)
419			{
420			$tokens = preg_split('/\s+/ ', $line, 2);
421
422			return $tokens;
423			}
424			}
425

raulferras / PHP-po-parser

Push — feature/5.0.1 ( f2b49f...4d2f9f )

Parser::parseMultiline() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like