LingoParser::__construct() - Code Metrics - Inspection of "Fix integration tests" - wikimedia/mediawiki-extensions-Lingo - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 841b7d...3ed1d3 )

unknown

created 2018-03-24 00:44 UTC

LingoParser::__construct() A

↳ Parent: LingoParser

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes

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

<?php

/**
 * File holding the Lingo\LingoParser class.
 *
 * This file is part of the MediaWiki extension Lingo.
 *
 * @copyright 2011 - 2018, Stephan Gambke
 * @license   GNU General Public License, version 2 (or any later version)
 *
 * The Lingo extension is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option) any
 * later version.
 *
 * The Lingo extension is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 * @author Stephan Gambke
 *
 * @file
 * @ingroup Lingo
 */
namespace Lingo;

use DOMDocument;
use DOMXPath;
use ObjectCache;
use Parser;
use Title;

/**
 * This class parses the given text and enriches it with definitions for defined
 * terms.
 *
 * Contains a static function to initiate the parsing.
 *
 * @ingroup Lingo
 */
class LingoParser {

	const WORD_VALUE = 0;
	const WORD_OFFSET = 1;

	private $mLingoTree = null;

	/**
	 * @var Backend
	 */
	private $mLingoBackend = null;
	private static $parserSingleton = null;

	// The RegEx to split a chunk of text into words
	public $regex = null;

	/**
	 * Lingo\LingoParser constructor.
	 * @param MessageLog|null $messages
	 */
	public function __construct( MessageLog &$messages = null ) {

		// The RegEx to split a chunk of text into words
		// Words are: placeholders for stripped items, sequences of letters and numbers, single characters that are neither letter nor number
		$this->regex = '/' . preg_quote( Parser::MARKER_PREFIX, '/' ) . '.*?' . preg_quote( Parser::MARKER_SUFFIX, '/' ) . '|[\p{L}\p{N}]+|[^\p{L}\p{N}]/u';
	}

	/**
	 * @return Boolean
	 */
	public function parse( /*$content, $title, $po */ ) {
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

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

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}

		/** @var \Parser $parser */
		$parser = $GLOBALS[ 'wgParser' ];

		if ( $this->shouldParse( $parser ) ) {
			$this->realParse( $parser );
		}

