MediawikiApi::newFromApiEndpoint() - Code Metrics - Inspection of "Add factory methods to MediawikiApi" - addwiki/mediawiki-api-base - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 749236...2c4679 )

by adam

created 2015-12-17 22:56 UTC

MediawikiApi::newFromApiEndpoint() A

↳ Parent: MediawikiApi

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	1

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

<?php

namespace Mediawiki\Api;

use GuzzleHttp\Client;
use GuzzleHttp\Exception\RequestException;
use GuzzleHttp\Handler\CurlHandler;
use GuzzleHttp\HandlerStack;
use GuzzleHttp\Promise\PromiseInterface;
use InvalidArgumentException;
use Mediawiki\Api\Guzzle\MiddlewareFactory;
use Psr\Http\Message\ResponseInterface;
use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerInterface;
use Psr\Log\LogLevel;
use Psr\Log\NullLogger;

/**
 * Main class for this library
 *
 * @since 0.1
 *
 * @author Addshore
 */
class MediawikiApi implements LoggerAwareInterface {

	/**
	 * @var Client|null Should be accessed through getClient
	 */
	private $client = null;

	/**
	 * @var bool|string
	 */
	private $isLoggedIn;

	/**
	 * @var MediawikiSession
	 */
	private $session;

	/**
	 * @var string
	 */
	private $version;

	/**
	 * @var LoggerInterface
	 */
	private $logger;

	/**
	 * @since 2.0.0
	 *
	 * @param string $apiEndpoint e.g. https://en.wikipedia.org/w/api.php
	 *
	 * @return self returns a MediawikiApi instance using $apiEndpoint
	 */
	public static function newFromApiEndpoint( $apiEndpoint ) {
		return new self( $apiEndpoint );
	}

	/**
	 * @since 2.0.0
	 *
	 * @param string $url e.g. https://en.wikipedia.org OR https://de.wikipedia.org/wiki/Berlin
	 *
	 * @return self returns a MediawikiApi instance using the apiEndpoint provided by the RSD
	 *              file accessible on all Mediawiki pages
	 *
	 * @see https://en.wikipedia.org/wiki/Really_Simple_Discovery
	 */
	public static function newFromPage( $url ) {

		//TODO implement me
	}

	/**
	 * @access private
	 *
	 * @param string $apiUrl The API Url
	 * @param Client|null $client Guzzle Client
	 * @param MediawikiSession|null $session Inject a custom session here
	 */
	public function __construct( $apiUrl, Client $client = null, MediawikiSession $session = null ) {
		if( !is_string( $apiUrl ) ) {
			throw new InvalidArgumentException( '$apiUrl must be a string' );
		}
		if( $session === null ) {
			$session = new MediawikiSession( $this );
		}

		$this->apiUrl = $apiUrl;
class MyClass { }

$x = new MyClass();
$x->foo = true;
		$this->client = $client;
		$this->session = $session;

		$this->logger = new NullLogger();
	}

	/**
	 * @return Client
	 */
	private function getClient() {
		if( $this->client === null ) {
			$middlewareFactory = new MiddlewareFactory();
			$middlewareFactory->setLogger( $this->logger );

			$handlerStack = HandlerStack::create( new CurlHandler() );
			$handlerStack->push( $middlewareFactory->retry() );

			$this->client = new Client( array(
				'cookies' => true,
				'handler' => $handlerStack,
			) );
		}
		return $this->client;
	}

	/**
	 * Sets a logger instance on the object
	 *
	 * @since 1.1
	 *
	 * @param LoggerInterface $logger
	 *
	 * @return null
	 */
	public function setLogger( LoggerInterface $logger ) {
		$this->logger = $logger;
		$this->session->setLogger( $logger );
	}

	/**
	 * @since 2.0
	 *
	 * @param Request $request
	 *
	 * @return PromiseInterface
	 *         Normally promising an array, though can be mixed (json_decode result)
	 *         Can throw UsageExceptions or RejectionExceptions
	 */
	public function getRequestAsync( Request $request ) {
		$promise = $this->getClient()->getAsync(
			$this->apiUrl,
			$this->getClientRequestOptions( $request, 'query' )
		);

		return $promise->then( function( ResponseInterface $response ) {
			return call_user_func( array( $this, 'decodeResponse' ), $response );
		} );
	}

