Parser::parse() - Code Metrics - Inspection of "v5.0" - raulferras/PHP-po-parser - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#68)

by Raúl

created 2018-02-02 18:30 UTC

Parser::parse() F

↳ Parent: Parser

Complexity

Conditions	48
Paths	15874

Size

Total Lines	238
Code Lines	143

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	238
rs	2
c	0
b	0
f	0
cc	48
eloc	143
nc	15874
nop	0

How to fix Long Method Complexity

<?php

namespace Sepia\PoParser;

use Sepia\PoParser\Catalog\EntryFactory;
use Sepia\PoParser\PoReader\FileHandler;
use Sepia\PoParser\PoReader\SourceHandler;
use Sepia\PoParser\PoReader\StringHandler;

/**
 *    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;

    /**
     * Reads and parses a string
     *
     * @param string $string po content
     *
     * @throws \Exception.
     * @return Parser
     */
    public static function parseString($string)
    {
        $parser = new Parser(new StringHandler($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 FileHandler($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
     * @return Catalog
     */
    public function parse()
    {
        $catalog = new Catalog();
        $entry = array();

        // A new entry has been just inserted.
        $justNewEntry = false;
        $firstLine = true;

        // Used to remember last key in a multiline previous entry.
        $lastPreviousKey = null;
        $state = null;
        $lineNumber = 0;

        while (!$this->sourceHandler->ended()) {
            $line = trim($this->sourceHandler->getNextLine());
            $split = preg_split('/\s+/ ', $line, 2);
            $key = $split[0];

            // If a blank line is found, or a new msgid when already got one
            if ($line === '' || ($key === 'msgid' && isset($entry['msgid']))) {
                // Two consecutive blank lines
                if ($justNewEntry) {
                    $lineNumber++;
                    continue;
                }

                if ($firstLine) {
                    $firstLine = false;
                    if (self::isHeader($entry)) {
                        $catalog->addHeaders(array_filter(explode('\\n', $entry['msgstr'])));
                    } else {
                        $catalog->addEntry(EntryFactory::createFromArray($entry));
                    }
                } else {
                    // A new entry is found!
                    $catalog->addEntry(EntryFactory::createFromArray($entry));
                }

                $entry = array();
                $state = null;
                $justNewEntry = true;
                $lastPreviousKey = null;
                if ($line === '') {
                    $lineNumber++;
                    continue;
                }
            }

            $justNewEntry = false; // ?
            $data = isset($split[1]) ? $split[1] : null;

            switch ($key) {
                // Flagged translation
                case '#,':
                    $entry['flags'] = preg_split('/,\s*/', $data);
                    break;

                // # Translator comments
                case '#':
                    $entry['tcomment'] = !isset($entry['tcomment']) ? array() : $entry['tcomment'];
                    $entry['tcomment'][] = $data;
                    break;

                // #. Comments extracted from source code
                case '#.':
                    $entry['ccomment'] = !isset($entry['ccomment']) ? array() : $entry['ccomment'];
                    $entry['ccomment'][] = $data;
                    break;

                // Reference
                case '#:':
                    $entry['reference'][] = addslashes($data);
                    break;


                case '#|':      // #| Previous untranslated string
                case '#~':      // #~ Old entry
                case '#~|':     // #~| Previous-Old untranslated string. Reported by @Cellard
                    switch ($key) {
                        case '#|':
                            $key = 'previous';
                            break;
                        case '#~':
                            $key = 'obsolete';
                            break;
                        case '#~|':
                            $key = 'previous-obsolete';
                            break;
                    }

                    $tmpParts = explode(' ', $data);
                    $tmpKey = $tmpParts[0];

                    if (!in_array($tmpKey, array('msgid', 'msgid_plural', 'msgstr', 'msgctxt'), true)) {
                        // If there is a multi-line previous string we must remember
                        // what key was first line.
                        $tmpKey = $lastPreviousKey;
                        $str = $data;
                    } else {
                        $str = implode(' ', array_slice($tmpParts, 1));
                    }

                    //array('obsolete' => true, 'msgid' => '', 'msgstr' => '');

                    if (strpos($key, 'obsolete') !== false) {
                        $entry['obsolete'] = true;
                        switch ($tmpKey) {
                            case 'msgid':
                                if (!isset($entry['msgid'])) {
                                    $entry['msgid'] = '';
                                }
                                $entry['msgid'].= trim($str, '"');
                                $lastPreviousKey = $tmpKey;
                                break;

                            case 'msgstr':
                                if (!isset($entry['msgstr'])) {
                                    $entry['msgstr'] = '';
                                }
                                $entry['msgstr'].= trim($str, '"');
                                $lastPreviousKey = $tmpKey;
                                break;

                            case 'msgctxt':
                                $entry['msgctxt'] = trim($str, '"');
                                $lastPreviousKey = $tmpKey;
                                break;

                            default:
                                break;
                        }
                    } else {
                        $entry[$key] = isset($entry[$key]) ? $entry[$key] : array('msgid' => '', 'msgstr' => '');
                    }

                    if ($key !== 'obsolete') {
                        switch ($tmpKey) {
                            case 'msgid':
                            case 'msgid_plural':
                            case 'msgstr':
                                $entry[$key][$tmpKey] = trim($str, '"');
                                $lastPreviousKey = $tmpKey;
                                break;

                            default:
                                $entry[$key][$tmpKey] = $str;
                                break;
                        }
                    }
                    break;


                // context
                // Allows disambiguations of different messages that have same msgid.
                // Example:
                //
                // #: tools/observinglist.cpp:700
                // msgctxt "First letter in 'Scope'"
                // msgid "S"
                // msgstr ""
                //
                // #: skycomponents/horizoncomponent.cpp:429
                // msgctxt "South"
                // msgid "S"
                // msgstr ""
                case 'msgctxt':
                    // untranslated-string
                case 'msgid':
                    // untranslated-string-plural
                case 'msgid_plural':
                    $state = $key;
                    if (!isset($entry[$state])) {
                        $entry[$state] = '';
                    }

                    $entry[$state] .= trim($data, '"');
                    break;
                // translated-string
                case 'msgstr':
                    $state = 'msgstr';
                    $entry[$state] = trim($data, '"');
                    break;

                default:
                    if (strpos($key, 'msgstr[') !== false) {
                        // translated-string-case-n
                        $state = $key;
                        $entry[$state] = trim($data, '"');
                    } else {
                        // "multiline" lines
                        switch ($state) {
                            case 'msgctxt':
                            case 'msgid':
                            case 'msgid_plural':
                            case (strpos($state, 'msgstr[') !== false):
                                if (!isset($entry[$state])) {
                                    $entry[$state] = '';
                                }

                                if (is_string($entry[$state])) {
                                    // Convert it to array
                                    //$entry[$state] = array($entry[$state]);
                                    $entry[$state] = trim($entry[$state], '"');
                                }
                                $entry[$state] .= trim($line, '"');
                                break;

                            case 'msgstr':
                                // Special fix where msgid is ""
                                $entry['msgstr'] .= trim($line, '"');
                                /*if ($entry['msgid'] === "\"\"") {
                                    $entry['msgstr'].= trim($line, '"');
                                } else {
                                    $entry['msgstr'].= $line;
                                }*/
                                break;

                            default:
                                throw new \Exception(
                                    'Parser: Parse error! Unknown key "'.$key.'" on line '.($lineNumber + 1)
                                );
                        }
                    }
                    break;
            }

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

        // add final entry
        if ($state === 'msgstr') {
            $catalog->addEntry(EntryFactory::createFromArray($entry));
        }

        return $catalog;
    }


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

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

        $headerItems = 0;
        $lines = explode("\\n", $entry['msgstr']);

        foreach ($lines as $str) {
            $tokens = explode(':', $str);
            $tokens[0] = trim($tokens[0], '"').':';

            if (in_array($tokens[0], $keys, true)) {
                $headerItems++;
                unset($headerKeys[$tokens[0]]);
                $keys = array_keys($headerKeys);
            }
        }

        return $headerItems === $count;
    }
}


1			<?php
2
3			namespace Sepia\PoParser;
4
5			use Sepia\PoParser\Catalog\EntryFactory;
6			use Sepia\PoParser\PoReader\FileHandler;
7			use Sepia\PoParser\PoReader\SourceHandler;
8			use Sepia\PoParser\PoReader\StringHandler;
9
10			/**
11			* Copyright (c) 2012 Raúl Ferràs [email protected]
12			* All rights reserved.
13			*
14			* Redistribution and use in source and binary forms, with or without
15			* modification, are permitted provided that the following conditions
16			* are met:
17			* 1. Redistributions of source code must retain the above copyright
18			* notice, this list of conditions and the following disclaimer.
19			* 2. Redistributions in binary form must reproduce the above copyright
20			* notice, this list of conditions and the following disclaimer in the
21			* documentation and/or other materials provided with the distribution.
22			* 3. Neither the name of copyright holders nor the names of its
23			* contributors may be used to endorse or promote products derived
24			* from this software without specific prior written permission.
25			*
26			* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
27			* ''AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
28			* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29			* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS OR CONTRIBUTORS
30			* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
31			* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
32			* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
33			* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
34			* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
35			* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36			* POSSIBILITY OF SUCH DAMAGE.
37			*
38			* https://github.com/raulferras/PHP-po-parser
39			*
40			* Class to parse .po file and extract its strings.
41			*
42			* @version 5.0
43			*/
44			class Parser
45			{
46			/** @var SourceHandler */
47			protected $sourceHandler;
48
49			/**
50			* Reads and parses a string
51			*
52			* @param string $string po content
53			*
54			* @throws \Exception.
55			* @return Parser
56			*/
57			public static function parseString($string)
58			{
59			$parser = new Parser(new StringHandler($string));
60			$parser->parse();
61
62			return $parser;
63			}
64
65			/**
66			* Reads and parses a file
67			*
68			* @param string $filePath
69			*
70			* @throws \Exception.
71			* @return Catalog
72			*/
73			public static function parseFile($filePath)
74			{
75			$parser = new Parser(new FileHandler($filePath));
76
77			return $parser->parse();
78			}
79
80			public function __construct(SourceHandler $sourceHandler)
81			{
82			$this->sourceHandler = $sourceHandler;
83			}
84
85			/**
86			* Reads and parses strings of a .po file.
87			*
88			* @param SourceHandler . Optional
89			*
90			* @throws \Exception, \InvalidArgumentException
91			* @return Catalog
92			*/
93			public function parse()
94			{
95			$catalog = new Catalog();
96			$entry = array();
97
98			// A new entry has been just inserted.
99			$justNewEntry = false;
100			$firstLine = true;
101
102			// Used to remember last key in a multiline previous entry.
103			$lastPreviousKey = null;
104			$state = null;
105			$lineNumber = 0;
106
107			while (!$this->sourceHandler->ended()) {
108			$line = trim($this->sourceHandler->getNextLine());
109			$split = preg_split('/\s+/ ', $line, 2);
110			$key = $split[0];
111
112			// If a blank line is found, or a new msgid when already got one
113			if ($line === '' \|\| ($key === 'msgid' && isset($entry['msgid']))) {
114			// Two consecutive blank lines
115			if ($justNewEntry) {
116			$lineNumber++;
117			continue;
118			}
119
120			if ($firstLine) {
121			$firstLine = false;
122			if (self::isHeader($entry)) {
123			$catalog->addHeaders(array_filter(explode('\\n', $entry['msgstr'])));
124			} else {
125			$catalog->addEntry(EntryFactory::createFromArray($entry));
126			}
127			} else {
128			// A new entry is found!
129			$catalog->addEntry(EntryFactory::createFromArray($entry));
130			}
131
132			$entry = array();
133			$state = null;
134			$justNewEntry = true;
135			$lastPreviousKey = null;
136			if ($line === '') {
137			$lineNumber++;
138			continue;
139			}
140			}
141
142			$justNewEntry = false; // ?
143			$data = isset($split[1]) ? $split[1] : null;
144
145			switch ($key) {
146			// Flagged translation
147			case '#,':
148			$entry['flags'] = preg_split('/,\s*/', $data);
149			break;
150
151			// # Translator comments
152			case '#':
153			$entry['tcomment'] = !isset($entry['tcomment']) ? array() : $entry['tcomment'];
154			$entry['tcomment'][] = $data;
155			break;
156
157			// #. Comments extracted from source code
158			case '#.':
159			$entry['ccomment'] = !isset($entry['ccomment']) ? array() : $entry['ccomment'];
160			$entry['ccomment'][] = $data;
161			break;
162
163			// Reference
164			case '#:':
165			$entry['reference'][] = addslashes($data);
166			break;
167
168
169			case '#\|': // #\| Previous untranslated string
170			case '#~': // #~ Old entry
171			case '#~\|': // #~\| Previous-Old untranslated string. Reported by @Cellard
172			switch ($key) {
173			case '#\|':
174			$key = 'previous';
175			break;
176			case '#~':
177			$key = 'obsolete';
178			break;
179			case '#~\|':
180			$key = 'previous-obsolete';
181			break;
182			}
183
184			$tmpParts = explode(' ', $data);
185			$tmpKey = $tmpParts[0];
186
187			if (!in_array($tmpKey, array('msgid', 'msgid_plural', 'msgstr', 'msgctxt'), true)) {
188			// If there is a multi-line previous string we must remember
189			// what key was first line.
190			$tmpKey = $lastPreviousKey;
191			$str = $data;
192			} else {
193			$str = implode(' ', array_slice($tmpParts, 1));
194			}
195
196			//array('obsolete' => true, 'msgid' => '', 'msgstr' => '');
197
198			if (strpos($key, 'obsolete') !== false) {
199			$entry['obsolete'] = true;
200			switch ($tmpKey) {
201			case 'msgid':
202			if (!isset($entry['msgid'])) {
203			$entry['msgid'] = '';
204			}
205			$entry['msgid'].= trim($str, '"');
206			$lastPreviousKey = $tmpKey;
207			break;
208
209			case 'msgstr':
210			if (!isset($entry['msgstr'])) {
211			$entry['msgstr'] = '';
212			}
213			$entry['msgstr'].= trim($str, '"');
214			$lastPreviousKey = $tmpKey;
215			break;
216
217			case 'msgctxt':
218			$entry['msgctxt'] = trim($str, '"');
219			$lastPreviousKey = $tmpKey;
220			break;
221
222			default:
223			break;
224			}
225			} else {
226			$entry[$key] = isset($entry[$key]) ? $entry[$key] : array('msgid' => '', 'msgstr' => '');
227			}
228
229			if ($key !== 'obsolete') {
230			switch ($tmpKey) {
231			case 'msgid':
232			case 'msgid_plural':
233			case 'msgstr':
234			$entry[$key][$tmpKey] = trim($str, '"');
235			$lastPreviousKey = $tmpKey;
236			break;
237
238			default:
239			$entry[$key][$tmpKey] = $str;
240			break;
241			}
242			}
243			break;
244
245
246			// context
247			// Allows disambiguations of different messages that have same msgid.
248			// Example:
249			//
250			// #: tools/observinglist.cpp:700
251			// msgctxt "First letter in 'Scope'"
252			// msgid "S"
253			// msgstr ""
254			//
255			// #: skycomponents/horizoncomponent.cpp:429
256			// msgctxt "South"
257			// msgid "S"
258			// msgstr ""
259			case 'msgctxt':
260			// untranslated-string
261			case 'msgid':
262			// untranslated-string-plural
263			case 'msgid_plural':
264			$state = $key;
265			if (!isset($entry[$state])) {
266			$entry[$state] = '';
267			}
268
269			$entry[$state] .= trim($data, '"');
270			break;
271			// translated-string
272			case 'msgstr':
273			$state = 'msgstr';
274			$entry[$state] = trim($data, '"');
275			break;
276
277			default:
278			if (strpos($key, 'msgstr[') !== false) {
279			// translated-string-case-n
280			$state = $key;
281			$entry[$state] = trim($data, '"');
282			} else {
283			// "multiline" lines
284			switch ($state) {
285			case 'msgctxt':
286			case 'msgid':
287			case 'msgid_plural':
288			case (strpos($state, 'msgstr[') !== false):
289			if (!isset($entry[$state])) {
290			$entry[$state] = '';
291			}
292
293			if (is_string($entry[$state])) {
294			// Convert it to array
295			//$entry[$state] = array($entry[$state]);
296			$entry[$state] = trim($entry[$state], '"');
297			}
298			$entry[$state] .= trim($line, '"');
299			break;
300
301			case 'msgstr':
302			// Special fix where msgid is ""
303			$entry['msgstr'] .= trim($line, '"');
304			/*if ($entry['msgid'] === "\"\"") {
305			$entry['msgstr'].= trim($line, '"');
306			} else {
307			$entry['msgstr'].= $line;
308			}*/
309			break;
310
311			default:
312			throw new \Exception(
313			'Parser: Parse error! Unknown key "'.$key.'" on line '.($lineNumber + 1)
314			);
315			}
316			}
317			break;
318			}
319
320			$lineNumber++;
321			}
322			$this->sourceHandler->close();
323
324			// add final entry
325			if ($state === 'msgstr') {
326			$catalog->addEntry(EntryFactory::createFromArray($entry));
327			}
328
329			return $catalog;
330			}
331
332
333			/**
334			* Checks if entry is a header by
335			*
336			* @param array $entry
337			*
338			* @return bool
339			*/
340			protected static function isHeader(array $entry)
341			{
342			if (empty($entry) \|\| !isset($entry['msgstr'])) {
343			return false;
344			}
345
346			$headerKeys = array(
347			'Project-Id-Version:' => false,
348			// 'Report-Msgid-Bugs-To:' => false,
349			// 'POT-Creation-Date:' => false,
350			'PO-Revision-Date:' => false,
351			// 'Last-Translator:' => false,
352			// 'Language-Team:' => false,
353			'MIME-Version:' => false,
354			// 'Content-Type:' => false,
355			// 'Content-Transfer-Encoding:' => false,
356			// 'Plural-Forms:' => false
357			);
358			$count = count($headerKeys);
359			$keys = array_keys($headerKeys);
360
361			$headerItems = 0;
362			$lines = explode("\\n", $entry['msgstr']);
363
364			foreach ($lines as $str) {
365			$tokens = explode(':', $str);
366			$tokens[0] = trim($tokens[0], '"').':';
367
368			if (in_array($tokens[0], $keys, true)) {
369			$headerItems++;
370			unset($headerKeys[$tokens[0]]);
371			$keys = array_keys($headerKeys);
372			}
373			}
374
375			return $headerItems === $count;
376			}
377			}
378

raulferras / PHP-po-parser

Pull Request — master (#68)

Parser::parse() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like