		return true;
	}

	/**
	 * @return LingoParser
	 * @since 2.0.1
	 */
	public static function getInstance() {
		if ( !self::$parserSingleton ) {
			self::$parserSingleton = new LingoParser();

		}

		return self::$parserSingleton;
	}

	/**
	 * @return string
	 */
	private function getCacheKey() {
		// FIXME: If Lingo ever stores the glossary tree per user, then the cache key also needs to include the user id (see T163608)

		return ObjectCache::getLocalClusterInstance()->makeKey( 'ext', 'lingo', 'lingotree', Tree::TREE_VERSION, get_class( self::getInstance()->getBackend() ) );
	}

	/**
	 * @return Backend the backend used by the parser
	 * @throws \MWException
	 */
	public function getBackend() {

		if ( $this->mLingoBackend === null ) {
			throw new \MWException( 'No Lingo backend available!' );
		}

		return $this->mLingoBackend;
	}

	/**
	 * Returns the list of terms in the glossary
	 *
	 * @return array an array mapping terms (keys) to descriptions (values)
	 */
	public function getLingoArray() {
		return $this->getLingoTree()->getTermList();
	}

	/**
	 * Returns the list of terms in the glossary as a Lingo\Tree
	 *
	 * @return Tree a Lingo\Tree mapping terms (keys) to descriptions (values)
	 */
	public function getLingoTree() {

		// build glossary array only once per request
		if ( !$this->mLingoTree ) {

			// use cache if enabled
			if ( $this->mLingoBackend->useCache() ) {

				// Try cache first
				global $wgexLingoCacheType;
function myFunction($a, $b) {
    // Do something
}
				$cache = ( $wgexLingoCacheType !== null ) ? wfGetCache( $wgexLingoCacheType ) : wfGetMainCache();
				$cachekey = $this->getCacheKey();
				$cachedLingoTree = $cache->get( $cachekey );

				// cache hit?
				if ( $cachedLingoTree !== false && $cachedLingoTree !== null ) {

					wfDebug( "Cache hit: Got lingo tree from cache.\n" );
					$this->mLingoTree = &$cachedLingoTree;

					wfDebug( "Re-cached lingo tree.\n" );
				} else {

					wfDebug( "Cache miss: Lingo tree not found in cache.\n" );
					$this->mLingoTree =& $this->buildLingo();
					wfDebug( "Cached lingo tree.\n" );
				}

				// Keep for one month
				// Limiting the cache validity will allow to purge stale cache
				// entries inserted by older versions after one month
				$cache->set( $cachekey, $this->mLingoTree, 60 * 60 * 24 * 30 );

			} else {
				wfDebug( "Caching of lingo tree disabled.\n" );
				$this->mLingoTree =& $this->buildLingo();
			}

		}

		return $this->mLingoTree;
	}

	/**
	 * @return Tree
	 */
	protected function &buildLingo() {

		$lingoTree = new Tree();
		$backend = &$this->mLingoBackend;

		// assemble the result array
		while ( $elementData = $backend->next() ) {
			$lingoTree->addTerm( $elementData[ Element::ELEMENT_TERM ], $elementData );
		}

		return $lingoTree;
	}

	/**
	 * Parses the given text and enriches applicable terms
	 *
	 * This method currently only recognizes terms consisting of max one word
	 *
	 * @param Parser $parser
	 *
	 * @return Boolean
	 */
	protected function realParse( &$parser ) {

		$text = $parser->getOutput()->getText();

		if ( $text === null || $text === '' ) {
			return true;
		}

		// Get array of terms
		$glossary = $this->getLingoTree();

		if ( $glossary == null ) {
			return true;
		}

		// Parse HTML from page
		\MediaWiki\suppressWarnings();

		$doc = new DOMDocument( '1.0', 'utf-8' );
		$doc->loadHTML( '<html><head><meta http-equiv="content-type" content="charset=utf-8"/></head><body>' . $text . '</body></html>' );

		\MediaWiki\restoreWarnings();

		// Find all text in HTML.
		$xpath = new DOMXPath( $doc );
		$textElements = $xpath->query(
			"//*[not(ancestor-or-self::*[@class='noglossary'] or ancestor-or-self::a)][text()!=' ']/text()"
		);

		// Iterate all HTML text matches
		$numberOfTextElements = $textElements->length;

		$definitions = [];

		for ( $textElementIndex = 0; $textElementIndex < $numberOfTextElements; $textElementIndex++ ) {
			$textElement = $textElements->item( $textElementIndex );

			if ( strlen( $textElement->nodeValue ) < $glossary->getMinTermLength() ) {
				continue;
			}

			$matches = [];
			preg_match_all(
				$this->regex,
				$textElement->nodeValue,
				$matches,
				PREG_OFFSET_CAPTURE | PREG_PATTERN_ORDER
			);

			if ( count( $matches ) === 0 || count( $matches[ 0 ] ) === 0 ) {
				continue;
			}

			$wordDescriptors = &$matches[ 0 ];  // See __construct() for definition of "word"
			$numberOfWordDescriptors = count( $wordDescriptors );

			$parentNode = &$textElement->parentNode;

			$wordDescriptorIndex = 0;
			$changedElem = false;

			while ( $wordDescriptorIndex < $numberOfWordDescriptors ) {

				/** @var \Lingo\Element $definition */
				list( $skippedWords, $usedWords, $definition ) =
					$glossary->findNextTerm( $wordDescriptors, $wordDescriptorIndex, $numberOfWordDescriptors );

				if ( $usedWords > 0 ) { // found a term

					if ( $skippedWords > 0 ) { // skipped some text, insert it as is

						$start = $wordDescriptors[$wordDescriptorIndex][self::WORD_OFFSET];
						$length = $wordDescriptors[$wordDescriptorIndex + $skippedWords][self::WORD_OFFSET] - $start;

						$parentNode->insertBefore(
							$doc->createTextNode(
								substr( $textElement->nodeValue, $start, $length)
							),
							$textElement
						);
					}

					$parentNode->insertBefore( $definition->getFormattedTerm( $doc ), $textElement );

					$definitions[ $definition->getId() ] = $definition->getFormattedDefinitions();

					$changedElem = true;

				} else { // did not find any term, just use the rest of the text

					// If we found no term now and no term before, there was no
					// term in the whole element. Might as well not change the
					// element at all.

					// Only change element if found term before
					if ( $changedElem === true ) {

						$start = $wordDescriptors[$wordDescriptorIndex][self::WORD_OFFSET];

						$parentNode->insertBefore(
							$doc->createTextNode(
								substr( $textElement->nodeValue, $start)
							),
							$textElement
						);

					}

					// In principle superfluous, the loop would run out anyway. Might save a bit of time.
					break;
				}

				$wordDescriptorIndex += $usedWords + $skippedWords;
			}

			if ( $changedElem ) {
				$parentNode->removeChild( $textElement );
			}
		}

		if ( count( $definitions ) > 0 ) {

			$this->loadModules( $parser );

			// U - Ungreedy, D - dollar matches only end of string, s - dot matches newlines
			$text = preg_replace( '%(^.*<body>)|(</body>.*$)%UDs', '', $doc->saveHTML() );
			$text .= $parser->recursiveTagParseFully( join( $definitions ) );

			$parser->getOutput()->setText( $text );
		}

		return true;
	}

	/**
	 * @param Parser $parser
	 */
	protected function loadModules( &$parser ) {
		global $wgOut;
function myFunction($a, $b) {
    // Do something
}

		$parserOutput = $parser->getOutput();

		// load scripts
		$parserOutput->addModules( 'ext.Lingo.Scripts' );

		if ( !$wgOut->isArticle() ) {
			$wgOut->addModules( 'ext.Lingo.Scripts' );
		}

		// load styles
		$parserOutput->addModuleStyles( 'ext.Lingo.Styles' );

		if ( !$wgOut->isArticle() ) {
			$wgOut->addModuleStyles( 'ext.Lingo.Styles' );
		}
	}

	/**
	 * Purges the lingo tree from the cache.
	 *
	 * @deprecated 2.0.2
	 */
	public static function purgeCache() {

		self::getInstance()->purgeGlossaryFromCache();
	}

	/**
	 * Purges the lingo tree from the cache.
	 *
	 * @since 2.0.2
	 */
	public function purgeGlossaryFromCache() {

		global $wgexLingoCacheType;
function myFunction($a, $b) {
    // Do something
}
		$cache = ( $wgexLingoCacheType !== null ) ? wfGetCache( $wgexLingoCacheType ) : wfGetMainCache();
		$cache->delete( $this->getCacheKey() );
	}

	/**
	 * @since 2.0.1
	 * @param Backend $backend
	 */
	public function setBackend( Backend $backend ) {
		$this->mLingoBackend = $backend;
		$backend->setLingoParser( $this );
	}

	/**
	 * @param Parser $parser
	 * @return bool
	 */
	protected function shouldParse( &$parser ) {
		global $wgexLingoUseNamespaces;
function myFunction($a, $b) {
    // Do something
}

		if ( !( $parser instanceof Parser ) ) {

			return false;
		}

		if ( isset( $parser->mDoubleUnderscores[ 'noglossary' ] ) ) { // __NOGLOSSARY__ found in wikitext
			return false;
		}

		$title = $parser->getTitle();

		if ( !( $title instanceof Title ) ) {

			return false;
		}

		$namespace = $title->getNamespace();

		if ( isset( $wgexLingoUseNamespaces[ $namespace ] ) && $wgexLingoUseNamespaces[ $namespace ] === false ) {
			return false;
		};

		return true;
	}
}



