DumpMetaInformation::getLanguageCode() - Code Metrics - Inspection of "Fix indentation and some spaces" - wikimedia/mediawiki-extensions-WikibaseQualityExternalValidation - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 8bf143...89dc24 )

unknown

created 2017-06-16 13:43 UTC

DumpMetaInformation::getLanguageCode() A

↳ Parent: DumpMetaInformation

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace WikibaseQuality\ExternalValidation\DumpMetaInformation;

use Language;
use InvalidArgumentException;
use Wikibase\DataModel\Entity\ItemId;
use Wikibase\DataModel\Entity\PropertyId;
use Wikimedia\Assert\Assert;

/**
 * @package WikibaseQuality\ExternalValidation\DumpMetaInformation
 * @author BP2014N1
 * @license GNU GPL v2+
 */
class DumpMetaInformation {

	/**
	 * Id of the dump
	 *
	 * @var string
	 */
	private $dumpId;

	/**
	 * Id of the item that represents the data source of the dump
	 *
	 * @var ItemId
	 */
	private $sourceItemId;

	/**
	 * Properties for identifiers of the dump.
	 *
	 * @var PropertyId[]
	 */
	private $identifierPropertyIds;

	/**
	 * Date of import
	 *
	 * @var string
	 */
	private $importDate;

	/**
	 * Language code of values of the dump
	 *
	 * @var string
	 */
	private $languageCode;

	/**
	 * Source url of the downloaded dump
	 *
	 * @var string
	 */
	private $sourceUrl;

	/**
	 * Size of the imported dump in byte
	 *
	 * @var int
	 */
	private $size;

	/**
	 * Id of the item that represents the license of the database
	 *
	 * @var ItemId
	 */
	private $licenseItemId;

	/**
	 * @param string $dumpId
	 * @param ItemId $sourceItemId
	 * @param PropertyId[] $identifierPropertyIds
	 * @param string $importDate
	 * @param string $languageCode
	 * @param string $sourceUrl
	 * @param int $size
	 * @param ItemId $licenseItemId
	 *
	 * @throws InvalidArgumentException
	 */
	public function __construct(
		$dumpId,
		ItemId $sourceItemId,
		array $identifierPropertyIds,
		$importDate,
		$languageCode,
		$sourceUrl,
		$size,
		ItemId $licenseItemId
	) {
		Assert::parameterElementType(
			PropertyId::class,
			$identifierPropertyIds,
			'$identifierPropertyIds'
		);

		$this->setDumpId( $dumpId );
		$this->sourceItemId = $sourceItemId;
		$this->identifierPropertyIds = $identifierPropertyIds;
		$this->setImportDate( $importDate );
		$this->setLanguageCode( $languageCode );
		$this->setSourceUrl( $sourceUrl );
		$this->setSize( $size );
		$this->licenseItemId = $licenseItemId;
	}

	/**
	 * @return string
	 */
	public function getDumpId() {
		return $this->dumpId;
	}

	/**
	 * @return ItemId
	 */
	public function getSourceItemId() {
		return $this->sourceItemId;
	}

	/**
	 * @return \Wikibase\DataModel\Entity\PropertyId[]
	 */
	public function getIdentifierPropertyIds() {
		return $this->identifierPropertyIds;
	}

	/**
	 * @return string
	 */
	public function getImportDate() {
		return $this->importDate;
	}

	/**
	 * @return string
	 */
	public function getLanguageCode() {
		return $this->languageCode;
	}

	/**
	 * @return string
	 */
	public function getSourceUrl() {
		return $this->sourceUrl;
	}

	/**
	 * @return int
	 */
	public function getSize() {
		return $this->size;
	}

	/**
	 * @return ItemId
	 */
	public function getLicenseItemId() {
		return $this->licenseItemId;
	}

	/**
	 * @param string $dumpId
	 *
	 * @throws InvalidArgumentException
	 */
	private function setDumpId( $dumpId ) {
		Assert::parameterType( 'string', $dumpId, '$dumpId' );
		$length = strlen( $dumpId );
		if ( $length < 1 || $length > 25 ) {
			throw new InvalidArgumentException( '$dumpId must be between 1 and 25 characters.' );
		}

		$this->dumpId = $dumpId;
	}

