Code Coverage |
||||||||||
Lines |
Functions and Methods |
Classes and Traits |
||||||||
Total | |
0.00% |
0 / 34 |
|
0.00% |
0 / 32 |
CRAP | |
0.00% |
0 / 1 |
ConstraintCheckerServices | |
0.00% |
0 / 34 |
|
0.00% |
0 / 32 |
1122 | |
0.00% |
0 / 1 |
getService | |
0.00% |
0 / 3 |
|
0.00% |
0 / 1 |
6 | |||
getConflictsWithChecker | |
0.00% |
0 / 1 |
|
0.00% |
0 / 1 |
2 | |||
getItemChecker | |
0.00% |
0 / 1 |
|
0.00% |
0 / 1 |
2 | |||
getTargetRequiredClaimChecker | |
0.00% |
0 / 1 |
|
0.00% |
0 / 1 |
2 | |||
getSymmetricChecker | |
0.00% |
0 / 1 |
|
0.00% |
0 / 1 |
2 | |||
getInverseChecker | |
0.00% |
0 / 1 |
|
0.00% |
0 / 1 |
2 | |||
getQualifierChecker | |
0.00% |
0 / 1 |
|
0.00% |
0 / 1 |
2 | |||
getQualifiersChecker | |
0.00% |
0 / 1 |
|
0.00% |
0 / 1 |
2 | |||
getMandatoryQualifiersChecker | |
0.00% |
0 / 1 |
|
0.00% |
0 / 1 |
2 | |||
getRangeChecker | |
0.00% |
0 / 1 |
|
0.00% |
0 / 1 |
2 | |||
getDiffWithinRangeChecker | |
0.00% |
0 / 1 |
|
0.00% |
0 / 1 |
2 | |||
getTypeChecker | |
0.00% |
0 / 1 |
|
0.00% |
0 / 1 |
2 | |||
getValueTypeChecker | |
0.00% |
0 / 1 |
|
0.00% |
0 / 1 |
2 | |||
getSingleValueChecker | |
0.00% |
0 / 1 |
|
0.00% |
0 / 1 |
2 | |||
getMultiValueChecker | |
0.00% |
0 / 1 |
|
0.00% |
0 / 1 |
2 | |||
getUniqueValueChecker | |
0.00% |
0 / 1 |
|
0.00% |
0 / 1 |
2 | |||
getFormatChecker | |
0.00% |
0 / 1 |
|
0.00% |
0 / 1 |
2 | |||
getCommonsLinkChecker | |
0.00% |
0 / 1 |
|
0.00% |
0 / 1 |
2 | |||
getOneOfChecker | |
0.00% |
0 / 1 |
|
0.00% |
0 / 1 |
2 | |||
getValueOnlyChecker | |
0.00% |
0 / 1 |
|
0.00% |
0 / 1 |
2 | |||
getReferenceChecker | |
0.00% |
0 / 1 |
|
0.00% |
0 / 1 |
2 | |||
getNoBoundsChecker | |
0.00% |
0 / 1 |
|
0.00% |
0 / 1 |
2 | |||
getAllowedUnitsChecker | |
0.00% |
0 / 1 |
|
0.00% |
0 / 1 |
2 | |||
getSingleBestValueChecker | |
0.00% |
0 / 1 |
|
0.00% |
0 / 1 |
2 | |||
getEntityTypeChecker | |
0.00% |
0 / 1 |
|
0.00% |
0 / 1 |
2 | |||
getNoneOfChecker | |
0.00% |
0 / 1 |
|
0.00% |
0 / 1 |
2 | |||
getIntegerChecker | |
0.00% |
0 / 1 |
|
0.00% |
0 / 1 |
2 | |||
getCitationNeededChecker | |
0.00% |
0 / 1 |
|
0.00% |
0 / 1 |
2 | |||
getPropertyScopeChecker | |
0.00% |
0 / 1 |
|
0.00% |
0 / 1 |
2 | |||
getContemporaryChecker | |
0.00% |
0 / 1 |
|
0.00% |
0 / 1 |
2 | |||
getLexemeLanguageChecker | |
0.00% |
0 / 1 |
|
0.00% |
0 / 1 |
2 | |||
getLabelInLanguageChecker | |
0.00% |
0 / 1 |
|
0.00% |
0 / 1 |
2 |
1 | <?php |
2 | |
3 | namespace WikibaseQuality\ConstraintReport; |
4 | |
5 | use MediaWiki\MediaWikiServices; |
6 | use WikibaseQuality\ConstraintReport\ConstraintCheck\Checker\LabelInLanguageChecker; |
7 | use WikibaseQuality\ConstraintReport\ConstraintCheck\Checker\Lexeme\LanguageChecker; |
8 | use WikibaseQuality\ConstraintReport\ConstraintCheck\ConstraintChecker; |
9 | |
10 | /** |
11 | * @license GPL-2.0-or-later |
12 | */ |
13 | class ConstraintCheckerServices { |
14 | |
15 | public const CONFLICTS_WITH_CHECKER = 'WBQC_ConflictsWithChecker'; |
16 | public const ITEM_CHECKER = 'WBQC_ItemChecker'; |
17 | public const TARGET_REQUIRED_CLAIM_CHECKER = 'WBQC_TargetRequiredClaimChecker'; |
18 | public const SYMMETRIC_CHECKER = 'WBQC_SymmetricChecker'; |
19 | public const INVERSE_CHECKER = 'WBQC_InverseChecker'; |
20 | public const QUALIFIER_CHECKER = 'WBQC_QualifierChecker'; |
21 | public const QUALIFIERS_CHECKER = 'WBQC_QualifiersChecker'; |
22 | public const MANDATORY_QUALIFIERS_CHECKER = 'WBQC_MandatoryQualifiersChecker'; |
23 | public const RANGE_CHECKER = 'WBQC_RangeChecker'; |
24 | public const DIFF_WITHIN_RANGE_CHECKER = 'WBQC_DiffWithinRangeChecker'; |
25 | public const TYPE_CHECKER = 'WBQC_TypeChecker'; |
26 | public const VALUE_TYPE_CHECKER = 'WBQC_ValueTypeChecker'; |
27 | public const SINGLE_VALUE_CHECKER = 'WBQC_SingleValueChecker'; |
28 | public const MULTI_VALUE_CHECKER = 'WBQC_MultiValueChecker'; |
29 | public const UNIQUE_VALUE_CHECKER = 'WBQC_UniqueValueChecker'; |
30 | public const FORMAT_CHECKER = 'WBQC_FormatChecker'; |
31 | public const COMMONS_LINK_CHECKER = 'WBQC_CommonsLinkChecker'; |
32 | public const ONE_OF_CHECKER = 'WBQC_OneOfChecker'; |
33 | public const VALUE_ONLY_CHECKER = 'WBQC_ValueOnlyChecker'; |
34 | public const REFERENCE_CHECKER = 'WBQC_ReferenceChecker'; |
35 | public const NO_BOUNDS_CHECKER = 'WBQC_NoBoundsChecker'; |
36 | public const ALLOWED_UNITS_CHECKER = 'WBQC_AllowedUnitsChecker'; |
37 | public const SINGLE_BEST_VALUE_CHECKER = 'WBQC_SingleBestValueChecker'; |
38 | public const ENTITY_TYPE_CHECKER = 'WBQC_EntityTypeChecker'; |
39 | public const NONE_OF_CHECKER = 'WBQC_NoneOfChecker'; |
40 | public const INTEGER_CHECKER = 'WBQC_IntegerChecker'; |
41 | public const CITATION_NEEDED_CHECKER = 'WBQC_CitationNeededChecker'; |
42 | public const PROPERTY_SCOPE_CHECKER = 'WBQC_PropertyScopeChecker'; |
43 | public const CONTEMPORARY_CHECKER = 'WBQC_ContemporaryChecker'; |
44 | public const LEXEME_LANGUAGE_CHECKER = 'WBQC_Lexeme_LanguageChecker'; |
45 | public const LABEL_IN_LANGUAGE_CHECKER = 'WBQC_LabelInLanguageChecker'; |
46 | |
47 | private static function getService( ?MediaWikiServices $services, $name ) { |
48 | if ( $services === null ) { |
49 | $services = MediaWikiServices::getInstance(); |
50 | } |
51 | return $services->getService( $name ); |
52 | } |
53 | |
54 | /** |
55 | * @param MediaWikiServices|null $services |
56 | * @return ConstraintChecker |
57 | */ |
58 | public static function getConflictsWithChecker( MediaWikiServices $services = null ) { |
59 | return self::getService( $services, self::CONFLICTS_WITH_CHECKER ); |
60 | } |
61 | |
62 | /** |
63 | * @param MediaWikiServices|null $services |
64 | * @return ConstraintChecker |
65 | */ |
66 | public static function getItemChecker( MediaWikiServices $services = null ) { |
67 | return self::getService( $services, self::ITEM_CHECKER ); |
68 | } |
69 | |
70 | /** |
71 | * @param MediaWikiServices|null $services |
72 | * @return ConstraintChecker |
73 | */ |
74 | public static function getTargetRequiredClaimChecker( MediaWikiServices $services = null ) { |
75 | return self::getService( $services, self::TARGET_REQUIRED_CLAIM_CHECKER ); |
76 | } |
77 | |
78 | /** |
79 | * @param MediaWikiServices|null $services |
80 | * @return ConstraintChecker |
81 | */ |
82 | public static function getSymmetricChecker( MediaWikiServices $services = null ) { |
83 | return self::getService( $services, self::SYMMETRIC_CHECKER ); |
84 | } |
85 | |
86 | /** |
87 | * @param MediaWikiServices|null $services |
88 | * @return ConstraintChecker |
89 | */ |
90 | public static function getInverseChecker( MediaWikiServices $services = null ) { |
91 | return self::getService( $services, self::INVERSE_CHECKER ); |
92 | } |
93 | |
94 | /** |
95 | * @param MediaWikiServices|null $services |
96 | * @return ConstraintChecker |
97 | */ |
98 | public static function getQualifierChecker( MediaWikiServices $services = null ) { |
99 | return self::getService( $services, self::QUALIFIER_CHECKER ); |
100 | } |
101 | |
102 | /** |
103 | * @param MediaWikiServices|null $services |
104 | * @return ConstraintChecker |
105 | */ |
106 | public static function getQualifiersChecker( MediaWikiServices $services = null ) { |
107 | return self::getService( $services, self::QUALIFIERS_CHECKER ); |
108 | } |
109 | |
110 | /** |
111 | * @param MediaWikiServices|null $services |
112 | * @return ConstraintChecker |
113 | */ |
114 | public static function getMandatoryQualifiersChecker( MediaWikiServices $services = null ) { |
115 | return self::getService( $services, self::MANDATORY_QUALIFIERS_CHECKER ); |
116 | } |
117 | |
118 | /** |
119 | * @param MediaWikiServices|null $services |
120 | * @return ConstraintChecker |
121 | */ |
122 | public static function getRangeChecker( MediaWikiServices $services = null ) { |
123 | return self::getService( $services, self::RANGE_CHECKER ); |
124 | } |
125 | |
126 | /** |
127 | * @param MediaWikiServices|null $services |
128 | * @return ConstraintChecker |
129 | */ |
130 | public static function getDiffWithinRangeChecker( MediaWikiServices $services = null ) { |
131 | return self::getService( $services, self::DIFF_WITHIN_RANGE_CHECKER ); |
132 | } |
133 | |
134 | /** |
135 | * @param MediaWikiServices|null $services |
136 | * @return ConstraintChecker |
137 | */ |
138 | public static function getTypeChecker( MediaWikiServices $services = null ) { |
139 | return self::getService( $services, self::TYPE_CHECKER ); |
140 | } |
141 | |
142 | /** |
143 | * @param MediaWikiServices|null $services |
144 | * @return ConstraintChecker |
145 | */ |
146 | public static function getValueTypeChecker( MediaWikiServices $services = null ) { |
147 | return self::getService( $services, self::VALUE_TYPE_CHECKER ); |
148 | } |
149 | |
150 | /** |
151 | * @param MediaWikiServices|null $services |
152 | * @return ConstraintChecker |
153 | */ |
154 | public static function getSingleValueChecker( MediaWikiServices $services = null ) { |
155 | return self::getService( $services, self::SINGLE_VALUE_CHECKER ); |
156 | } |
157 | |
158 | /** |
159 | * @param MediaWikiServices|null $services |
160 | * @return ConstraintChecker |
161 | */ |
162 | public static function getMultiValueChecker( MediaWikiServices $services = null ) { |
163 | return self::getService( $services, self::MULTI_VALUE_CHECKER ); |
164 | } |
165 | |
166 | /** |
167 | * @param MediaWikiServices|null $services |
168 | * @return ConstraintChecker |
169 | */ |
170 | public static function getUniqueValueChecker( MediaWikiServices $services = null ) { |
171 | return self::getService( $services, self::UNIQUE_VALUE_CHECKER ); |
172 | } |
173 | |
174 | /** |
175 | * @param MediaWikiServices|null $services |
176 | * @return ConstraintChecker |
177 | */ |
178 | public static function getFormatChecker( MediaWikiServices $services = null ) { |
179 | return self::getService( $services, self::FORMAT_CHECKER ); |
180 | } |
181 | |
182 | /** |
183 | * @param MediaWikiServices|null $services |
184 | * @return ConstraintChecker |
185 | */ |
186 | public static function getCommonsLinkChecker( MediaWikiServices $services = null ) { |
187 | return self::getService( $services, self::COMMONS_LINK_CHECKER ); |
188 | } |
189 | |
190 | /** |
191 | * @param MediaWikiServices|null $services |
192 | * @return ConstraintChecker |
193 | */ |
194 | public static function getOneOfChecker( MediaWikiServices $services = null ) { |
195 | return self::getService( $services, self::ONE_OF_CHECKER ); |
196 | } |
197 | |
198 | /** |
199 | * @param MediaWikiServices|null $services |
200 | * @return ConstraintChecker |
201 | */ |
202 | public static function getValueOnlyChecker( MediaWikiServices $services = null ) { |
203 | return self::getService( $services, self::VALUE_ONLY_CHECKER ); |
204 | } |
205 | |
206 | /** |
207 | * @param MediaWikiServices|null $services |
208 | * @return ConstraintChecker |
209 | */ |
210 | public static function getReferenceChecker( MediaWikiServices $services = null ) { |
211 | return self::getService( $services, self::REFERENCE_CHECKER ); |
212 | } |
213 | |
214 | /** |
215 | * @param MediaWikiServices|null $services |
216 | * @return ConstraintChecker |
217 | */ |
218 | public static function getNoBoundsChecker( MediaWikiServices $services = null ) { |
219 | return self::getService( $services, self::NO_BOUNDS_CHECKER ); |
220 | } |
221 | |
222 | /** |
223 | * @param MediaWikiServices|null $services |
224 | * @return ConstraintChecker |
225 | */ |
226 | public static function getAllowedUnitsChecker( MediaWikiServices $services = null ) { |
227 | return self::getService( $services, self::ALLOWED_UNITS_CHECKER ); |
228 | } |
229 | |
230 | /** |
231 | * @param MediaWikiServices|null $services |
232 | * @return ConstraintChecker |
233 | */ |
234 | public static function getSingleBestValueChecker( MediaWikiServices $services = null ) { |
235 | return self::getService( $services, self::SINGLE_BEST_VALUE_CHECKER ); |
236 | } |
237 | |
238 | /** |
239 | * @param MediaWikiServices|null $services |
240 | * @return ConstraintChecker |
241 | */ |
242 | public static function getEntityTypeChecker( MediaWikiServices $services = null ) { |
243 | return self::getService( $services, self::ENTITY_TYPE_CHECKER ); |
244 | } |
245 | |
246 | /** |
247 | * @param MediaWikiServices|null $services |
248 | * @return ConstraintChecker |
249 | */ |
250 | public static function getNoneOfChecker( MediaWikiServices $services = null ) { |
251 | return self::getService( $services, self::NONE_OF_CHECKER ); |
252 | } |
253 | |
254 | /** |
255 | * @param MediaWikiServices|null $services |
256 | * @return ConstraintChecker |
257 | */ |
258 | public static function getIntegerChecker( MediaWikiServices $services = null ) { |
259 | return self::getService( $services, self::INTEGER_CHECKER ); |
260 | } |
261 | |
262 | /** |
263 | * @param MediaWikiServices|null $services |
264 | * @return ConstraintChecker |
265 | */ |
266 | public static function getCitationNeededChecker( MediaWikiServices $services = null ) { |
267 | return self::getService( $services, self::CITATION_NEEDED_CHECKER ); |
268 | } |
269 | |
270 | /** |
271 | * @param MediaWikiServices|null $services |
272 | * @return ConstraintChecker |
273 | */ |
274 | public static function getPropertyScopeChecker( MediaWikiServices $services = null ) { |
275 | return self::getService( $services, self::PROPERTY_SCOPE_CHECKER ); |
276 | } |
277 | |
278 | /** |
279 | * @param MediaWikiServices|null $services |
280 | * @return ConstraintChecker |
281 | */ |
282 | public static function getContemporaryChecker( MediaWikiServices $services = null ) { |
283 | return self::getService( $services, self::CONTEMPORARY_CHECKER ); |
284 | } |
285 | |
286 | /** |
287 | * @param MediaWikiServices|null $services |
288 | * @return LanguageChecker |
289 | */ |
290 | public static function getLexemeLanguageChecker( MediaWikiServices $services = null ) { |
291 | return self::getService( $services, self::LEXEME_LANGUAGE_CHECKER ); |
292 | } |
293 | |
294 | /** |
295 | * @param MediaWikiServices|null $services |
296 | * @return LabelInLanguageChecker |
297 | */ |
298 | public static function getLabelInLanguageChecker( MediaWikiServices $services = null ) { |
299 | return self::getService( $services, self::LABEL_IN_LANGUAGE_CHECKER ); |
300 | } |
301 | |
302 | } |