summaryrefslogtreecommitdiff
blob: bd56f36260871decbd5c4d2709c2c370c7365116 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
<?php
/**
 * This file contains the base information of unmanaged message groups.
 * These classes don't use Yaml configuration nor Special:ManageMessageGroups
 * nor processMessageChanges.php
 *
 * @file
 * @author Niklas Laxström
 * @author Siebrand Mazeland
 * @copyright Copyright © 2008-2013, Niklas Laxström, Siebrand Mazeland
 * @license GPL-2.0-or-later
 */

/**
 * This is the interface and base implementation of unmanaged
 * message groups.
 * @todo Rename the class
 * @ingroup MessageGroup
 */
abstract class MessageGroupOld implements MessageGroup {
	/**
	 * Human-readable name of this group
	 */
	protected $label = 'none';

	/**
	 * @param IContextSource|null $context
	 * @return string
	 */
	public function getLabel( IContextSource $context = null ) {
		return $this->label;
	}

	/**
	 * @param string $value
	 */
	public function setLabel( $value ) {
		$this->label = $value;
	}

	/**
	 * Group-wide unique id of this group. Used also for sorting.
	 */
	protected $id = 'none';

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

	/**
	 * @param string $value
	 */
	public function setId( $value ) {
		$this->id = $value;
	}

	/**
	 * The namespace where all the messages of this group belong.
	 * If the group has messages from multiple namespaces, set this to false
	 * and look how RecentMessageGroup implements the definitions.
	 */
	protected $namespace = NS_MEDIAWIKI;

	/**
	 * Get the namespace where all the messages of this group belong.
	 * @return int
	 */
	public function getNamespace() {
		return $this->namespace;
	}

	/**
	 * Set the namespace where all the messages of this group belong.
	 * @param int $ns
	 */
	public function setNamespace( $ns ) {
		$this->namespace = $ns;
	}

	/**
	 * List of messages that are hidden by default, but can still be translated if
	 * needed.
	 */
	protected $optional = [];

	/**
	 * @return array
	 */
	public function getOptional() {
		return $this->optional;
	}

	/**
	 * @param array $value
	 */
	public function setOptional( $value ) {
		$this->optional = $value;
	}

	/**
	 * List of messages that are always hidden and cannot be translated.
	 */
	protected $ignored = [];

	/**
	 * @return array
	 */
	public function getIgnored() {
		return $this->ignored;
	}

	/**
	 * @param array $value
	 */
	public function setIgnored( $value ) {
		$this->ignored = $value;
	}

	/**
	 * Holds descripton of this group. Description is a wiki text snippet that
	 * gives information about this group to translators.
	 */
	protected $description = null;

	public function getDescription( IContextSource $context = null ) {
		return $this->description;
	}

	public function setDescription( $value ) {
		$this->description = $value;
	}

	public function getIcon() {
		return null;
	}

	/**
	 * Meta groups consist of multiple groups or parts of other groups. This info
	 * is used on many places, like when creating message index.
	 */
	protected $meta = false;

	public function isMeta() {
		return $this->meta;
	}

	public function setMeta( $value ) {
		$this->meta = $value;
	}

	public function getSourceLanguage() {
		return 'en';
	}

	/**
	 * To avoid key conflicts between groups or separated changed messages between
	 * branches one can set a message key mangler.
	 */
	protected $mangler = null;

	/**
	 * @return StringMatcher
	 */
	public function getMangler() {
		if ( !isset( $this->mangler ) ) {
			$this->mangler = StringMatcher::EmptyMatcher();
		}

		return $this->mangler;
	}

	public function setMangler( $value ) {
		$this->mangler = $value;
	}

	public function load( $code ) {
		return [];
	}

	/**
	 * This function returns array of type key => definition of all messages
	 * this message group handles.
	 *
	 * @throws MWException
	 * @return Array of messages definitions indexed by key.
	 */
	public function getDefinitions() {
		$defs = $this->load( $this->getSourceLanguage() );
		if ( !is_array( $defs ) ) {
			throw new MWException( 'Unable to load definitions for ' . $this->getLabel() );
		}

		return $defs;
	}

	/**
	 * This function can be used for meta message groups to list their "own"
	 * messages. For example branched message groups can exclude the messages they
	 * share with each other.
	 * @return array
	 */
	public function getUniqueDefinitions() {
		return $this->meta ? [] : $this->getDefinitions();
	}