	/**
	 * @param string $languageCode
	 *
	 * @throws InvalidArgumentException
	 */
	private function setLanguageCode( $languageCode ) {
		Assert::parameterType( 'string', $languageCode, '$languageCode' );
		if ( !Language::isValidCode( $languageCode ) ) {
			throw new InvalidArgumentException( '$languageCode is not valid.' );
		}

		$this->languageCode = $languageCode;
	}

	/**
	 * @param string $importDate
	 *
	 * @throws InvalidArgumentException
	 */
	private function setImportDate( $importDate ) {
		Assert::parameterType( 'string', $importDate, '$importDate' );

		$timestamp = wfTimestamp( TS_MW, $importDate );
		if ( !$timestamp ) {
			throw new InvalidArgumentException( '$updatedAt has invalid timestamp format.' );
		}

		$this->importDate = $importDate;
	}

	/**
	 * @param string $sourceUrl
	 *
	 * @throws InvalidArgumentException
	 */
	private function setSourceUrl( $sourceUrl ) {
		Assert::parameterType( 'string', $sourceUrl, '$sourceUrl' );
		if ( strlen( $sourceUrl ) > 300 ) {
			throw new InvalidArgumentException( '$sourceUrl must not be longer than 300 characters.' );
		}
		if ( !filter_var( $sourceUrl, FILTER_VALIDATE_URL ) ) {
			throw new InvalidArgumentException( '$sourceUrl is not a valid url.' );
		}

		$this->sourceUrl = $sourceUrl;
	}

	/**
	 * @param int $size
	 *
	 * @throws InvalidArgumentException
	 */
	private function setSize( $size ) {
		Assert::parameterType( 'integer', $size, '$size' );
		if ( $size <= 0 ) {
			throw new InvalidArgumentException( '$size must be positive integer.' );
		}

		$this->size = $size;
	}

}