	/**
	 * @since 2.0
	 *
	 * @param Request $request
	 *
	 * @return PromiseInterface
	 *         Normally promising an array, though can be mixed (json_decode result)
	 *         Can throw UsageExceptions or RejectionExceptions
	 */
	public function postRequestAsync( Request $request ) {
		$promise = $this->getClient()->postAsync(
			$this->apiUrl,
			$this->getClientRequestOptions( $request, 'form_params' )
		);

		return $promise->then( function( ResponseInterface $response ) {
			return call_user_func( array( $this, 'decodeResponse' ), $response );
		} );
	}

	/**
	 * @since 0.2
	 *
	 * @param Request $request
	 *
	 * @return mixed Normally an array
	 */
	public function getRequest( Request $request ) {
		$response = $this->getClient()->get(
			$this->apiUrl,
			$this->getClientRequestOptions( $request, 'query' )
		);

		return $this->decodeResponse( $response );
	}

	/**
	 * @since 0.2
	 *
	 * @param Request $request
	 *
	 * @return mixed Normally an array
	 */
	public function postRequest( Request $request ) {
		$response = $this->getClient()->post(
			$this->apiUrl,
			$this->getClientRequestOptions( $request, 'form_params' )
		);

		return $this->decodeResponse( $response );
	}

	/**
	 * @param ResponseInterface $response
	 *
	 * @return mixed
	 * @throws UsageException
	 */
	private function decodeResponse( ResponseInterface $response ) {
		$resultArray = json_decode( $response->getBody(), true );

		$this->logWarnings( $resultArray );
		$this->throwUsageExceptions( $resultArray );

		return $resultArray;
	}

	/**
	 * @param Request $request
	 * @param string $paramsKey either 'query' or 'form_params'
	 *
	 * @throws RequestException
	 *
	 * @return array as needed by ClientInterface::get and ClientInterface::post
	 */
	private function getClientRequestOptions( Request $request, $paramsKey ) {
		return array(
			$paramsKey => array_merge( $request->getParams(), array( 'format' => 'json' ) ),
			'headers' => array_merge( $this->getDefaultHeaders(), $request->getHeaders() ),
		);
	}

	/**
	 * @return array
	 */
	private function getDefaultHeaders() {
		return array(
			'User-Agent' => $this->getUserAgent(),
		);
	}

	private function getUserAgent() {
		$loggedIn = $this->isLoggedin();
		if( $loggedIn ) {
			return 'addwiki-mediawiki-client/' . $loggedIn;
		}
		return 'addwiki-mediawiki-client';
	}

	/**
	 * @param $result
	 */
	private function logWarnings( $result ) {
		if( is_array( $result ) && array_key_exists( 'warnings', $result ) ) {
			foreach( $result['warnings'] as $module => $warningData ) {
				$this->logger->log( LogLevel::WARNING, $module . ': ' . $warningData['*'], array( 'data' => $warningData ) );
			}
		}
	}

	/**
	 * @param array $result
	 *
	 * @throws UsageException
	 */
	private function throwUsageExceptions( $result ) {
		if( is_array( $result ) && array_key_exists( 'error', $result ) ) {
			throw new UsageException(
				$result['error']['code'],
				$result['error']['info'],
				$result
			);
		}
	}

	/**
	 * @since 0.1
	 *
	 * @return bool|string false or the name of the current user
	 */
	public function isLoggedin() {
		return $this->isLoggedIn;
	}

	/**
	 * @since 0.1
	 *
	 * @param ApiUser $apiUser
	 *
	 * @throws UsageException
	 * @return bool success
	 */
	public function login( ApiUser $apiUser ) {
		$this->logger->log( LogLevel::DEBUG, 'Logging in' );

		$credentials = array(
			'lgname' => $apiUser->getUsername(),
			'lgpassword' => $apiUser->getPassword(),
		);

		if( !is_null( $apiUser->getDomain() ) ) {
			$credentials['lgdomain'] = $apiUser->getDomain();
		}

		$result = $this->postRequest( new SimpleRequest( 'login', $credentials ) );
		if ( $result['login']['result'] == "NeedToken" ) {
			$result = $this->postRequest( new SimpleRequest( 'login', array_merge( array( 'lgtoken' => $result['login']['token'] ), $credentials) ) );
		}
		if ( $result['login']['result'] == "Success" ) {
			$this->isLoggedIn = $apiUser->getUsername();
			return true;
		}

		$this->isLoggedIn = false;
		$this->throwLoginUsageException( $result );
		return false;
	}

