global $wgLanguageNames;
require_once( dirname( __FILE__ ) . '/Names.php' );
-global $wgInputEncoding, $wgOutputEncoding;
-
-/**
- * These are always UTF-8, they exist only for backwards compatibility
- */
-$wgInputEncoding = 'UTF-8';
-$wgOutputEncoding = 'UTF-8';
-
if ( function_exists( 'mb_strtoupper' ) ) {
mb_internal_encoding( 'UTF-8' );
}
*/
class FakeConverter {
var $mLang;
- function FakeConverter( $langobj ) { $this->mLang = $langobj; }
+ function __construct( $langobj ) { $this->mLang = $langobj; }
function autoConvertToAllVariants( $text ) { return array( $this->mLang->getCode() => $text ); }
function convert( $t ) { return $t; }
function convertTitle( $t ) { return $t->getPrefixedText(); }
function getVariants() { return array( $this->mLang->getCode() ); }
function getPreferredVariant() { return $this->mLang->getCode(); }
+ function getDefaultVariant() { return $this->mLang->getCode(); }
+ function getURLVariant() { return ''; }
function getConvRuleTitle() { return false; }
function findVariantLink( &$l, &$n, $ignoreOtherCond = false ) { }
function getExtraHashOptions() { return ''; }
function getParsedTitle() { return ''; }
function markNoConversion( $text, $noParse = false ) { return $text; }
function convertCategoryKey( $key ) { return $key; }
- function convertLinkToAllVariants( $text ) { return autoConvertToAllVariants( $text ); }
+ function convertLinkToAllVariants( $text ) { return $this->autoConvertToAllVariants( $text ); }
function armourMath( $text ) { return $text; }
}
*/
var $transformData = array();
+ /**
+ * @var LocalisationCache
+ */
static public $dataCache;
+
static public $mLangObjCache = array();
static public $mWeekdayMsgs = array(
/**
* Get a cached language object for a given language code
+ * @param $code String
+ * @return Language
*/
static function factory( $code ) {
if ( !isset( self::$mLangObjCache[$code] ) ) {
/**
* Create a language object for a given language code
+ * @param $code String
+ * @return Language
*/
protected static function newFromCode( $code ) {
global $IP;
static $recursionLevel = 0;
+
+ // Protect against path traversal below
+ if ( !Language::isValidCode( $code )
+ || strcspn( $code, ":/\\\000" ) !== strlen( $code ) )
+ {
+ throw new MWException( "Invalid language code \"$code\"" );
+ }
+
+ if ( !Language::isValidBuiltInCode( $code ) ) {
+ // It's not possible to customise this code with class files, so
+ // just return a Language object. This is to support uselang= hacks.
+ $lang = new Language;
+ $lang->setCode( $code );
+ return $lang;
+ }
+
if ( $code == 'en' ) {
$class = 'Language';
} else {
$class = 'Language' . str_replace( '-', '_', ucfirst( $code ) );
- // Preload base classes to work around APC/PHP5 bug
- if ( file_exists( "$IP/languages/classes/$class.deps.php" ) ) {
- include_once( "$IP/languages/classes/$class.deps.php" );
- }
- if ( file_exists( "$IP/languages/classes/$class.php" ) ) {
- include_once( "$IP/languages/classes/$class.php" );
+ if ( !defined( 'MW_COMPILED' ) ) {
+ // Preload base classes to work around APC/PHP5 bug
+ if ( file_exists( "$IP/languages/classes/$class.deps.php" ) ) {
+ include_once( "$IP/languages/classes/$class.deps.php" );
+ }
+ if ( file_exists( "$IP/languages/classes/$class.php" ) ) {
+ include_once( "$IP/languages/classes/$class.php" );
+ }
}
}
throw new MWException( "Language fallback loop detected when creating class $class\n" );
}
- if ( !class_exists( $class ) ) {
+ if ( !MWInit::classExists( $class ) ) {
$fallback = Language::getFallbackFor( $code );
++$recursionLevel;
$lang = Language::newFromCode( $fallback );
return $lang;
}
+ /**
+ * Returns true if a language code string is of a valid form, whether or
+ * not it exists. This includes codes which are used solely for
+ * customisation via the MediaWiki namespace.
+ */
+ public static function isValidCode( $code ) {
+ return
+ strcspn( $code, ":/\\\000" ) === strlen( $code )
+ && !preg_match( Title::getTitleInvalidRegex(), $code );
+ }
+
+ /**
+ * Returns true if a language code is of a valid form for the purposes of
+ * internal customisation of MediaWiki, via Messages*.php.
+ */
+ public static function isValidBuiltInCode( $code ) {
+ return preg_match( '/^[a-z0-9-]*$/i', $code );
+ }
+
/**
* Get the LocalisationCache instance
+ *
+ * @return LocalisationCache
*/
public static function getLocalisationCache() {
if ( is_null( self::$dataCache ) ) {
*/
function initContLang() { }
- /**
- * @deprecated Use User::getDefaultOptions()
- * @return array
- */
- function getDefaultUserOptions() {
- wfDeprecated( __METHOD__ );
- return User::getDefaultOptions();
- }
-
function getFallbackLanguageCode() {
if ( $this->mCode === 'en' ) {
return false;
$this->namespaceNames[NS_PROJECT_TALK] =
$this->fixVariableInNamespace( $talk );
}
-
+
# Sometimes a language will be localised but not actually exist on this wiki.
- global $wgCanonicalNamespaceNames;
- $validNamespaces = array_keys(MWNamespace::getCanonicalNamespaces());
foreach( $this->namespaceNames as $key => $text ) {
if ( !isset( $validNamespaces[$key] ) ) {
unset( $this->namespaceNames[$key] );
return strtr( $ns, '_', ' ' );
}
+ /**
+ * Returns gender-dependent namespace alias if available.
+ * @param $index Int: namespace index
+ * @param $gender String: gender key (male, female... )
+ * @return String
+ * @since 1.18
+ */
+ function getGenderNsText( $index, $gender ) {
+ $ns = self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
+ return isset( $ns[$index][$gender] ) ? $ns[$index][$gender] : $this->getNsText( $index );
+ }
+
+ /**
+ * Whether this language makes distinguishes genders for example in
+ * namespaces.
+ * @return bool
+ * @since 1.18
+ */
+ function needsGenderDistinction() {
+ $aliases = self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
+ return count( $aliases ) > 0;
+ }
+
/**
* Get a namespace key by value, case insensitive.
* Only matches namespace names for the current language, not the
}
}
}
+
+ $genders = self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
+ foreach ( $genders as $index => $forms ) {
+ foreach ( $forms as $alias ) {
+ $aliases[$alias] = $index;
+ }
+ }
+
$this->namespaceAliases = $aliases;
}
return $this->namespaceAliases;
);
}
- function getMathNames() {
- return self::$dataCache->getItem( $this->mCode, 'mathNames' );
- }
-
function getDatePreferences() {
return self::$dataCache->getItem( $this->mCode, 'datePreferences' );
}
* If $customisedOnly is true, only returns codes with a messages file
*/
public static function getLanguageNames( $customisedOnly = false ) {
- global $wgLanguageNames, $wgExtraLanguageNames;
- $allNames = $wgExtraLanguageNames + $wgLanguageNames;
+ global $wgExtraLanguageNames;
+ static $coreLanguageNames;
+
+ if ( $coreLanguageNames === null ) {
+ include( MWInit::compiledPath( 'languages/Names.php' ) );
+ }
+
+ $allNames = $wgExtraLanguageNames + $coreLanguageNames;
if ( !$customisedOnly ) {
return $allNames;
}
return $names;
}
+ /**
+ * Get translated language names. This is done on best effort and
+ * by default this is exactly the same as Language::getLanguageNames.
+ * The CLDR extension provides translated names.
+ * @param $code String Language code.
+ * @return Array language code => language name
+ * @since 1.18.0
+ */
+ public static function getTranslatedLanguageNames( $code ) {
+ $names = array();
+ wfRunHooks( 'LanguageGetTranslatedLanguageNames', array( &$names, $code ) );
+
+ foreach ( self::getLanguageNames() as $code => $name ) {
+ if ( !isset( $names[$code] ) ) $names[$code] = $name;
+ }
+
+ return $names;
+ }
+
/**
* Get a message from the MediaWiki namespace.
*
return $this->getMessageFromDB( self::$mMonthMsgs[$key - 1] );
}
+ function getMonthNamesArray() {
+ $monthNames = array( '' );
+ for ( $i=1; $i < 13; $i++ ) {
+ $monthNames[] = $this->getMonthName( $i );
+ }
+ return $monthNames;
+ }
+
function getMonthNameGen( $key ) {
return $this->getMessageFromDB( self::$mMonthGenMsgs[$key - 1] );
}
return $this->getMessageFromDB( self::$mMonthAbbrevMsgs[$key - 1] );
}
+ function getMonthAbbreviationsArray() {
+ $monthNames = array('');
+ for ( $i=1; $i < 13; $i++ ) {
+ $monthNames[] = $this->getMonthAbbreviation( $i );
+ }
+ return $monthNames;
+ }
+
function getWeekdayName( $key ) {
return $this->getMessageFromDB( self::$mWeekdayMsgs[$key - 1] );
}
* escaping format.
*
* Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrU. See the
- * PHP manual for definitions. "o" format character is supported since
- * PHP 5.1.0, previous versions return literal o.
- * There are a number of extensions, which start with "x":
+ * PHP manual for definitions. There are a number of extensions, which
+ * start with "x":
*
* xn Do not translate digits of the next numeric format character
* xN Toggle raw digit (xn) flag, stays set until explicitly unset
* @param $ts String: 14-character timestamp
* YYYYMMDDHHMMSS
* 01234567890123
- * @todo emulation of "o" format character for PHP pre 5.1.0
* @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
*/
function sprintfDate( $format, $ts ) {
}
$num = gmdate( 'L', $unix );
break;
- # 'o' is supported since PHP 5.1.0
- # return literal if not supported
- # TODO: emulation for pre 5.1.0 versions
case 'o':
if ( !$unix ) {
$unix = wfTimestamp( TS_UNIX, $ts );
}
- if ( version_compare( PHP_VERSION, '5.1.0' ) === 1 ) {
- $num = date( 'o', $unix );
- } else {
- $s .= 'o';
- }
+ $num = date( 'o', $unix );
break;
case 'Y':
$num = substr( $ts, 0, 4 );
} else {
$s .= $this->formatNum( $num, true );
}
- $num = false;
}
}
return $s;
private static function tsToIranian( $ts ) {
$gy = substr( $ts, 0, 4 ) -1600;
$gm = substr( $ts, 4, 2 ) -1;
- $gd = substr( $ts, 6, 2 ) -1;
+ $gd = (int)substr( $ts, 6, 2 ) -1;
# Days passed from the beginning (including leap years)
$gDayNo = 365 * $gy
return $s;
}
- /**
+ /**
* Hebrew Gematria number formatting up to 9999
*/
static function hebrewNumeral( $num ) {
* @return string
*/
function date( $ts, $adj = false, $format = true, $timecorrection = false ) {
+ $ts = wfTimestamp( TS_MW, $ts );
if ( $adj ) {
$ts = $this->userAdjust( $ts, $timecorrection );
}
* @return string
*/
function time( $ts, $adj = false, $format = true, $timecorrection = false ) {
+ $ts = wfTimestamp( TS_MW, $ts );
if ( $adj ) {
$ts = $this->userAdjust( $ts, $timecorrection );
}
return strtr( $matches[0], $wikiUpperChars );
}
+ /**
+ * Make a string's first character uppercase
+ */
function ucfirst( $str ) {
$o = ord( $str );
- if ( $o < 96 ) {
+ if ( $o < 96 ) { // if already uppercase...
return $str;
} elseif ( $o < 128 ) {
- return ucfirst( $str );
+ return ucfirst( $str ); // use PHP's ucfirst()
} else {
// fall back to more complex logic in case of multibyte strings
return $this->uc( $str, true );
}
}
+ /**
+ * Convert a string to uppercase
+ */
function uc( $str, $first = false ) {
if ( function_exists( 'mb_strtoupper' ) ) {
if ( $first ) {
}
$isutf8 = preg_match( '/^([\x00-\x7f]|[\xc0-\xdf][\x80-\xbf]|' .
- '[\xe0-\xef][\x80-\xbf]{2}|[\xf0-\xf7][\x80-\xbf]{3})+$/', $s );
+ '[\xe0-\xef][\x80-\xbf]{2}|[\xf0-\xf7][\x80-\xbf]{3})+$/', $s );
if ( $isutf8 ) {
return $s;
}
return self::$dataCache->getItem( $this->mCode, 'magicWords' );
}
+ protected function doMagicHook() {
+ if ( $this->mMagicHookDone ) {
+ return;
+ }
+ $this->mMagicHookDone = true;
+ wfProfileIn( 'LanguageGetMagic' );
+ wfRunHooks( 'LanguageGetMagic', array( &$this->mMagicExtensions, $this->getCode() ) );
+ wfProfileOut( 'LanguageGetMagic' );
+ }
+
# Fill a MagicWord object with data from here
function getMagic( $mw ) {
- if ( !$this->mMagicHookDone ) {
- $this->mMagicHookDone = true;
- wfProfileIn( 'LanguageGetMagic' );
- wfRunHooks( 'LanguageGetMagic', array( &$this->mMagicExtensions, $this->getCode() ) );
- wfProfileOut( 'LanguageGetMagic' );
- }
+ $this->doMagicHook();
+
if ( isset( $this->mMagicExtensions[$mw->mId] ) ) {
$rawEntry = $this->mMagicExtensions[$mw->mId];
} else {
* If $length is negative, the string will be truncated from the beginning
*
* @param $string String to truncate
- * @param $length Int: maximum length (excluding ellipses)
+ * @param $length Int: maximum length (including ellipses)
* @param $ellipsis String to append to the truncated text
+ * @param $adjustLength Boolean: Subtract length of ellipsis from $length.
+ * $adjustLength was introduced in 1.18, before that behaved as if false.
* @return string
*/
- function truncate( $string, $length, $ellipsis = '...' ) {
+ function truncate( $string, $length, $ellipsis = '...', $adjustLength = true ) {
# Use the localized ellipsis character
if ( $ellipsis == '...' ) {
$ellipsis = wfMsgExt( 'ellipsis', array( 'escapenoentities', 'language' => $this ) );
}
# Check if there is no need to truncate
if ( $length == 0 ) {
- return $ellipsis;
+ return $ellipsis; // convention
} elseif ( strlen( $string ) <= abs( $length ) ) {
- return $string;
+ return $string; // no need to truncate
}
$stringOriginal = $string;
- if ( $length > 0 ) {
- $string = substr( $string, 0, $length ); // xyz...
- $string = $this->removeBadCharLast( $string );
- $string = $string . $ellipsis;
+ # If ellipsis length is >= $length then we can't apply $adjustLength
+ if ( $adjustLength && strlen( $ellipsis ) >= abs( $length ) ) {
+ $string = $ellipsis; // this can be slightly unexpected
+ # Otherwise, truncate and add ellipsis...
} else {
- $string = substr( $string, $length ); // ...xyz
- $string = $this->removeBadCharFirst( $string );
- $string = $ellipsis . $string;
+ $eLength = $adjustLength ? strlen( $ellipsis ) : 0;
+ if ( $length > 0 ) {
+ $length -= $eLength;
+ $string = substr( $string, 0, $length ); // xyz...
+ $string = $this->removeBadCharLast( $string );
+ $string = $string . $ellipsis;
+ } else {
+ $length += $eLength;
+ $string = substr( $string, $length ); // ...xyz
+ $string = $this->removeBadCharFirst( $string );
+ $string = $ellipsis . $string;
+ }
}
- # Do not truncate if the ellipsis makes the string longer/equal (bug 22181)
+ # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
+ # This check is *not* redundant if $adjustLength, due to the single case where
+ # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
if ( strlen( $string ) < strlen( $stringOriginal ) ) {
return $string;
} else {
* @return string
*/
protected function removeBadCharLast( $string ) {
- $char = ord( $string[strlen( $string ) - 1] );
- $m = array();
- if ( $char >= 0xc0 ) {
- # We got the first byte only of a multibyte char; remove it.
- $string = substr( $string, 0, -1 );
- } elseif ( $char >= 0x80 &&
- preg_match( '/^(.*)(?:[\xe0-\xef][\x80-\xbf]|' .
- '[\xf0-\xf7][\x80-\xbf]{1,2})$/', $string, $m ) )
- {
- # We chopped in the middle of a character; remove it
- $string = $m[1];
+ if ( $string != '' ) {
+ $char = ord( $string[strlen( $string ) - 1] );
+ $m = array();
+ if ( $char >= 0xc0 ) {
+ # We got the first byte only of a multibyte char; remove it.
+ $string = substr( $string, 0, -1 );
+ } elseif ( $char >= 0x80 &&
+ preg_match( '/^(.*)(?:[\xe0-\xef][\x80-\xbf]|' .
+ '[\xf0-\xf7][\x80-\xbf]{1,2})$/', $string, $m ) )
+ {
+ # We chopped in the middle of a character; remove it
+ $string = $m[1];
+ }
}
return $string;
}
* @return string
*/
protected function removeBadCharFirst( $string ) {
- $char = ord( $string[0] );
- if ( $char >= 0x80 && $char < 0xc0 ) {
- # We chopped in the middle of a character; remove the whole thing
- $string = preg_replace( '/^[\x80-\xbf]+/', '', $string );
+ if ( $string != '' ) {
+ $char = ord( $string[0] );
+ if ( $char >= 0x80 && $char < 0xc0 ) {
+ # We chopped in the middle of a character; remove the whole thing
+ $string = preg_replace( '/^[\x80-\xbf]+/', '', $string );
+ }
}
return $string;
}
- /*
+ /**
* Truncate a string of valid HTML to a specified length in bytes,
* appending an optional string (e.g. for ellipses), and return valid HTML
*
* This is only intended for styled/linked text, such as HTML with
- * tags like <span> and <a>, were the tags are self-contained (valid HTML)
+ * tags like <span> and <a>, were the tags are self-contained (valid HTML).
+ * Also, this will not detect things like "display:none" CSS.
*
- * Note: tries to fix broken HTML with MWTidy
+ * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
*
- * @param string $text String to truncate
- * @param int $length (zero/positive) Maximum length (excluding ellipses)
+ * @param string $text HTML string to truncate
+ * @param int $length (zero/positive) Maximum length (including ellipses)
* @param string $ellipsis String to append to the truncated text
* @returns string
*/
if ( $ellipsis == '...' ) {
$ellipsis = wfMsgExt( 'ellipsis', array( 'escapenoentities', 'language' => $this ) );
}
- # Check if there is no need to truncate
+ # Check if there is clearly no need to truncate
if ( $length <= 0 ) {
- return $ellipsis; // no text shown, nothing to format
+ return $ellipsis; // no text shown, nothing to format (convention)
} elseif ( strlen( $text ) <= $length ) {
- return $text; // string short enough even *with* HTML
+ return $text; // string short enough even *with* HTML (short-circuit)
}
- $text = MWTidy::tidy( $text ); // fix tags
+
$displayLen = 0; // innerHTML legth so far
$testingEllipsis = false; // checking if ellipses will make string longer/equal?
$tagType = 0; // 0-open, 1-close
$bracketState = 0; // 1-tag start, 2-tag name, 0-neither
$entityState = 0; // 0-not entity, 1-entity
- $tag = $ret = $ch = '';
- $openTags = array();
+ $tag = $ret = $pRet = ''; // accumulated tag name, accumulated result string
+ $openTags = array(); // open tag stack
+ $pOpenTags = array();
+
$textLen = strlen( $text );
- for ( $pos = 0; $pos < $textLen; ++$pos ) {
+ $neLength = max( 0, $length - strlen( $ellipsis ) ); // non-ellipsis len if truncated
+ for ( $pos = 0; true; ++$pos ) {
+ # Consider truncation once the display length has reached the maximim.
+ # Check that we're not in the middle of a bracket/entity...
+ if ( $displayLen >= $neLength && $bracketState == 0 && $entityState == 0 ) {
+ if ( !$testingEllipsis ) {
+ $testingEllipsis = true;
+ # Save where we are; we will truncate here unless there turn out to
+ # be so few remaining characters that truncation is not necessary.
+ $pOpenTags = $openTags; // save state
+ $pRet = $ret; // save state
+ } elseif ( $displayLen > $length && $displayLen > strlen( $ellipsis ) ) {
+ # String in fact does need truncation, the truncation point was OK.
+ $openTags = $pOpenTags; // reload state
+ $ret = $this->removeBadCharLast( $pRet ); // reload state, multi-byte char fix
+ $ret .= $ellipsis; // add ellipsis
+ break;
+ }
+ }
+ if ( $pos >= $textLen ) break; // extra iteration just for above checks
+
+ # Read the next char...
$ch = $text[$pos];
$lastCh = $pos ? $text[$pos - 1] : '';
$ret .= $ch; // add to result string
$entityState = 1; // entity found, (e.g. " ")
} else {
$displayLen++; // this char is displayed
- // Add on the other display text after this...
- $skipped = $this->truncate_skip(
- $ret, $text, "<>&", $pos + 1, $length - $displayLen );
+ // Add the next $max display text chars after this in one swoop...
+ $max = ( $testingEllipsis ? $length : $neLength ) - $displayLen;
+ $skipped = $this->truncate_skip( $ret, $text, "<>&", $pos + 1, $max );
$displayLen += $skipped;
$pos += $skipped;
}
}
}
- # Consider truncation once the display length has reached the maximim.
- # Double-check that we're not in the middle of a bracket/entity...
- if ( $displayLen >= $length && $bracketState == 0 && $entityState == 0 ) {
- if ( !$testingEllipsis ) {
- $testingEllipsis = true;
- # Save where we are; we will truncate here unless
- # the ellipsis actually makes the string longer.
- $pOpenTags = $openTags; // save state
- $pRet = $ret; // save state
- } elseif ( $displayLen > ( $length + strlen( $ellipsis ) ) ) {
- # Ellipsis won't make string longer/equal, the truncation point was OK.
- $openTags = $pOpenTags; // reload state
- $ret = $this->removeBadCharLast( $pRet ); // reload state, multi-byte char fix
- $ret .= $ellipsis; // add ellipsis
- break;
- }
- }
}
if ( $displayLen == 0 ) {
return ''; // no text shown, nothing to format
}
- $this->truncate_endBracket( $tag, $text[$textLen - 1], $tagType, $openTags ); // for bad HTML
+ // Close the last tag if left unclosed by bad HTML
+ $this->truncate_endBracket( $tag, $text[$textLen - 1], $tagType, $openTags );
while ( count( $openTags ) > 0 ) {
$ret .= '</' . array_pop( $openTags ) . '>'; // close open tags
}
// truncateHtml() helper function
// like strcspn() but adds the skipped chars to $ret
- private function truncate_skip( &$ret, $text, $search, $start, $len = -1 ) {
+ private function truncate_skip( &$ret, $text, $search, $start, $len = null ) {
+ if ( $len === null ) {
+ $len = -1; // -1 means "no limit" for strcspn
+ } elseif ( $len < 0 ) {
+ $len = 0; // sanity
+ }
$skipCount = 0;
if ( $start < strlen( $text ) ) {
$skipCount = strcspn( $text, $search, $start, $len );
return $skipCount;
}
- // truncateHtml() helper function
- // (a) push or pop $tag from $openTags as needed
- // (b) clear $tag value
+ /**
+ * truncateHtml() helper function
+ * (a) push or pop $tag from $openTags as needed
+ * (b) clear $tag value
+ * @param String &$tag Current HTML tag name we are looking at
+ * @param int $tagType (0-open tag, 1-close tag)
+ * @param char $lastCh Character before the '>' that ended this tag
+ * @param array &$openTags Open tag stack (not accounting for $tag)
+ */
private function truncate_endBracket( &$tag, $tagType, $lastCh, &$openTags ) {
$tag = ltrim( $tag );
if ( $tag != '' ) {
/**
* Checks that convertPlural was given an array and pads it to requested
- * amound of forms by copying the last one.
+ * amount of forms by copying the last one.
*
* @param $count Integer: How many forms should there be at least
* @param $forms Array of forms given to convertPlural
}
/**
- * For translating of expiry times
- * @param $str String: the validated block time in English
- * @return Somehow translated block time
+ * Maybe translate block durations. Note that this function is somewhat misnamed: it
+ * deals with translating the *duration* ("1 week", "4 days", etc), not the expiry time
+ * (which is an absolute timestamp).
+ * @param $str String: the validated block duration in English
+ * @return Somehow translated block duration
* @see LanguageFi.php for example implementation
*/
function translateBlockExpiry( $str ) {
- $scBlockExpiryOptions = $this->getMessageFromDB( 'ipboptions' );
-
- if ( $scBlockExpiryOptions == '-' ) {
- return $str;
- }
-
- foreach ( explode( ',', $scBlockExpiryOptions ) as $option ) {
- if ( strpos( $option, ':' ) === false ) {
- continue;
- }
- list( $show, $value ) = explode( ':', $option );
+ $duration = SpecialBlock::getSuggestedDurations( $this );
+ foreach( $duration as $show => $value ){
if ( strcmp( $str, $value ) == 0 ) {
return htmlspecialchars( trim( $show ) );
}
}
+ // Since usually only infinite or indefinite is only on list, so try
+ // equivalents if still here.
+ $indefs = array( 'infinite', 'infinity', 'indefinite' );
+ if ( in_array( $str, $indefs ) ) {
+ foreach( $indefs as $val ) {
+ $show = array_search( $val, $duration, true );
+ if ( $show !== false ) {
+ return htmlspecialchars( trim( $show ) );
+ }
+ }
+ }
+ // If all else fails, return the original string.
return $str;
}
}
/**
- * Get the list of variants supported by this langauge
+ * Get the list of variants supported by this language
* see sample implementation in LanguageZh.php
*
* @return array an array of language codes
return $this->mConverter->getVariants();
}
- function getPreferredVariant( $fromUser = true, $fromHeader = false ) {
- return $this->mConverter->getPreferredVariant( $fromUser, $fromHeader );
+ function getPreferredVariant() {
+ return $this->mConverter->getPreferredVariant();
+ }
+
+ function getDefaultVariant() {
+ return $this->mConverter->getDefaultVariant();
+ }
+
+ function getURLVariant() {
+ return $this->mConverter->getURLVariant();
}
/**
* If a language supports multiple variants, converts text
* into an array of all possible variants of the text:
* 'variant' => text in that variant
+ *
+ * @deprecated since 1.17 Use autoConvertToAllVariants()
*/
function convertLinkToAllVariants( $text ) {
return $this->mConverter->convertLinkToAllVariants( $text );
* @return string $prefix . $mangledCode . $suffix
*/
static function getFileName( $prefix = 'Language', $code, $suffix = '.php' ) {
+ // Protect against path traversal
+ if ( !Language::isValidCode( $code )
+ || strcspn( $code, ":/\\\000" ) !== strlen( $code ) )
+ {
+ throw new MWException( "Invalid language code \"$code\"" );
+ }
+
return $prefix . str_replace( '-', '_', ucfirst( $code ) ) . $suffix;
}
throw new MWException(
"Utf8Case.ser is missing, please run \"make\" in the serialized directory\n" );
}
- extract( $arr );
+ $wikiUpperChars = $arr['wikiUpperChars'];
+ $wikiLowerChars = $arr['wikiLowerChars'];
wfProfileOut( __METHOD__ );
return array( $wikiUpperChars, $wikiLowerChars );
}
+ /**
+ * Decode an expiry (block, protection, etc) which has come from the DB
+ *
+ * @param $expiry String: Database expiry String
+ * @param $format Bool|Int true to process using language functions, or TS_ constant
+ * to return the expiry in a given timestamp
+ * @return String
+ */
+ public function formatExpiry( $expiry, $format = true ) {
+ static $infinity, $infinityMsg;
+ if( $infinity === null ){
+ $infinityMsg = wfMessage( 'infiniteblock' );
+ $infinity = wfGetDB( DB_SLAVE )->getInfinity();
+ }
+
+ if ( $expiry == '' || $expiry == $infinity ) {
+ return $format === true
+ ? $infinityMsg
+ : $infinity;
+ } else {
+ return $format === true
+ ? $this->timeanddate( $expiry )
+ : wfTimestamp( $format, $expiry );
+ }
+ }
+
+ /**
+ * @todo Document
+ * @param $seconds String
+ * @return string
+ */
function formatTimePeriod( $seconds ) {
- if ( $seconds < 10 ) {
- return $this->formatNum( sprintf( "%.1f", $seconds ) ) . $this->getMessageFromDB( 'seconds-abbrev' );
- } elseif ( $seconds < 60 ) {
+ if ( round( $seconds * 10 ) < 100 ) {
+ return $this->formatNum( sprintf( "%.1f", round( $seconds * 10 ) / 10 ) ) . $this->getMessageFromDB( 'seconds-abbrev' );
+ } elseif ( round( $seconds ) < 60 ) {
return $this->formatNum( round( $seconds ) ) . $this->getMessageFromDB( 'seconds-abbrev' );
- } elseif ( $seconds < 3600 ) {
+ } elseif ( round( $seconds ) < 3600 ) {
$minutes = floor( $seconds / 60 );
$secondsPart = round( fmod( $seconds, 60 ) );
if ( $secondsPart == 60 ) {
function getConvRuleTitle() {
return $this->mConverter->getConvRuleTitle();
}
-
- /**
- * Given a string, convert it to a (hopefully short) key that can be used
- * for efficient sorting. A binary sort according to the sortkeys
- * corresponds to a logical sort of the corresponding strings. Current
- * code expects that a null character should sort before all others, but
- * has no other particular expectations (and that one can be changed if
- * necessary).
- *
- * @param string $string UTF-8 string
- * @return string Binary sortkey
- */
- public function convertToSortkey( $string ) {
- # Fake function for now
- return strtoupper( $string );
- }
-
- /**
- * Does it make sense for lists to be split up into sections based on their
- * first letter? Logogram-based scripts probably want to return false.
- *
- * TODO: Use this in CategoryPage.php.
- *
- * @return boolean
- */
- public function usesFirstLettersInLists() {
- return true;
- }
-
- /**
- * Given a string, return the logical "first letter" to be used for
- * grouping on category pages and so on. This has to be coordinated
- * carefully with convertToSortkey(), or else the sorted list might jump
- * back and forth between the same "initial letters" or other pathological
- * behavior. For instance, if you just return the first character, but "a"
- * sorts the same as "A" based on convertToSortkey(), then you might get a
- * list like
- *
- * == A ==
- * * [[Aardvark]]
- *
- * == a ==
- * * [[antelope]]
- *
- * == A ==
- * * [[Ape]]
- *
- * etc., assuming for the sake of argument that $wgCapitalLinks is false.
- * Obviously, this is ignored if usesFirstLettersInLists() is false.
- *
- * @param string $string UTF-8 string
- * @return string UTF-8 string corresponding to the first letter of input
- */
- public function firstLetterForLists( $string ) {
- if ( $string[0] == "\0" ) {
- $string = substr( $string, 1 );
- }
- return strtoupper( $this->firstChar( $string ) );
- }
}