Push — master ( 841b7d...3ed1d3 )

LingoParser::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

1. Pass all data via parameters

2. Create a class that maintains your state

1. Pass all data via parameters

2. Create a class that maintains your state

1. Pass all data via parameters

2. Create a class that maintains your state

1. Pass all data via parameters

2. Create a class that maintains your state

1		<?php
2
3		/**
4		* File holding the Lingo\LingoParser class.
5		*
6		* This file is part of the MediaWiki extension Lingo.
7		*
8		* @copyright 2011 - 2018, Stephan Gambke
9		* @license GNU General Public License, version 2 (or any later version)
10		*
11		* The Lingo extension is free software: you can redistribute it and/or modify
12		* it under the terms of the GNU General Public License as published by the Free
13		* Software Foundation; either version 2 of the License, or (at your option) any
14		* later version.
15		*
16		* The Lingo extension is distributed in the hope that it will be useful, but
17		* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
18		* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
19		* details.
20		*
21		* You should have received a copy of the GNU General Public License along
22		* with this program. If not, see <http://www.gnu.org/licenses/>.
23		*
24		* @author Stephan Gambke
25		*
26		* @file
27		* @ingroup Lingo
28		*/
29		namespace Lingo;
30
31		use DOMDocument;
32		use DOMXPath;
33		use ObjectCache;
34		use Parser;
35		use Title;
36
37		/**
38		* This class parses the given text and enriches it with definitions for defined
39		* terms.
40		*
41		* Contains a static function to initiate the parsing.
42		*
43		* @ingroup Lingo
44		*/
45		class LingoParser {
46
47		const WORD_VALUE = 0;
48		const WORD_OFFSET = 1;
49
50		private $mLingoTree = null;
51
52		/**
53		* @var Backend
54		*/
55		private $mLingoBackend = null;
56		private static $parserSingleton = null;
57
58		// The RegEx to split a chunk of text into words
59		public $regex = null;
60
61		/**
62		* Lingo\LingoParser constructor.
63		* @param MessageLog\|null $messages
64		*/
65	1	public function __construct( MessageLog &$messages = null ) {
		0 ignored issues – show Unused Code introduced 2017-08-01 10:31 UTC by Report Bug Copy Issue Report The parameter `$messages` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
66		// The RegEx to split a chunk of text into words
67		// Words are: placeholders for stripped items, sequences of letters and numbers, single characters that are neither letter nor number
68	1	$this->regex = '/' . preg_quote( Parser::MARKER_PREFIX, '/' ) . '.*?' . preg_quote( Parser::MARKER_SUFFIX, '/' ) . '\|[\p{L}\p{N}]+\|[^\p{L}\p{N}]/u';
69	1	}
70
71		/**
72		* @return Boolean
73		*/
74		public function parse( /$content, $title, $po / ) {
		0 ignored issues – show Coding Style introduced 2018-03-24 00:03 UTC by Report Bug Copy Issue Report `parse` uses the super-global variable `$GLOBALS` which is generally not recommended. Instead of super-globals, we recommend to explicitly inject the dependencies of your class. This makes your code less dependent on global state and it becomes generally more testable: // Bad class Router { public function generate($path) { return $_SERVER['HOST'].$path; } } // Better class Router { private $host; public function __construct($host) { $this->host = $host; } public function generate($path) { return $this->host.$path; } } class Controller { public function myAction(Request $request) { // Instead of $page = isset($_GET['page']) ? intval($_GET['page']) : 1; // Better (assuming you use the Symfony2 request) $page = $request->query->get('page', 1); } } Loading history... Unused Code Comprehensibility introduced 2018-03-24 00:58 UTC by Report Bug Copy Issue Report `72%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
75
76		/** @var \Parser $parser */
77		$parser = $GLOBALS[ 'wgParser' ];
78
79		if ( $this->shouldParse( $parser ) ) {
80		$this->realParse( $parser );
81		}
82
83		return true;
84		}
85
86		/**
87		* @return LingoParser
88		* @since 2.0.1
89		*/
90		public static function getInstance() {
91		if ( !self::$parserSingleton ) {
92		self::$parserSingleton = new LingoParser();
93
94		}
95
96		return self::$parserSingleton;
97		}
98
99		/**
100		* @return string
101		*/
102		private function getCacheKey() {
103		// FIXME: If Lingo ever stores the glossary tree per user, then the cache key also needs to include the user id (see T163608)
		0 ignored issues – show Coding Style introduced 2018-03-23 00:26 UTC by Report Bug Copy Issue Report Comment refers to a FIXME task "If Lingo ever stores the glossary tree per user, then the cache key also needs to include the user id (see T163608" Loading history...
104		return ObjectCache::getLocalClusterInstance()->makeKey( 'ext', 'lingo', 'lingotree', Tree::TREE_VERSION, get_class( self::getInstance()->getBackend() ) );
105		}
106
107		/**
108		* @return Backend the backend used by the parser
109		* @throws \MWException
110		*/
111		public function getBackend() {
112
113		if ( $this->mLingoBackend === null ) {
114		throw new \MWException( 'No Lingo backend available!' );
115		}
116
117		return $this->mLingoBackend;
118		}
119
120		/**
121		* Returns the list of terms in the glossary
122		*
123		* @return array an array mapping terms (keys) to descriptions (values)
124		*/
125		public function getLingoArray() {
126		return $this->getLingoTree()->getTermList();
127		}
128
129		/**
130		* Returns the list of terms in the glossary as a Lingo\Tree
131		*
132		* @return Tree a Lingo\Tree mapping terms (keys) to descriptions (values)
133		*/
134		public function getLingoTree() {
135
136		// build glossary array only once per request
137		if ( !$this->mLingoTree ) {
138
139		// use cache if enabled
140		if ( $this->mLingoBackend->useCache() ) {
141
142		// Try cache first
143		global $wgexLingoCacheType;
		0 ignored issues – show Compatibility Best Practice introduced 2016-02-29 08:15 UTC by Report Bug Copy Issue Report Use of `global` functionality is not recommended; it makes your code harder to test, and less reusable. Instead of relying on `global` state, we recommend one of these alternatives: 1. Pass all data via parameters function myFunction($a, $b) { // Do something } 2. Create a class that maintains your state class MyClass { private $a; private $b; public function __construct($a, $b) { $this->a = $a; $this->b = $b; } public function myFunction() { // Do something } } Loading history...
144		$cache = ( $wgexLingoCacheType !== null ) ? wfGetCache( $wgexLingoCacheType ) : wfGetMainCache();
145		$cachekey = $this->getCacheKey();
146		$cachedLingoTree = $cache->get( $cachekey );
147
148		// cache hit?
149		if ( $cachedLingoTree !== false && $cachedLingoTree !== null ) {
150
151		wfDebug( "Cache hit: Got lingo tree from cache.\n" );
152		$this->mLingoTree = &$cachedLingoTree;
153
154		wfDebug( "Re-cached lingo tree.\n" );
155		} else {
156
157		wfDebug( "Cache miss: Lingo tree not found in cache.\n" );
158		$this->mLingoTree =& $this->buildLingo();
159		wfDebug( "Cached lingo tree.\n" );
160		}
161
162		// Keep for one month
163		// Limiting the cache validity will allow to purge stale cache
164		// entries inserted by older versions after one month
165		$cache->set( $cachekey, $this->mLingoTree, 60 * 60 * 24 * 30 );
166
167		} else {
168		wfDebug( "Caching of lingo tree disabled.\n" );
169		$this->mLingoTree =& $this->buildLingo();
170		}
171
172		}
173
174		return $this->mLingoTree;
175		}
176
177		/**
178		* @return Tree
179		*/
180		protected function &buildLingo() {
181
182		$lingoTree = new Tree();
183		$backend = &$this->mLingoBackend;
184
185		// assemble the result array
186		while ( $elementData = $backend->next() ) {
187		$lingoTree->addTerm( $elementData[ Element::ELEMENT_TERM ], $elementData );
188		}
189
190		return $lingoTree;
191		}
192
193		/**
194		* Parses the given text and enriches applicable terms
195		*
196		* This method currently only recognizes terms consisting of max one word
197		*
198		* @param Parser $parser
199		*
200		* @return Boolean
201		*/
202		protected function realParse( &$parser ) {
203
204		$text = $parser->getOutput()->getText();
205
206		if ( $text === null \|\| $text === '' ) {
207		return true;
208		}
209
210		// Get array of terms
211		$glossary = $this->getLingoTree();
212
213		if ( $glossary == null ) {
214		return true;
215		}
216
217		// Parse HTML from page
218		\MediaWiki\suppressWarnings();
219
220		$doc = new DOMDocument( '1.0', 'utf-8' );
221		$doc->loadHTML( '<html><head><meta http-equiv="content-type" content="charset=utf-8"/></head><body>' . $text . '</body></html>' );
222
223		\MediaWiki\restoreWarnings();
224
225		// Find all text in HTML.
226		$xpath = new DOMXPath( $doc );
227		$textElements = $xpath->query(
228		"//[not(ancestor-or-self::[@class='noglossary'] or ancestor-or-self::a)][text()!=' ']/text()"
229		);
230
231		// Iterate all HTML text matches
232		$numberOfTextElements = $textElements->length;
233
234		$definitions = [];
235
236		for ( $textElementIndex = 0; $textElementIndex < $numberOfTextElements; $textElementIndex++ ) {
237		$textElement = $textElements->item( $textElementIndex );
238
239		if ( strlen( $textElement->nodeValue ) < $glossary->getMinTermLength() ) {
240		continue;
241		}
242
243		$matches = [];
244		preg_match_all(
245		$this->regex,
246		$textElement->nodeValue,
247		$matches,
248		PREG_OFFSET_CAPTURE \| PREG_PATTERN_ORDER
249		);
250
251		if ( count( $matches ) === 0 \|\| count( $matches[ 0 ] ) === 0 ) {
252		continue;
253		}
254
255		$wordDescriptors = &$matches[ 0 ]; // See __construct() for definition of "word"
256		$numberOfWordDescriptors = count( $wordDescriptors );
257
258		$parentNode = &$textElement->parentNode;
259
260		$wordDescriptorIndex = 0;
261		$changedElem = false;
262
263		while ( $wordDescriptorIndex < $numberOfWordDescriptors ) {
264
265		/** @var \Lingo\Element $definition */
266		list( $skippedWords, $usedWords, $definition ) =
267		$glossary->findNextTerm( $wordDescriptors, $wordDescriptorIndex, $numberOfWordDescriptors );
268
269		if ( $usedWords > 0 ) { // found a term
270
271		if ( $skippedWords > 0 ) { // skipped some text, insert it as is
272
273		$start = $wordDescriptors[$wordDescriptorIndex][self::WORD_OFFSET];
274		$length = $wordDescriptors[$wordDescriptorIndex + $skippedWords][self::WORD_OFFSET] - $start;
275
276		$parentNode->insertBefore(
277		$doc->createTextNode(
278		substr( $textElement->nodeValue, $start, $length)
279		),
280		$textElement
281		);
282		}
283
284		$parentNode->insertBefore( $definition->getFormattedTerm( $doc ), $textElement );
285
286		$definitions[ $definition->getId() ] = $definition->getFormattedDefinitions();
287
288		$changedElem = true;
289
290		} else { // did not find any term, just use the rest of the text
291
292		// If we found no term now and no term before, there was no
293		// term in the whole element. Might as well not change the
294		// element at all.
295
296		// Only change element if found term before
297		if ( $changedElem === true ) {
298
299		$start = $wordDescriptors[$wordDescriptorIndex][self::WORD_OFFSET];
300
301		$parentNode->insertBefore(
302		$doc->createTextNode(
303		substr( $textElement->nodeValue, $start)
304		),
305		$textElement
306		);
307
308		}
309
310		// In principle superfluous, the loop would run out anyway. Might save a bit of time.
311		break;
312		}
313
314		$wordDescriptorIndex += $usedWords + $skippedWords;
315		}
316
317		if ( $changedElem ) {
318		$parentNode->removeChild( $textElement );
319		}
320		}
321
322		if ( count( $definitions ) > 0 ) {
323
324		$this->loadModules( $parser );
325
326		// U - Ungreedy, D - dollar matches only end of string, s - dot matches newlines
327		$text = preg_replace( '%(^.<body>)\|(</body>.$)%UDs', '', $doc->saveHTML() );
328		$text .= $parser->recursiveTagParseFully( join( $definitions ) );
329
330		$parser->getOutput()->setText( $text );
331		}
332
333		return true;
334		}
335
336		/**
337		* @param Parser $parser
338		*/
339		protected function loadModules( &$parser ) {
340		global $wgOut;
		0 ignored issues – show Compatibility Best Practice introduced 2018-03-23 00:26 UTC by Report Bug Copy Issue Report Use of `global` functionality is not recommended; it makes your code harder to test, and less reusable. Instead of relying on `global` state, we recommend one of these alternatives: 1. Pass all data via parameters function myFunction($a, $b) { // Do something } 2. Create a class that maintains your state class MyClass { private $a; private $b; public function __construct($a, $b) { $this->a = $a; $this->b = $b; } public function myFunction() { // Do something } } Loading history...
341
342		$parserOutput = $parser->getOutput();
343
344		// load scripts
345		$parserOutput->addModules( 'ext.Lingo.Scripts' );
346
347		if ( !$wgOut->isArticle() ) {
348		$wgOut->addModules( 'ext.Lingo.Scripts' );
349		}
350
351		// load styles
352		$parserOutput->addModuleStyles( 'ext.Lingo.Styles' );
353
354		if ( !$wgOut->isArticle() ) {
355		$wgOut->addModuleStyles( 'ext.Lingo.Styles' );
356		}
357		}
358
359		/**
360		* Purges the lingo tree from the cache.
361		*
362		* @deprecated 2.0.2
363		*/
364		public static function purgeCache() {
365
366		self::getInstance()->purgeGlossaryFromCache();
367		}
368
369		/**
370		* Purges the lingo tree from the cache.
371		*
372		* @since 2.0.2
373		*/
374		public function purgeGlossaryFromCache() {
375
376		global $wgexLingoCacheType;
		0 ignored issues – show Compatibility Best Practice introduced 2016-02-29 08:15 UTC by Report Bug Copy Issue Report Use of `global` functionality is not recommended; it makes your code harder to test, and less reusable. Instead of relying on `global` state, we recommend one of these alternatives: 1. Pass all data via parameters function myFunction($a, $b) { // Do something } 2. Create a class that maintains your state class MyClass { private $a; private $b; public function __construct($a, $b) { $this->a = $a; $this->b = $b; } public function myFunction() { // Do something } } Loading history...
377		$cache = ( $wgexLingoCacheType !== null ) ? wfGetCache( $wgexLingoCacheType ) : wfGetMainCache();
378		$cache->delete( $this->getCacheKey() );
379		}
380
381		/**
382		* @since 2.0.1
383		* @param Backend $backend
384		*/
385		public function setBackend( Backend $backend ) {
386		$this->mLingoBackend = $backend;
387		$backend->setLingoParser( $this );
388		}
389
390		/**
391		* @param Parser $parser
392		* @return bool
393		*/
394		protected function shouldParse( &$parser ) {
395		global $wgexLingoUseNamespaces;
		0 ignored issues – show Compatibility Best Practice introduced 2016-02-29 08:15 UTC by Report Bug Copy Issue Report Use of `global` functionality is not recommended; it makes your code harder to test, and less reusable. Instead of relying on `global` state, we recommend one of these alternatives: 1. Pass all data via parameters function myFunction($a, $b) { // Do something } 2. Create a class that maintains your state class MyClass { private $a; private $b; public function __construct($a, $b) { $this->a = $a; $this->b = $b; } public function myFunction() { // Do something } } Loading history...
396
397		if ( !( $parser instanceof Parser ) ) {
		0 ignored issues – show Bug introduced 2018-03-24 00:03 UTC by Report Bug Copy Issue Report The class `Parser` does not exist. Is this class maybe located in a folder that is not analyzed, or in a newer version of your dependencies than listed in your composer.lock/composer.json? Loading history...
398		return false;
399		}
400
401		if ( isset( $parser->mDoubleUnderscores[ 'noglossary' ] ) ) { // __NOGLOSSARY__ found in wikitext
402		return false;
403		}
404
405		$title = $parser->getTitle();
406
407		if ( !( $title instanceof Title ) ) {
		0 ignored issues – show Bug introduced 2018-03-24 00:03 UTC by Report Bug Copy Issue Report The class `Title` does not exist. Is this class maybe located in a folder that is not analyzed, or in a newer version of your dependencies than listed in your composer.lock/composer.json? Loading history...
408		return false;
409		}
410
411		$namespace = $title->getNamespace();
412
413		if ( isset( $wgexLingoUseNamespaces[ $namespace ] ) && $wgexLingoUseNamespaces[ $namespace ] === false ) {
414		return false;
415		};
416
417		return true;
418		}
419		}
420
421

wikimedia / mediawiki-extensions-Lingo

Push — master ( 841b7d...3ed1d3 )

LingoParser::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

1. Pass all data via parameters

2. Create a class that maintains your state

1. Pass all data via parameters

2. Create a class that maintains your state

1. Pass all data via parameters

2. Create a class that maintains your state

1. Pass all data via parameters

2. Create a class that maintains your state

Duplication Side-by-Side

Filter issues like