	/**
	 * @param array $result
	 *
	 * @throws UsageException
	 */
	private function throwLoginUsageException( $result ) {
		$loginResult = $result['login']['result'];
		switch( $loginResult ) {
			case 'Illegal';
				throw new UsageException(
					'login-' . $loginResult,
					'You provided an illegal username',
					$result
				);
			case 'NotExists';
				throw new UsageException(
					'login-' . $loginResult,
					'The username you provided doesn\'t exist',
					$result
				);
			case 'WrongPass';
				throw new UsageException(
					'login-' . $loginResult,
					'The password you provided is incorrect',
					$result
				);
			case 'WrongPluginPass';
				throw new UsageException(
					'login-' . $loginResult,
					'An authentication plugin rather than MediaWiki itself rejected the password',
					$result
				);
			case 'CreateBlocked';
				throw new UsageException(
					'login-' . $loginResult,
					'The wiki tried to automatically create a new account for you, but your IP address has been blocked from account creation',
					$result
				);
			case 'Throttled';
				throw new UsageException(
					'login-' . $loginResult,
					'You\'ve logged in too many times in a short time.',
					$result
				);
			case 'Blocked';
				throw new UsageException(
					'login-' . $loginResult,
					'User is blocked',
					$result
				);
			case 'NeedToken';
				throw new UsageException(
					'login-' . $loginResult,
					'Either you did not provide the login token or the sessionid cookie.',
					$result
				);
			default:
				throw new UsageException(
					'login-' . $loginResult,
					$loginResult,
					$result
				);
		}
	}

	/**
	 * @since 0.1
	 *
	 * @return bool success
	 */
	public function logout() {
		$this->logger->log( LogLevel::DEBUG, 'Logging out' );
		$result = $this->postRequest( new SimpleRequest( 'logout' ) );
		if( $result === array() ) {
			$this->isLoggedIn = false;
			$this->clearTokens();
			return true;
		}
		return false;
	}

	/**
	 * @since 0.1
	 *
	 * @param string $type
	 *
	 * @return string
	 */
	public function getToken( $type = 'csrf' ) {
		return $this->session->getToken( $type );
	}

	/**
	 * @since 0.1
	 *
	 * Clears all tokens stored by the api
	 */
	public function clearTokens() {
		$this->session->clearTokens();
	}

	/**
	 * @return string
	 */
	public function getVersion(){
		if( !isset( $this->version ) ) {
			$result = $this->getRequest( new SimpleRequest( 'query', array(
				'meta' => 'siteinfo',
				'continue' => '',
			) ) );
			preg_match(
				'/\d+(?:\.\d+)+/',
				$result['query']['general']['generator'],
				$versionParts
			);
			$this->version = $versionParts[0];
		}
		return $this->version;
	}

}