1			<?php
2
3			namespace WikibaseQuality\ExternalValidation\DumpMetaInformation;
4
5			use Language;
6			use InvalidArgumentException;
7			use Wikibase\DataModel\Entity\ItemId;
8			use Wikibase\DataModel\Entity\PropertyId;
9			use Wikimedia\Assert\Assert;
10
11			/**
12			* @package WikibaseQuality\ExternalValidation\DumpMetaInformation
13			* @author BP2014N1
14			* @license GNU GPL v2+
15			*/
16			class DumpMetaInformation {
17
18			/**
19			* Id of the dump
20			*
21			* @var string
22			*/
23			private $dumpId;
24
25			/**
26			* Id of the item that represents the data source of the dump
27			*
28			* @var ItemId
29			*/
30			private $sourceItemId;
31
32			/**
33			* Properties for identifiers of the dump.
34			*
35			* @var PropertyId[]
36			*/
37			private $identifierPropertyIds;
38
39			/**
40			* Date of import
41			*
42			* @var string
43			*/
44			private $importDate;
45
46			/**
47			* Language code of values of the dump
48			*
49			* @var string
50			*/
51			private $languageCode;
52
53			/**
54			* Source url of the downloaded dump
55			*
56			* @var string
57			*/
58			private $sourceUrl;
59
60			/**
61			* Size of the imported dump in byte
62			*
63			* @var int
64			*/
65			private $size;
66
67			/**
68			* Id of the item that represents the license of the database
69			*
70			* @var ItemId
71			*/
72			private $licenseItemId;
73
74			/**
75			* @param string $dumpId
76			* @param ItemId $sourceItemId
77			* @param PropertyId[] $identifierPropertyIds
78			* @param string $importDate
79			* @param string $languageCode
80			* @param string $sourceUrl
81			* @param int $size
82			* @param ItemId $licenseItemId
83			*
84			* @throws InvalidArgumentException
85			*/
86			public function __construct(
87			$dumpId,
88			ItemId $sourceItemId,
89			array $identifierPropertyIds,
90			$importDate,
91			$languageCode,
92			$sourceUrl,
93			$size,
94			ItemId $licenseItemId
95			) {
96			Assert::parameterElementType(
97			PropertyId::class,
98			$identifierPropertyIds,
99			'$identifierPropertyIds'
100			);
101
102			$this->setDumpId( $dumpId );
103			$this->sourceItemId = $sourceItemId;
104			$this->identifierPropertyIds = $identifierPropertyIds;
105			$this->setImportDate( $importDate );
106			$this->setLanguageCode( $languageCode );
107			$this->setSourceUrl( $sourceUrl );
108			$this->setSize( $size );
109			$this->licenseItemId = $licenseItemId;
110			}
111
112			/**
113			* @return string
114			*/
115			public function getDumpId() {
116			return $this->dumpId;
117			}
118
119			/**
120			* @return ItemId
121			*/
122			public function getSourceItemId() {
123			return $this->sourceItemId;
124			}
125
126			/**
127			* @return \Wikibase\DataModel\Entity\PropertyId[]
128			*/
129			public function getIdentifierPropertyIds() {
130			return $this->identifierPropertyIds;
131			}
132
133			/**
134			* @return string
135			*/
136			public function getImportDate() {
137			return $this->importDate;
138			}
139
140			/**
141			* @return string
142			*/
143			public function getLanguageCode() {
144			return $this->languageCode;
145			}
146
147			/**
148			* @return string
149			*/
150			public function getSourceUrl() {
151			return $this->sourceUrl;
152			}
153
154			/**
155			* @return int
156			*/
157			public function getSize() {
158			return $this->size;
159			}
160
161			/**
162			* @return ItemId
163			*/
164			public function getLicenseItemId() {
165			return $this->licenseItemId;
166			}
167
168			/**
169			* @param string $dumpId
170			*
171			* @throws InvalidArgumentException
172			*/
173			private function setDumpId( $dumpId ) {
174			Assert::parameterType( 'string', $dumpId, '$dumpId' );
175			$length = strlen( $dumpId );
176			if ( $length < 1 \|\| $length > 25 ) {
177			throw new InvalidArgumentException( '$dumpId must be between 1 and 25 characters.' );
178			}
179
180			$this->dumpId = $dumpId;
181			}
182
183			/**
184			* @param string $languageCode
185			*
186			* @throws InvalidArgumentException
187			*/
188			private function setLanguageCode( $languageCode ) {
189			Assert::parameterType( 'string', $languageCode, '$languageCode' );
190			if ( !Language::isValidCode( $languageCode ) ) {
191			throw new InvalidArgumentException( '$languageCode is not valid.' );
192			}
193
194			$this->languageCode = $languageCode;
195			}
196
197			/**
198			* @param string $importDate
199			*
200			* @throws InvalidArgumentException
201			*/
202			private function setImportDate( $importDate ) {
203			Assert::parameterType( 'string', $importDate, '$importDate' );
204
205			$timestamp = wfTimestamp( TS_MW, $importDate );
206			if ( !$timestamp ) {
207			throw new InvalidArgumentException( '$updatedAt has invalid timestamp format.' );
208			}
209
210			$this->importDate = $importDate;
211			}
212
213			/**
214			* @param string $sourceUrl
215			*
216			* @throws InvalidArgumentException
217			*/
218			private function setSourceUrl( $sourceUrl ) {
219			Assert::parameterType( 'string', $sourceUrl, '$sourceUrl' );
220			if ( strlen( $sourceUrl ) > 300 ) {
221			throw new InvalidArgumentException( '$sourceUrl must not be longer than 300 characters.' );
222			}
223			if ( !filter_var( $sourceUrl, FILTER_VALIDATE_URL ) ) {
224			throw new InvalidArgumentException( '$sourceUrl is not a valid url.' );
225			}
226
227			$this->sourceUrl = $sourceUrl;
228			}
229
230			/**
231			* @param int $size
232			*
233			* @throws InvalidArgumentException
234			*/
235			private function setSize( $size ) {
236			Assert::parameterType( 'integer', $size, '$size' );
237			if ( $size <= 0 ) {
238			throw new InvalidArgumentException( '$size must be positive integer.' );
239			}
240
241			$this->size = $size;
242			}
243
244			}
245

wikimedia / mediawiki-extensions-WikibaseQualityExternalValidation

Push — master ( 8bf143...89dc24 )

DumpMetaInformation::getLanguageCode() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like