	/**
	 * Returns of stored translation of message specified by the $key in language
	 * code $code.
	 *
	 * @param string $key Message key
	 * @param string $code Language code
	 * @return Mixed List of stored translation or \null.
	 */
	public function getMessage( $key, $code ) {
		if ( !isset( $this->messages[$code] ) ) {
			$this->messages[$code] = self::normaliseKeys( $this->load( $code ) );
		}
		$key = strtolower( str_replace( ' ', '_', $key ) );

		return isset( $this->messages[$code][$key] ) ? $this->messages[$code][$key] : null;
	}

	public static function normaliseKeys( $array ) {
		if ( !is_array( $array ) ) {
			return null;
		}

		$new = [];
		foreach ( $array as $key => $v ) {
			$key = strtolower( str_replace( ' ', '_', $key ) );
			$new[$key] = $v;
		}

		return $new;
	}

	/**
	 * All the messages for this group, by language code.
	 */
	protected $messages = [];

	/**
	 * Returns path to the file where translation of language code $code are.
	 *
	 * @param string $code
	 * @return string Path to the file or false if not applicable.
	 */
	public function getMessageFile( $code ) {
		return false;
	}

	public function getPath() {
		return false;
	}

	/**
	 * @param string $code
	 * @return bool|string
	 */
	public function getMessageFileWithPath( $code ) {
		$path = $this->getPath();
		$file = $this->getMessageFile( $code );

		if ( !$path || !$file ) {
			return false;
		}

		return "$path/$file";
	}

	public function getSourceFilePath( $code ) {
		return $this->getMessageFileWithPath( $code );
	}

	/**
	 * Creates a new MessageCollection for this group.
	 *
	 * @param string $code Language code for this collection.
	 * @param bool $unique Whether to build collection for messages unique to this
	 *                group only.
	 * @return MessageCollection
	 */
	public function initCollection( $code, $unique = false ) {
		if ( !$unique ) {
			$definitions = $this->getDefinitions();
		} else {
			$definitions = $this->getUniqueDefinitions();
		}

		$defs = new MessageDefinitions( $definitions, $this->getNamespace() );
		$collection = MessageCollection::newFromDefinitions( $defs, $code );

		foreach ( $this->getTags() as $type => $tags ) {
			$collection->setTags( $type, $tags );
		}

		return $collection;
	}

	public function __construct() {
	}

	/**
	 * Can be overwritten to retun false if something is wrong.
	 * @return bool
	 */
	public function exists() {
		return true;
	}

	public function getChecker() {
		return null;
	}

	public function getTags( $type = null ) {
		$tags = [
			'optional' => $this->optional,
			'ignored' => $this->ignored,
		];

		if ( !$type ) {
			return $tags;
		}

		return isset( $tags[$type] ) ? $tags[$type] : [];
	}

	/**
	 * @param string $code
	 * @return bool
	 */
	protected function isSourceLanguage( $code ) {
		return $code === $this->getSourceLanguage();
	}

	/**
	 * Unsupported stuff, just to satisfy the new interface
	 * @param array $conf
	 */
	public function setConfiguration( $conf ) {
	}

	public function getConfiguration() {
	}

	public function getFFS() {
		return null;
	}

	/**
	 * @deprecated Use getMessageGroupStates
	 */
	public function getWorkflowConfiguration() {
		global $wgTranslateWorkflowStates;
		if ( !$wgTranslateWorkflowStates ) {
			// Not configured
			$conf = [];
		} else {
			$conf = $wgTranslateWorkflowStates;
		}

		return $conf;
	}

	/**
	 * Get the message group workflow state configuration.
	 * @return MessageGroupStates
	 */
	public function getMessageGroupStates() {
		// @todo Replace deprecated call.
		$conf = $this->getWorkflowConfiguration();

		return new MessageGroupStates( $conf );
	}

	/**
	 * Get all the translatable languages for a group, considering the whitelisting
	 * and blacklisting.
	 * @return array|null The language codes as array keys.
	 */
	public function getTranslatableLanguages() {
		return null;
	}

	protected static function addContext( Message $message, IContextSource $context = null ) {
		if ( $context ) {
			$message->inLanguage( $context->getLanguage() );
		} else {
			$message->inLanguage( 'en' );
		}

		return $message;
	}

	/**
	 * List of available message types mapped to the classes
	 * implementing them. Default implementation (all).
	 *
	 * @return array
	 */
	public function getTranslationAids() {
		return TranslationAid::getTypes();
	}
}