1		<?php
2
3		namespace Mediawiki\Api;
4
5		use GuzzleHttp\Client;
6		use GuzzleHttp\Exception\RequestException;
7		use GuzzleHttp\Handler\CurlHandler;
8		use GuzzleHttp\HandlerStack;
9		use GuzzleHttp\Promise\PromiseInterface;
10		use InvalidArgumentException;
11		use Mediawiki\Api\Guzzle\MiddlewareFactory;
12		use Psr\Http\Message\ResponseInterface;
13		use Psr\Log\LoggerAwareInterface;
14		use Psr\Log\LoggerInterface;
15		use Psr\Log\LogLevel;
16		use Psr\Log\NullLogger;
17
18		/**
19		* Main class for this library
20		*
21		* @since 0.1
22		*
23		* @author Addshore
24		*/
25		class MediawikiApi implements LoggerAwareInterface {
26
27		/**
28		* @var Client\|null Should be accessed through getClient
29		*/
30		private $client = null;
31
32		/**
33		* @var bool\|string
34		*/
35		private $isLoggedIn;
36
37		/**
38		* @var MediawikiSession
39		*/
40		private $session;
41
42		/**
43		* @var string
44		*/
45		private $version;
46
47		/**
48		* @var LoggerInterface
49		*/
50		private $logger;
51
52		/**
53		* @since 2.0.0
54		*
55		* @param string $apiEndpoint e.g. https://en.wikipedia.org/w/api.php
56		*
57	23	* @return self returns a MediawikiApi instance using $apiEndpoint
58	23	*/
59	4	public static function newFromApiEndpoint( $apiEndpoint ) {
60		return new self( $apiEndpoint );
61	19	}
62	19
63	19	/**
64		* @since 2.0.0
65	19	*
66	16	* @param string $url e.g. https://en.wikipedia.org OR https://de.wikipedia.org/wiki/Berlin
67		*
68		* @return self returns a MediawikiApi instance using the apiEndpoint provided by the RSD
69	16	* file accessible on all Mediawiki pages
70		*
71	19	* @see https://en.wikipedia.org/wiki/Really_Simple_Discovery
72	19	*/
73	19	public static function newFromPage( $url ) {
		0 ignored issues – show Unused Code introduced 2015-12-17 22:59 UTC by Report Bug Copy Issue Report The parameter `$url` 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...
74		//TODO implement me
75	19	}
76	19
77		/**
78		* @access private
79		*
80		* @param string $apiUrl The API Url
81	16	* @param Client\|null $client Guzzle Client
82	16	* @param MediawikiSession\|null $session Inject a custom session here
83		*/
84		public function __construct( $apiUrl, Client $client = null, MediawikiSession $session = null ) {
85		if( !is_string( $apiUrl ) ) {
86		throw new InvalidArgumentException( '$apiUrl must be a string' );
87		}
88		if( $session === null ) {
89		$session = new MediawikiSession( $this );
90		}
91
92		$this->apiUrl = $apiUrl;
		0 ignored issues – show Bug introduced 2015-12-16 13:05 UTC by Report Bug Copy Issue Report The property `apiUrl` 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...
93		$this->client = $client;
94	16	$this->session = $session;
95
96		$this->logger = new NullLogger();
97		}
98
99		/**
100		* @return Client
101		*/
102		private function getClient() {
103		if( $this->client === null ) {
104		$middlewareFactory = new MiddlewareFactory();
105		$middlewareFactory->setLogger( $this->logger );
106
107		$handlerStack = HandlerStack::create( new CurlHandler() );
108		$handlerStack->push( $middlewareFactory->retry() );
109
110		$this->client = new Client( array(
111		'cookies' => true,
112		'handler' => $handlerStack,
113		) );
114		}
115		return $this->client;
116		}
117
118		/**
119		* Sets a logger instance on the object
120		*
121		* @since 1.1
122		*
123		* @param LoggerInterface $logger
124		*
125		* @return null
126		*/
127		public function setLogger( LoggerInterface $logger ) {
128		$this->logger = $logger;
129		$this->session->setLogger( $logger );
130		}
131
132		/**
133		* @since 2.0
134		*
135		* @param Request $request
136		*
137		* @return PromiseInterface
138		* Normally promising an array, though can be mixed (json_decode result)
139		* Can throw UsageExceptions or RejectionExceptions
140		*/
141		public function getRequestAsync( Request $request ) {
142		$promise = $this->getClient()->getAsync(
143		$this->apiUrl,
144		$this->getClientRequestOptions( $request, 'query' )
145		);
146
147		return $promise->then( function( ResponseInterface $response ) {
148		return call_user_func( array( $this, 'decodeResponse' ), $response );
149		} );
150		}
151
152		/**
153		* @since 2.0
154		*
155		* @param Request $request
156		*
157		* @return PromiseInterface
158	8	* Normally promising an array, though can be mixed (json_decode result)
159	8	* Can throw UsageExceptions or RejectionExceptions
160	8	*/
161	8	public function postRequestAsync( Request $request ) {
162	8	$promise = $this->getClient()->postAsync(
163		$this->apiUrl,
164	8	$this->getClientRequestOptions( $request, 'form_params' )
165		);
166
167		return $promise->then( function( ResponseInterface $response ) {
168		return call_user_func( array( $this, 'decodeResponse' ), $response );
169		} );
170		}
171
172		/**
173		* @since 0.2
174	8	*
175	8	* @param Request $request
176	8	*
177	8	* @return mixed Normally an array
178	8	*/
179		public function getRequest( Request $request ) {
180	8	$response = $this->getClient()->get(
181		$this->apiUrl,
182		$this->getClientRequestOptions( $request, 'query' )
183		);
184
185		return $this->decodeResponse( $response );
186		}
187
188		/**
189	16	* @since 0.2
190	16	*
191		* @param Request $request
192	16	*
193	16	* @return mixed Normally an array
194		*/
195	14	public function postRequest( Request $request ) {
196		$response = $this->getClient()->post(
197		$this->apiUrl,
198		$this->getClientRequestOptions( $request, 'form_params' )
199		);
200
201		return $this->decodeResponse( $response );
202		}
203
204		/**
205		* @param ResponseInterface $response
206	16	*
207		* @return mixed
208	16	* @throws UsageException
209	16	*/
210	16	private function decodeResponse( ResponseInterface $response ) {
211		$resultArray = json_decode( $response->getBody(), true );
212
213		$this->logWarnings( $resultArray );
214		$this->throwUsageExceptions( $resultArray );
215
216	16	return $resultArray;
217		}
218	16
219	16	/**
220		* @param Request $request
221		* @param string $paramsKey either 'query' or 'form_params'
222	16	*
223	16	* @throws RequestException
224	16	*
225		* @return array as needed by ClientInterface::get and ClientInterface::post
226		*/
227	16	private function getClientRequestOptions( Request $request, $paramsKey ) {
228		return array(
229		$paramsKey => array_merge( $request->getParams(), array( 'format' => 'json' ) ),
230		'headers' => array_merge( $this->getDefaultHeaders(), $request->getHeaders() ),
231		);
232		}
233	16
234	16	/**
235		* @return array
236		*/
237		private function getDefaultHeaders() {
238		return array(
239	16	'User-Agent' => $this->getUserAgent(),
240		);
241		}
242
243		private function getUserAgent() {
244		$loggedIn = $this->isLoggedin();
245		if( $loggedIn ) {
246	16	return 'addwiki-mediawiki-client/' . $loggedIn;
247	16	}
248	2	return 'addwiki-mediawiki-client';
249	2	}
250	2
251		/**
252	2	* @param $result
253		*/
254	14	private function logWarnings( $result ) {
255		if( is_array( $result ) && array_key_exists( 'warnings', $result ) ) {
256		foreach( $result['warnings'] as $module => $warningData ) {
257		$this->logger->log( LogLevel::WARNING, $module . ': ' . $warningData['*'], array( 'data' => $warningData ) );
258		}
259		}
260		}
261	16
262	16	/**
263		* @param array $result
264		*
265		* @throws UsageException
266		*/
267		private function throwUsageExceptions( $result ) {
268		if( is_array( $result ) && array_key_exists( 'error', $result ) ) {
269		throw new UsageException(
270		$result['error']['code'],
271		$result['error']['info'],
272		$result
273	2	);
274	2	}
275		}
276
277	2	/**
278	2	* @since 0.1
279	2	*
280		* @return bool\|string false or the name of the current user
281	2	*/
282		public function isLoggedin() {
283		return $this->isLoggedIn;
284		}
285	2
286	2	/**
287	2	* @since 0.1
288	2	*
289	2	* @param ApiUser $apiUser
290	1	*
291	1	* @throws UsageException
292		* @return bool success
293		*/
294	1	public function login( ApiUser $apiUser ) {
295	1	$this->logger->log( LogLevel::DEBUG, 'Logging in' );
296
297		$credentials = array(
298		'lgname' => $apiUser->getUsername(),
299		'lgpassword' => $apiUser->getPassword(),
300		);
301
302		if( !is_null( $apiUser->getDomain() ) ) {
303		$credentials['lgdomain'] = $apiUser->getDomain();
304	1	}
305	1
306		$result = $this->postRequest( new SimpleRequest( 'login', $credentials ) );
307	1	if ( $result['login']['result'] == "NeedToken" ) {
308		$result = $this->postRequest( new SimpleRequest( 'login', array_merge( array( 'lgtoken' => $result['login']['token'] ), $credentials) ) );
309		}
310		if ( $result['login']['result'] == "Success" ) {
311		$this->isLoggedIn = $apiUser->getUsername();
312		return true;
313	1	}
314
315		$this->isLoggedIn = false;
316		$this->throwLoginUsageException( $result );
317		return false;
318		}
319	1
320		/**
321		* @param array $result
322		*
323		* @throws UsageException
324		*/
325	1	private function throwLoginUsageException( $result ) {
326		$loginResult = $result['login']['result'];
327		switch( $loginResult ) {
328		case 'Illegal';
329		throw new UsageException(
330		'login-' . $loginResult,
331	1	'You provided an illegal username',
332		$result
333		);
334		case 'NotExists';
335		throw new UsageException(
336		'login-' . $loginResult,
337	1	'The username you provided doesn\'t exist',
338		$result
339		);
340		case 'WrongPass';
341		throw new UsageException(
342		'login-' . $loginResult,
343	1	'The password you provided is incorrect',
344		$result
345		);
346		case 'WrongPluginPass';
347		throw new UsageException(
348		'login-' . $loginResult,
349	1	'An authentication plugin rather than MediaWiki itself rejected the password',
350		$result
351		);
352		case 'CreateBlocked';
353		throw new UsageException(
354		'login-' . $loginResult,
355	1	'The wiki tried to automatically create a new account for you, but your IP address has been blocked from account creation',
356	1	$result
357	1	);
358	1	case 'Throttled';
359		throw new UsageException(
360	1	'login-' . $loginResult,
361	1	'You\'ve logged in too many times in a short time.',
362		$result
363		);
364		case 'Blocked';
365		throw new UsageException(
366		'login-' . $loginResult,
367		'User is blocked',
368	2	$result
369	2	);
370	2	case 'NeedToken';
371	2	throw new UsageException(
372	1	'login-' . $loginResult,
373	1	'Either you did not provide the login token or the sessionid cookie.',
374	1	$result
375		);
376	1	default:
377		throw new UsageException(
378		'login-' . $loginResult,
379		$loginResult,
380		$result
381		);
382		}
383		}
384
385		/**
386		* @since 0.1
387		*
388		* @return bool success
389		*/
390		public function logout() {
391		$this->logger->log( LogLevel::DEBUG, 'Logging out' );
392		$result = $this->postRequest( new SimpleRequest( 'logout' ) );
393		if( $result === array() ) {
394	1	$this->isLoggedIn = false;
395	1	$this->clearTokens();
396	1	return true;
397		}
398		return false;
399		}
400
401	4	/**
402	4	* @since 0.1
403	4	*
404	4	* @param string $type
405	4	*
406	4	* @return string
407	4	*/
408	4	public function getToken( $type = 'csrf' ) {
409	4	return $this->session->getToken( $type );
410		}
411	4
412	4	/**
413	4	* @since 0.1
414	4	*
415		* Clears all tokens stored by the api
416		*/
417		public function clearTokens() {
418		$this->session->clearTokens();
419		}
420
421		/**
422		* @return string
423		*/
424		public function getVersion(){
425		if( !isset( $this->version ) ) {
426		$result = $this->getRequest( new SimpleRequest( 'query', array(
427		'meta' => 'siteinfo',
428		'continue' => '',
429		) ) );
430		preg_match(
431		'/\d+(?:\.\d+)+/',
432		$result['query']['general']['generator'],
433		$versionParts
434		);
435		$this->version = $versionParts[0];
436		}
437		return $this->version;
438		}
439
440		}
441

addwiki / mediawiki-api-base

Push — master ( 749236...2c4679 )

MediawikiApi::newFromApiEndpoint() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like