* @file
*/
+/**
+ * @todo: determine if it is really necessary to load this. Appears to be left over from pre-autoloader versions, and
+ * is only really needed to provide access to constant UTF8_REPLACEMENT, which actually resides in UtfNormalDefines.php
+ * and is loaded by UtfNormalUtil.php, which is loaded by UtfNormal.php.
+ */
if ( !class_exists( 'UtfNormal' ) ) {
require_once( dirname(__FILE__) . '/normal/UtfNormal.php' );
}
define ( 'GAID_FOR_UPDATE', 1 );
-
-/**
- * Constants for pr_cascade bitfield
- */
-define( 'CASCADE', 1 );
-
/**
* Represents a title within MediaWiki.
* Optionally may contain an interwiki designation or namespace.
* @note This class can fetch various kinds of data from the database;
* however, it does so inefficiently.
+ *
+ * @internal documentation reviewed 15 Mar 2010
*/
class Title {
/** @name Static cache variables */
*/
//@{
- var $mTextform = ''; ///< Text form (spaces not underscores) of the main part
- var $mUrlform = ''; ///< URL-encoded form of the main part
- var $mDbkeyform = ''; ///< Main part with underscores
+ var $mTextform = ''; ///< Text form (spaces not underscores) of the main part
+ var $mUrlform = ''; ///< URL-encoded form of the main part
+ var $mDbkeyform = ''; ///< Main part with underscores
var $mUserCaseDBKey; ///< DB key with the initial letter in the case specified by the user
var $mNamespace = NS_MAIN; ///< Namespace index, i.e. one of the NS_xxxx constants
- var $mInterwiki = ''; ///< Interwiki prefix (or null string)
- var $mFragment; ///< Title fragment (i.e. the bit after the #)
+ var $mInterwiki = ''; ///< Interwiki prefix (or null string)
+ var $mFragment; ///< Title fragment (i.e. the bit after the #)
var $mArticleID = -1; ///< Article ID, fetched from the link cache on demand
var $mLatestID = false; ///< ID of most recent revision
var $mRestrictions = array(); ///< Array of groups allowed to edit this article
var $mOldRestrictions = false;
- var $mCascadeRestriction; ///< Cascade restrictions on this page to included templates and images?
- var $mRestrictionsExpiry = array(); ///< When do the restrictions on this page expire?
- var $mHasCascadingRestrictions; ///< Are cascading restrictions in effect on this page?
- var $mCascadeSources; ///< Where are the cascading restrictions coming from on this page?
+ var $mCascadeRestriction; ///< Cascade restrictions on this page to included templates and images?
+ var $mRestrictionsExpiry = array(); ///< When do the restrictions on this page expire?
+ var $mHasCascadingRestrictions; ///< Are cascading restrictions in effect on this page?
+ var $mCascadeSources; ///< Where are the cascading restrictions coming from on this page?
var $mRestrictionsLoaded = false; ///< Boolean for initialisation on demand
- var $mPrefixedText; ///< Text form including namespace/interwiki, initialised on demand
+ var $mPrefixedText; ///< Text form including namespace/interwiki, initialised on demand
# Don't change the following default, NS_MAIN is hardcoded in several
# places. See bug 696.
var $mDefaultNamespace = NS_MAIN; ///< Namespace index when there is no namespace
- # Zero except in {{transclusion}} tags
- var $mWatched = null; ///< Is $wgUser watching this page? null if unfilled, accessed through userIsWatching()
+ # Zero except in {{transclusion}} tags
+ var $mWatched = null; ///< Is $wgUser watching this page? null if unfilled, accessed through userIsWatching()
var $mLength = -1; ///< The page length, 0 for special pages
var $mRedirect = null; ///< Is the article at this title a redirect?
var $mNotificationTimestamp = array(); ///< Associative array of user ID -> timestamp/false
- var $mBacklinkCache = null; ///< Cache of links to this title
+ var $mBacklinkCache = null; ///< Cache of links to this title
//@}
/**
* Create a new Title from a prefixed DB key
+ *
* @param $key \type{\string} The database key, which has underscores
* instead of spaces, possibly including namespace and
* interwiki prefixes
if( $t->secureAndSplit() )
return $t;
else
- return NULL;
+ return null;
}
/**
* Create a new Title from text, such as what one would find in a link. De-
* codes any HTML entities in the text.
*
- * @param $text string The link text; spaces, prefixes, and an
+ * @param $text string The link text; spaces, prefixes, and an
* initial ':' indicating the main namespace are accepted.
- * @param $defaultNamespace int The namespace to use if none is speci-
+ * @param $defaultNamespace int The namespace to use if none is speci-
* fied by a prefix. If you want to force a specific namespace even if
* $text might begin with a namespace prefix, use makeTitle() or
* makeTitleSafe().
}
/**
- * Convert things like é ā or 〗 into real text...
+ * Convert things like é ā or 〗 into normalized(bug 14952) text
*/
- $filteredText = Sanitizer::decodeCharReferences( $text );
+ $filteredText = Sanitizer::decodeCharReferencesAndNormalize( $text );
$t = new Title();
$t->mDbkeyform = str_replace( ' ', '_', $filteredText );
}
return $t;
} else {
- $ret = NULL;
+ $ret = null;
return $ret;
}
}
*
* Create a new Title from URL-encoded text. Ensures that
* the given title's length does not exceed the maximum.
+ *
* @param $url \type{\string} the title, as might be taken from a URL
* @return \type{Title} the new object, or NULL on an error
*/
if( $t->secureAndSplit() ) {
return $t;
} else {
- return NULL;
+ return null;
}
}
if( $row !== false ) {
$title = Title::newFromRow( $row );
} else {
- $title = NULL;
+ $title = null;
}
return $title;
}
/**
* Make an array of titles from an array of IDs
+ *
* @param $ids \type{\arrayof{\int}} Array of IDs
* @return \type{\arrayof{Title}} Array of Titles
*/
/**
* Make a Title object from a DB row
+ *
* @param $row \type{Row} (needs at least page_title,page_namespace)
* @return \type{Title} corresponding Title
*/
$t->mArticleID = isset($row->page_id) ? intval($row->page_id) : -1;
$t->mLength = isset($row->page_len) ? intval($row->page_len) : -1;
- $t->mRedirect = isset($row->page_is_redirect) ? (bool)$row->page_is_redirect : NULL;
+ $t->mRedirect = isset($row->page_is_redirect) ? (bool)$row->page_is_redirect : null;
$t->mLatestID = isset($row->page_latest) ? $row->page_latest : false;
return $t;
if( $t->secureAndSplit() ) {
return $t;
} else {
- return NULL;
+ return null;
}
- }
+ }
/**
* Create a new Title for the Main Page
+ *
* @return \type{Title} the new object
*/
public static function newMainPage() {
public static function newFromRedirect( $text ) {
return self::newFromRedirectInternal( $text );
}
-
+
/**
* Extract a redirect destination from a string and return the
* Title, or null if the text doesn't contain a valid redirect
$titles = self::newFromRedirectArray( $text );
return $titles ? array_pop( $titles ) : null;
}
-
+
/**
* Extract a redirect destination from a string and return an
* array of Titles, or null if the text doesn't contain a valid redirect
}
return $titles;
}
-
+
/**
* Really extract the redirect destination
* Do not call this function directly, use one of the newFromRedirect* functions above
/**
* Get the prefixed DB key associated with an ID
+ *
* @param $id \type{\int} the page_id of the article
* @return \type{Title} an object representing the article, or NULL
- * if no such article was found
+ * if no such article was found
*/
public static function nameOf( $id ) {
$dbr = wfGetDB( DB_SLAVE );
$s = $dbr->selectRow( 'page',
array( 'page_namespace','page_title' ),
- array( 'page_id' => $id ),
+ array( 'page_id' => $id ),
__METHOD__ );
- if ( $s === false ) { return NULL; }
+ if ( $s === false ) { return null; }
$n = self::makeName( $s->page_namespace, $s->page_title );
return $n;
/**
* Get a regex character class describing the legal characters in a link
+ *
* @return \type{\string} the list of characters, not delimited
*/
public static function legalChars() {
* @param $ns \type{\int} a namespace index
* @param $title \type{\string} text-form main part
* @return \type{\string} a stripped-down title string ready for the
- * search index
+ * search index
*/
public static function indexTitle( $ns, $title ) {
global $wgContLang;
$lc = SearchEngine::legalSearchChars() . '&#;';
- $t = $wgContLang->stripForSearch( $title );
+ $t = $wgContLang->normalizeForSearch( $title );
$t = preg_replace( "/[^{$lc}]+/", ' ', $t );
$t = $wgContLang->lc( $t );
/**
* Make a prefixed DB key from a DB key and a namespace index
+ *
* @param $ns \type{\int} numerical representation of the namespace
* @param $title \type{\string} the DB key form the title
* @param $fragment \type{\string} The link fragment (after the "#")
public function isTrans() {
if ($this->mInterwiki == '')
return false;
-
+
return Interwiki::fetch( $this->mInterwiki )->isTranscludable();
}
/**
* Escape a text fragment, say from a link, for a URL
+ *
+ * @param $fragment string containing a URL or link fragment (after the "#")
+ * @return String: escaped string
*/
static function escapeFragmentForURL( $fragment ) {
- global $wgEnforceHtmlIds;
# Note that we don't urlencode the fragment. urlencoded Unicode
# fragments appear not to work in IE (at least up to 7) or in at least
# one version of Opera 9.x. The W3C validator, for one, doesn't seem
# to care if they aren't encoded.
- return Sanitizer::escapeId( $fragment,
- $wgEnforceHtmlIds ? 'noninitial' : 'xml' );
+ return Sanitizer::escapeId( $fragment, 'noninitial' );
}
#----------------------------------------------------------------------------
/** Simple accessors */
/**
* Get the text form (spaces not underscores) of the main part
+ *
* @return \type{\string} Main part of the title
*/
public function getText() { return $this->mTextform; }
+
/**
* Get the URL-encoded form of the main part
+ *
* @return \type{\string} Main part of the title, URL-encoded
*/
public function getPartialURL() { return $this->mUrlform; }
+
/**
* Get the main part with underscores
+ *
* @return \type{\string} Main part of the title, with underscores
*/
public function getDBkey() { return $this->mDbkeyform; }
+
/**
* Get the namespace index, i.e.\ one of the NS_xxxx constants.
+ *
* @return \type{\int} Namespace index
*/
public function getNamespace() { return $this->mNamespace; }
+
/**
* Get the namespace text
+ *
* @return \type{\string} Namespace text
*/
public function getNsText() {
- global $wgContLang, $wgCanonicalNamespaceNames;
+ global $wgContLang;
- if ( '' != $this->mInterwiki ) {
+ if ( $this->mInterwiki != '' ) {
// This probably shouldn't even happen. ohh man, oh yuck.
// But for interwiki transclusion it sometimes does.
// Shit. Shit shit shit.
//
// Use the canonical namespaces if possible to try to
// resolve a foreign namespace.
- if( isset( $wgCanonicalNamespaceNames[$this->mNamespace] ) ) {
- return $wgCanonicalNamespaceNames[$this->mNamespace];
+ if( MWNamespace::exists( $this->mNamespace ) ) {
+ return MWNamespace::getCanonicalName( $this->mNamespace );
}
}
return $wgContLang->getNsText( $this->mNamespace );
}
+
/**
* Get the DB key with the initial letter case as specified by the user
+ *
* @return \type{\string} DB key
*/
function getUserCaseDBKey() {
return $this->mUserCaseDBKey;
}
+
/**
* Get the namespace text of the subject (rather than talk) page
+ *
* @return \type{\string} Namespace text
*/
public function getSubjectNsText() {
global $wgContLang;
return $wgContLang->getNsText( MWNamespace::getSubject( $this->mNamespace ) );
}
+
/**
* Get the namespace text of the talk page
+ *
* @return \type{\string} Namespace text
*/
public function getTalkNsText() {
global $wgContLang;
return( $wgContLang->getNsText( MWNamespace::getTalk( $this->mNamespace ) ) );
}
+
/**
* Could this title have a corresponding talk page?
+ *
* @return \type{\bool} TRUE or FALSE
*/
public function canTalk() {
return( MWNamespace::canTalk( $this->mNamespace ) );
}
+
/**
* Get the interwiki prefix (or null string)
+ *
* @return \type{\string} Interwiki prefix
*/
public function getInterwiki() { return $this->mInterwiki; }
+
/**
* Get the Title fragment (i.e.\ the bit after the #) in text form
+ *
* @return \type{\string} Title fragment
*/
public function getFragment() { return $this->mFragment; }
+
/**
* Get the fragment in URL form, including the "#" character if there is one
* @return \type{\string} Fragment in URL form
return '#' . Title::escapeFragmentForURL( $this->mFragment );
}
}
+
/**
* Get the default namespace index, for when there is no namespace
+ *
* @return \type{\int} Default namespace index
*/
public function getDefaultNamespace() { return $this->mDefaultNamespace; }
/**
* Get title for search index
+ *
* @return \type{\string} a stripped-down title string ready for the
- * search index
+ * search index
*/
public function getIndexTitle() {
return Title::indexTitle( $this->mNamespace, $this->mTextform );
/**
* Get the prefixed database key form
+ *
* @return \type{\string} the prefixed title, with underscores and
- * any interwiki and namespace prefixes
+ * any interwiki and namespace prefixes
*/
public function getPrefixedDBkey() {
$s = $this->prefix( $this->mDbkeyform );
/**
* Get the prefixed title with spaces.
* This is the form usually used for display
+ *
* @return \type{\string} the prefixed title, with spaces
*/
public function getPrefixedText() {
/**
* Get the prefixed title with spaces, plus any fragment
* (part beginning with '#')
+ *
* @return \type{\string} the prefixed title, with spaces and
- * the fragment, including '#'
+ * the fragment, including '#'
*/
public function getFullText() {
$text = $this->getPrefixedText();
- if( '' != $this->mFragment ) {
+ if( $this->mFragment != '' ) {
$text .= '#' . $this->mFragment;
}
return $text;
/**
* Get the base name, i.e. the leftmost parts before the /
+ *
* @return \type{\string} Base name
*/
public function getBaseText() {
/**
* Get the lowest-level subpage name, i.e. the rightmost part after /
+ *
* @return \type{\string} Subpage name
*/
public function getSubpageText() {
/**
* Get a URL-encoded form of the subpage text
+ *
* @return \type{\string} URL-encoded subpage name
*/
public function getSubpageUrlForm() {
/**
* Get a URL-encoded title (not an actual URL) including interwiki
+ *
* @return \type{\string} the URL-encoded form
*/
public function getPrefixedURL() {
$interwiki = Interwiki::fetch( $this->mInterwiki );
if ( !$interwiki ) {
- $url = $this->getLocalUrl( $query, $variant );
+ $url = $this->getLocalURL( $query, $variant );
// Ugly quick hack to avoid duplicate prefixes (bug 4571 etc)
// Correct fix would be to move the prepending elsewhere.
$baseUrl = $interwiki->getURL( );
$namespace = wfUrlencode( $this->getNsText() );
- if ( '' != $namespace ) {
+ if ( $namespace != '' ) {
# Can this actually happen? Interwikis shouldn't be parsed.
# Yes! It can in interwiki transclusion. But... it probably shouldn't.
$namespace .= ':';
/**
* Get a URL with no fragment or server name. If this page is generated
* with action=render, $wgServer is prepended.
- * @param mixed $query an optional query string; if not specified,
- * $wgArticlePath will be used. Can be specified as an associative array
+ *
+ * @param $query Mixed: an optional query string; if not specified,
+ * $wgArticlePath will be used. Can be specified as an associative array
* as well, e.g., array( 'action' => 'edit' ) (keys and values will be
* URL-escaped).
* @param $variant \type{\string} language variant of url (for sr, zh..)
/**
* Get an HTML-escaped version of the URL form, suitable for
* using in a link, without a server name or fragment
+ *
* @param $query \type{\string} an optional query string
* @return \type{\string} the URL
*/
/**
* Get the edit URL for this Title
+ *
* @return \type{\string} the URL, or a null string if this is an
- * interwiki link
+ * interwiki link
*/
public function getEditURL() {
- if ( '' != $this->mInterwiki ) { return ''; }
+ if ( $this->mInterwiki != '' ) { return ''; }
$s = $this->getLocalURL( 'action=edit' );
return $s;
/**
* Get the HTML-escaped displayable text form.
* Used for the title field in <a> tags.
+ *
* @return \type{\string} the text, including any prefixes
*/
public function getEscapedText() {
/**
* Is this Title interwiki?
+ *
* @return \type{\bool}
*/
- public function isExternal() { return ( '' != $this->mInterwiki ); }
+ public function isExternal() { return ( $this->mInterwiki != '' ); }
/**
* Is this page "semi-protected" - the *only* protection is autoconfirm?
*
- * @param @action \type{\string} Action to check (default: edit)
+ * @param $action \type{\string} Action to check (default: edit)
* @return \type{\bool}
*/
public function isSemiProtected( $action = 'edit' ) {
/**
* Does the title correspond to a protected article?
- * @param $what \type{\string} the action the page is protected from,
- * by default checks move and edit
+ *
+ * @param $action \type{\string} the action the page is protected from,
+ * by default checks all actions.
* @return \type{\bool}
*/
public function isProtected( $action = '' ) {
- global $wgRestrictionLevels, $wgRestrictionTypes;
+ global $wgRestrictionLevels;
+
+ $restrictionTypes = $this->getRestrictionTypes();
# Special pages have inherent protection
if( $this->getNamespace() == NS_SPECIAL )
return true;
# Check regular protection levels
- foreach( $wgRestrictionTypes as $type ){
+ foreach( $restrictionTypes as $type ){
if( $action == $type || $action == '' ) {
$r = $this->getRestrictions( $type );
foreach( $wgRestrictionLevels as $level ) {
return false;
}
+ /**
+ * Is this a conversion table for the LanguageConverter?
+ *
+ * @return \type{\bool}
+ */
+ public function isConversionTable() {
+ if($this->getNamespace() == NS_MEDIAWIKI
+ && strpos( $this->getText(), 'Conversiontable' ) !== false ) {
+ return true;
+ }
+
+ return false;
+ }
+
/**
* Is $wgUser watching this page?
+ *
* @return \type{\bool}
*/
public function userIsWatching() {
/**
* Can $wgUser perform $action on this page?
- * This skips potentially expensive cascading permission checks.
+ * This skips potentially expensive cascading permission checks
+ * as well as avoids expensive error formatting
*
* Suitable for use for nonessential UI controls in common cases, but
* _not_ for functional access control.
*
* @param $action \type{\string} action that permission needs to be checked for
* @return \type{\bool}
- */
+ */
public function quickUserCan( $action ) {
return $this->userCan( $action, false );
}
/**
* Can $wgUser perform $action on this page?
+ *
* @param $action \type{\string} action that permission needs to be checked for
* @param $doExpensiveQueries \type{\bool} Set this to false to avoid doing unnecessary queries.
* @return \type{\bool}
- */
+ */
public function userCan( $action, $doExpensiveQueries = true ) {
global $wgUser;
return ($this->getUserPermissionsErrorsInternal( $action, $wgUser, $doExpensiveQueries, true ) === array());
$intended = $user->mBlock->mAddress;
- $errors[] = array( ($block->mAuto ? 'autoblockedtext' : 'blockedtext'), $link, $reason, $ip, $name,
+ $errors[] = array( ($block->mAuto ? 'autoblockedtext' : 'blockedtext'), $link, $reason, $ip, $name,
$blockid, $blockExpiry, $intended, $blockTimestamp );
}
-
+
// Remove the errors being ignored.
-
+
foreach( $errors as $index => $error ) {
$error_key = is_array($error) ? $error[0] : $error;
-
+
if (in_array( $error_key, $ignoreErrors )) {
unset($errors[$index]);
}
// Show user page-specific message only if the user can move other pages
$errors[] = array( 'cant-move-user-page' );
}
-
+
// Check if user is allowed to move files if it's a file
if( $this->getNamespace() == NS_FILE && !$user->isAllowed( 'movefile' ) ) {
$errors[] = array( 'movenotallowedfile' );
}
-
+
if( !$user->isAllowed( 'move' ) ) {
// User can't move anything
global $wgGroupPermissions;
}
} elseif( !$user->isAllowed( $action ) ) {
$return = null;
- $groups = array_map( array( 'User', 'makeGroupLinkWiki' ),
- User::getGroupsWithPermission( $action ) );
+
+ // We avoid expensive display logic for quickUserCan's and such
+ $groups = false;
+ if (!$short) {
+ $groups = array_map( array( 'User', 'makeGroupLinkWiki' ),
+ User::getGroupsWithPermission( $action ) );
+ }
+
if( $groups ) {
- $return = array( 'badaccess-groups',
- array( implode( ', ', $groups ), count( $groups ) ) );
+ global $wgLang;
+ $return = array(
+ 'badaccess-groups',
+ $wgLang->commaList( $groups ),
+ count( $groups )
+ );
} else {
$return = array( "badaccess-group0" );
}
wfProfileOut( __METHOD__ );
return $errors;
}
-
+
# Only 'createaccount' and 'execute' can be performed on
# special pages, which don't actually exist in the DB.
$specialOKActions = array( 'createaccount', 'execute' );
# Protect css/js subpages of user pages
# XXX: this might be better using restrictions
- # XXX: Find a way to work around the php bug that prevents using $this->userCanEditCssSubpage()
+ # XXX: Find a way to work around the php bug that prevents using $this->userCanEditCssSubpage()
# and $this->userCanEditJsSubpage() from working
# XXX: right 'editusercssjs' is deprecated, for backward compatibility only
- if( $this->isCssSubpage() && ( !$user->isAllowed('editusercssjs') || !$user->isAllowed('editusercss') )
+ if( $this->isCssSubpage() && !( $user->isAllowed('editusercssjs') || $user->isAllowed('editusercss') )
&& $action != 'patrol'
&& !preg_match('/^'.preg_quote($user->getName(), '/').'\//', $this->mTextform) )
{
$errors[] = array('customcssjsprotected');
- } else if( $this->isJsSubpage() && ( !$user->isAllowed('editusercssjs') || !$user->isAllowed('edituserjs') )
+ } else if( $this->isJsSubpage() && !( $user->isAllowed('editusercssjs') || $user->isAllowed('edituserjs') )
&& $action != 'patrol'
&& !preg_match('/^'.preg_quote($user->getName(), '/').'\//', $this->mTextform) )
{
if( $right == 'sysop' ) {
$right = 'protect';
}
- if( '' != $right && !$user->isAllowed( $right ) ) {
+ if( $right != '' && !$user->isAllowed( $right ) ) {
// Users with 'editprotected' permission can edit protected pages
if( $action=='edit' && $user->isAllowed( 'editprotected' ) ) {
// Users with 'editprotected' permission cannot edit protected pages
wfProfileOut( __METHOD__ );
return $errors;
}
-
+
if( $doExpensiveQueries && !$this->isCssJsSubpage() ) {
# We /could/ use the protection level on the source page, but it's fairly ugly
# as we have to establish a precedence hierarchy for pages included by multiple
# Several cascading protected pages may include this page...
# Check each cascading level
# This is only for protection restrictions, not for all actions
- if( $cascadingSources > 0 && isset($restrictions[$action]) ) {
+ if( isset($restrictions[$action]) ) {
foreach( $restrictions[$action] as $right ) {
$right = ( $right == 'sysop' ) ? 'protect' : $right;
- if( '' != $right && !$user->isAllowed( $right ) ) {
+ if( $right != '' && !$user->isAllowed( $right ) ) {
$pages = '';
foreach( $cascadingSources as $page )
$pages .= '* [[:' . $page->getPrefixedText() . "]]\n";
/**
* Is this title subject to title protection?
+ *
* @return \type{\mixed} An associative array representing any existent title
* protection, or false if there's none.
*/
if ( $this->getNamespace() < 0 ) {
return false;
}
-
+
// Can't protect pages that exist.
if ($this->exists()) {
return false;
/**
* Update the title protection status
+ *
* @param $create_perm \type{\string} Permission required for creation
* @param $reason \type{\string} Reason for protection
* @param $expiry \type{\string} Expiry timestamp
+ * @return boolean true
*/
public function updateTitleProtection( $create_perm, $reason, $expiry ) {
global $wgUser,$wgContLang;
else {
$expiry_description .= ' (' . wfMsgForContent( 'protect-expiry-indefinite' ).')';
}
-
+
# Update protection table
if ($create_perm != '' ) {
$dbw->replace( 'protected_titles', array(array('pt_namespace', 'pt_title')),
$dbw = wfGetDB( DB_MASTER );
$dbw->delete( 'protected_titles',
- array( 'pt_namespace' => $this->getNamespace(), 'pt_title' => $this->getDBkey() ),
+ array( 'pt_namespace' => $this->getNamespace(), 'pt_title' => $this->getDBkey() ),
__METHOD__ );
}
/**
* Can $wgUser read this page?
- * @return \type{\bool} TRUE or FALSE
+ *
+ * @return \type{\bool}
* @todo fold these checks into userCan()
*/
public function userCanRead() {
global $wgUser, $wgGroupPermissions;
-
+
static $useShortcut = null;
# Initialize the $useShortcut boolean, to determine if we can skip quite a bit of code below
}
}
}
-
+
$result = null;
wfRunHooks( 'userCan', array( &$this, &$wgUser, 'read', &$result ) );
if ( $result !== null ) {
/**
* Is this a talk page of some sort?
- * @return \type{\bool} TRUE or FALSE
+ *
+ * @return \type{\bool}
*/
public function isTalkPage() {
return MWNamespace::isTalk( $this->getNamespace() );
/**
* Is this a subpage?
- * @return \type{\bool} TRUE or FALSE
+ *
+ * @return \type{\bool}
*/
public function isSubpage() {
return MWNamespace::hasSubpages( $this->mNamespace )
/**
* Does this have subpages? (Warning, usually requires an extra DB query.)
- * @return \type{\bool} TRUE or FALSE
+ *
+ * @return \type{\bool}
*/
public function hasSubpages() {
if( !MWNamespace::hasSubpages( $this->mNamespace ) ) {
return $this->mHasSubpages = (bool)$subpages->count();
return $this->mHasSubpages = false;
}
-
+
/**
* Get all subpages of this page.
+ *
* @param $limit Maximum number of subpages to fetch; -1 for no limit
* @return mixed TitleArray, or empty array if this page's namespace
* doesn't allow subpages
$dbr = wfGetDB( DB_SLAVE );
$conds['page_namespace'] = $this->getNamespace();
- $conds[] = 'page_title LIKE ' . $dbr->addQuotes(
- $dbr->escapeLike( $this->getDBkey() ) . '/%' );
+ $conds[] = 'page_title ' . $dbr->buildLike( $this->getDBkey() . '/', $dbr->anyString() );
$options = array();
if( $limit > -1 )
$options['LIMIT'] = $limit;
* Could this page contain custom CSS or JavaScript, based
* on the title?
*
- * @return \type{\bool} TRUE or FALSE
+ * @return \type{\bool}
*/
public function isCssOrJsPage() {
return $this->mNamespace == NS_MEDIAWIKI
/**
* Is this a .css or .js subpage of a user page?
- * @return \type{\bool} TRUE or FALSE
+ * @return \type{\bool}
*/
public function isCssJsSubpage() {
return ( NS_USER == $this->mNamespace and preg_match("/\\/.*\\.(?:css|js)$/", $this->mTextform ) );
}
+
/**
* Is this a *valid* .css or .js subpage of a user page?
* Check that the corresponding skin exists
- * @return \type{\bool} TRUE or FALSE
+ *
+ * @return \type{\bool}
*/
public function isValidCssJsSubpage() {
if ( $this->isCssJsSubpage() ) {
+ $name = $this->getSkinFromCssJsSubpage();
+ if ( $name == 'common' ) return true;
$skinNames = Skin::getSkinNames();
- return array_key_exists( $this->getSkinFromCssJsSubpage(), $skinNames );
+ return array_key_exists( $name, $skinNames );
} else {
return false;
}
}
+
/**
* Trim down a .css or .js subpage title to get the corresponding skin name
+ *
+ * @return string containing skin name from .css or .js subpage title
*/
public function getSkinFromCssJsSubpage() {
$subpage = explode( '/', $this->mTextform );
$subpage = $subpage[ count( $subpage ) - 1 ];
return( str_replace( array( '.css', '.js' ), array( '', '' ), $subpage ) );
}
+
/**
* Is this a .css subpage of a user page?
- * @return \type{\bool} TRUE or FALSE
+ *
+ * @return \type{\bool}
*/
public function isCssSubpage() {
return ( NS_USER == $this->mNamespace && preg_match("/\\/.*\\.css$/", $this->mTextform ) );
}
+
/**
* Is this a .js subpage of a user page?
- * @return \type{\bool} TRUE or FALSE
+ *
+ * @return \type{\bool}
*/
public function isJsSubpage() {
return ( NS_USER == $this->mNamespace && preg_match("/\\/.*\\.js$/", $this->mTextform ) );
}
+
/**
* Protect css subpages of user pages: can $wgUser edit
* this page?
*
- * @return \type{\bool} TRUE or FALSE
+ * @return \type{\bool}
* @todo XXX: this might be better using restrictions
*/
public function userCanEditCssSubpage() {
global $wgUser;
- return ( ( $wgUser->isAllowed('editusercssjs') && $wgUser->isAllowed('editusercss') )
+ return ( ( $wgUser->isAllowed('editusercssjs') && $wgUser->isAllowed('editusercss') )
|| preg_match('/^'.preg_quote($wgUser->getName(), '/').'\//', $this->mTextform) );
}
/**
* Protect js subpages of user pages: can $wgUser edit
* this page?
*
- * @return \type{\bool} TRUE or FALSE
+ * @return \type{\bool}
* @todo XXX: this might be better using restrictions
*/
public function userCanEditJsSubpage() {
global $wgUser;
return ( ( $wgUser->isAllowed('editusercssjs') && $wgUser->isAllowed('edituserjs') )
- || preg_match('/^'.preg_quote($wgUser->getName(), '/').'\//', $this->mTextform) );
+ || preg_match('/^'.preg_quote($wgUser->getName(), '/').'\//', $this->mTextform) );
}
/**
/**
* Cascading protection: Get the source of any cascading restrictions on this page.
*
- * @param $get_pages \type{\bool} Whether or not to retrieve the actual pages that the restrictions have come from.
- * @return \type{\arrayof{mixed title array, restriction array}} Array of the Title objects of the pages from
- * which cascading restrictions have come, false for none, or true if such restrictions exist, but $get_pages was not set.
- * The restriction array is an array of each type, each of which contains an array of unique groups.
+ * @param $get_pages \type{\bool} Whether or not to retrieve the actual pages
+ * that the restrictions have come from.
+ * @return \type{\arrayof{mixed title array, restriction array}} Array of the Title
+ * objects of the pages from which cascading restrictions have come,
+ * false for none, or true if such restrictions exist, but $get_pages was not set.
+ * The restriction array is an array of each type, each of which contains a
+ * array of unique groups.
*/
public function getCascadeProtectionSources( $get_pages = true ) {
- global $wgRestrictionTypes;
-
- # Define our dimension of restrictions types
$pagerestrictions = array();
- foreach( $wgRestrictionTypes as $action )
- $pagerestrictions[$action] = array();
if ( isset( $this->mCascadeSources ) && $get_pages ) {
return array( $this->mCascadeSources, $this->mCascadingRestrictions );
$sources[$page_id] = Title::makeTitle($page_ns, $page_title);
# Add groups needed for each restriction type if its not already there
# Make sure this restriction type still exists
- if ( isset($pagerestrictions[$row->pr_type]) && !in_array($row->pr_level, $pagerestrictions[$row->pr_type]) ) {
+
+ if ( !isset( $pagerestrictions[$row->pr_type] ) ) {
+ $pagerestrictions[$row->pr_type] = array();
+ }
+
+ if ( isset($pagerestrictions[$row->pr_type]) &&
+ !in_array($row->pr_level, $pagerestrictions[$row->pr_type]) ) {
$pagerestrictions[$row->pr_type][]=$row->pr_level;
}
} else {
return array( $sources, $pagerestrictions );
}
+ /**
+ * Returns cascading restrictions for the current article
+ *
+ * @return Boolean
+ */
function areRestrictionsCascading() {
if (!$this->mRestrictionsLoaded) {
$this->loadRestrictions();
/**
* Loads a string into mRestrictions array
+ *
* @param $res \type{Resource} restrictions as an SQL result.
+ * @param $oldFashionedRestrictions string comma-separated list of page
+ * restrictions from page table (pre 1.10)
*/
- private function loadRestrictionsFromResultWrapper( $res, $oldFashionedRestrictions = NULL ) {
+ private function loadRestrictionsFromResultWrapper( $res, $oldFashionedRestrictions = null ) {
$rows = array();
$dbr = wfGetDB( DB_SLAVE );
-
+
while( $row = $dbr->fetchObject( $res ) ) {
$rows[] = $row;
}
-
+
$this->loadRestrictionsFromRows( $rows, $oldFashionedRestrictions );
}
-
- public function loadRestrictionsFromRows( $rows, $oldFashionedRestrictions = NULL ) {
- global $wgRestrictionTypes;
+
+ /**
+ * Compiles list of active page restrictions from both page table (pre 1.10)
+ * and page_restrictions table
+ *
+ * @param $rows array of db result objects
+ * @param $oldFashionedRestrictions string comma-separated list of page
+ * restrictions from page table (pre 1.10)
+ */
+ public function loadRestrictionsFromRows( $rows, $oldFashionedRestrictions = null ) {
$dbr = wfGetDB( DB_SLAVE );
- foreach( $wgRestrictionTypes as $type ){
+ $restrictionTypes = $this->getRestrictionTypes();
+
+ foreach( $restrictionTypes as $type ){
$this->mRestrictions[$type] = array();
$this->mRestrictionsExpiry[$type] = Block::decodeExpiry('');
}
# Backwards-compatibility: also load the restrictions from the page record (old format).
- if ( $oldFashionedRestrictions === NULL ) {
- $oldFashionedRestrictions = $dbr->selectField( 'page', 'page_restrictions',
+ if ( $oldFashionedRestrictions === null ) {
+ $oldFashionedRestrictions = $dbr->selectField( 'page', 'page_restrictions',
array( 'page_id' => $this->getArticleId() ), __METHOD__ );
}
foreach( $rows as $row ) {
# Cycle through all the restrictions.
- // Don't take care of restrictions types that aren't in $wgRestrictionTypes
- if( !in_array( $row->pr_type, $wgRestrictionTypes ) )
+ // Don't take care of restrictions types that aren't allowed
+
+ if( !in_array( $row->pr_type, $restrictionTypes ) )
continue;
// This code should be refactored, now that it's being used more generally,
/**
* Load restrictions from the page_restrictions table
+ *
+ * @param $oldFashionedRestrictions string comma-separated list of page
+ * restrictions from page table (pre 1.10)
*/
- public function loadRestrictions( $oldFashionedRestrictions = NULL ) {
+ public function loadRestrictions( $oldFashionedRestrictions = null ) {
if( !$this->mRestrictionsLoaded ) {
if ($this->exists()) {
$dbr = wfGetDB( DB_SLAVE );
/**
* Get the expiry time for the restriction against a given action
- * @return 14-char timestamp, or 'infinity' if the page is protected forever
- * or not protected at all, or false if the action is not recognised.
+ *
+ * @return 14-char timestamp, or 'infinity' if the page is protected forever
+ * or not protected at all, or false if the action is not recognised.
*/
public function getRestrictionExpiry( $action ) {
if( !$this->mRestrictionsLoaded ) {
/**
* Is there a version of this page in the deletion archive?
+ *
* @return \type{\int} the number of archived revisions
*/
public function isDeleted() {
$n = 0;
} else {
$dbr = wfGetDB( DB_SLAVE );
- $n = $dbr->selectField( 'archive', 'COUNT(*)',
+ $n = $dbr->selectField( 'archive', 'COUNT(*)',
array( 'ar_namespace' => $this->getNamespace(), 'ar_title' => $this->getDBkey() ),
__METHOD__
);
}
return (int)$n;
}
-
+
/**
* Is there a version of this page in the deletion archive?
- * @return bool
+ *
+ * @return Boolean
*/
public function isDeletedQuick() {
if( $this->getNamespace() < 0 ) {
/**
* Get the article ID for this Title from the link cache,
* adding it if necessary
+ *
* @param $flags \type{\int} a bit field; may be GAID_FOR_UPDATE to select
- * for update
+ * for update
* @return \type{\int} the ID
*/
public function getArticleID( $flags = 0 ) {
/**
* Is this an article that is a redirect page?
* Uses link cache, adding it if necessary
+ *
* @param $flags \type{\int} a bit field; may be GAID_FOR_UPDATE to select for update
* @return \type{\bool}
*/
/**
* What is the length of this page?
* Uses link cache, adding it if necessary
+ *
* @param $flags \type{\int} a bit field; may be GAID_FOR_UPDATE to select for update
* @return \type{\bool}
*/
/**
* What is the page_latest field for this page?
+ *
* @param $flags \type{\int} a bit field; may be GAID_FOR_UPDATE to select for update
- * @return \type{\int}
+ * @return \type{\int} or false if the page doesn't exist
*/
public function getLatestRevID( $flags = 0 ) {
if( $this->mLatestID !== false )
return $this->mLatestID;
$db = ($flags & GAID_FOR_UPDATE) ? wfGetDB(DB_MASTER) : wfGetDB(DB_SLAVE);
- $this->mLatestID = $db->selectField( 'page', 'page_latest', $this->pageCond(), __METHOD__ );
+ $this->mLatestID = (int)$db->selectField(
+ 'page', 'page_latest', $this->pageCond(), __METHOD__ );
return $this->mLatestID;
}
$linkCache = LinkCache::singleton();
$linkCache->clearBadLink( $this->getPrefixedDBkey() );
- if ( $newid === false ) { $this->mArticleID = -1; }
- else { $this->mArticleID = $newid; }
+ if ( $newid === false ) {
+ $this->mArticleID = -1;
+ } else {
+ $this->mArticleID = intval( $newid );
+ }
$this->mRestrictionsLoaded = false;
$this->mRestrictions = array();
+ $this->mRedirect = null;
+ $this->mLength = -1;
+ $this->mLatestID = false;
}
/**
* Updates page_touched for this page; called from LinksUpdate.php
+ *
* @return \type{\bool} true if the update succeded
*/
public function invalidateCache() {
}
$dbw = wfGetDB( DB_MASTER );
$success = $dbw->update( 'page',
- array( 'page_touched' => $dbw->timestamp() ),
- $this->pageCond(),
+ array( 'page_touched' => $dbw->timestamp() ),
+ $this->pageCond(),
__METHOD__
);
HTMLFileCache::clearFileCache( $this );
*/
/* private */ function prefix( $name ) {
$p = '';
- if ( '' != $this->mInterwiki ) {
+ if ( $this->mInterwiki != '' ) {
$p = $this->mInterwiki . ':';
}
if ( 0 != $this->mNamespace ) {
}
/**
- * Secure and split - main initialisation function for this object
+ * Returns a simple regex that will match on characters and sequences invalid in titles.
+ * Note that this doesn't pick up many things that could be wrong with titles, but that
+ * replacing this regex with something valid will make many titles valid.
*
- * Assumes that mDbkeyform has been set, and is urldecoded
- * and uses underscores, but not otherwise munged. This function
- * removes illegal characters, splits off the interwiki and
- * namespace prefixes, sets the other forms, and canonicalizes
- * everything.
- * @return \type{\bool} true on success
+ * @return string regex string
*/
- private function secureAndSplit() {
- global $wgContLang, $wgLocalInterwiki, $wgCapitalLinks;
-
- # Initialisation
+ static function getTitleInvalidRegex() {
static $rxTc = false;
if( !$rxTc ) {
# Matching titles will be held as illegal.
'/S';
}
+ return $rxTc;
+ }
+
+ /**
+ * Capitalize a text string for a title if it belongs to a namespace that capitalizes
+ *
+ * @param $text string containing title to capitalize
+ * @param $ns int namespace index, defaults to NS_MAIN
+ * @return String containing capitalized title
+ */
+ public static function capitalize( $text, $ns = NS_MAIN ) {
+ global $wgContLang;
+
+ if ( MWNamespace::isCapitalized( $ns ) )
+ return $wgContLang->ucfirst( $text );
+ else
+ return $text;
+ }
+
+ /**
+ * Secure and split - main initialisation function for this object
+ *
+ * Assumes that mDbkeyform has been set, and is urldecoded
+ * and uses underscores, but not otherwise munged. This function
+ * removes illegal characters, splits off the interwiki and
+ * namespace prefixes, sets the other forms, and canonicalizes
+ * everything.
+ *
+ * @return \type{\bool} true on success
+ */
+ private function secureAndSplit() {
+ global $wgContLang, $wgLocalInterwiki;
+
+ # Initialisation
+ $rxTc = self::getTitleInvalidRegex();
+
$this->mInterwiki = $this->mFragment = '';
$this->mNamespace = $this->mDefaultNamespace; # Usually NS_MAIN
$dbkey = preg_replace( '/\xE2\x80[\x8E\x8F\xAA-\xAE]/S', '', $dbkey );
# Clean up whitespace
+ # Note: use of the /u option on preg_replace here will cause
+ # input with invalid UTF-8 sequences to be nullified out in PHP 5.2.x,
+ # conveniently disabling them.
#
- $dbkey = preg_replace( '/[ _]+/', '_', $dbkey );
+ $dbkey = preg_replace( '/[ _\xA0\x{1680}\x{180E}\x{2000}-\x{200A}\x{2028}\x{2029}\x{202F}\x{205F}\x{3000}]+/u', '_', $dbkey );
$dbkey = trim( $dbkey, '_' );
- if ( '' == $dbkey ) {
+ if ( $dbkey == '' ) {
return false;
}
$m = array();
if ( preg_match( $prefixRegexp, $dbkey, $m ) ) {
$p = $m[1];
- if ( $ns = $wgContLang->getNsIndex( $p ) ) {
+ if ( ( $ns = $wgContLang->getNsIndex( $p ) ) !== false ) {
# Ordinary namespace
$dbkey = $m[2];
$this->mNamespace = $ns;
# We already know that some pages won't be in the database!
#
- if ( '' != $this->mInterwiki || NS_SPECIAL == $this->mNamespace ) {
+ if ( $this->mInterwiki != '' || NS_SPECIAL == $this->mNamespace ) {
$this->mArticleID = 0;
}
$fragment = strstr( $dbkey, '#' );
* site might be case-sensitive.
*/
$this->mUserCaseDBKey = $dbkey;
- if( $wgCapitalLinks && $this->mInterwiki == '') {
- $dbkey = $wgContLang->ucfirst( $dbkey );
+ if( $this->mInterwiki == '') {
+ $dbkey = self::capitalize( $dbkey, $this->mNamespace );
}
/**
/**
* Set the fragment for this title. Removes the first character from the
- * specified fragment before setting, so it assumes you're passing it with
+ * specified fragment before setting, so it assumes you're passing it with
* an initial "#".
*
* Deprecated for public use, use Title::makeTitle() with fragment parameter.
/**
* Get a Title object associated with the talk page of this article
+ *
* @return \type{Title} the object for the talk page
*/
public function getTalkPage() {
* WARNING: do not use this function on arbitrary user-supplied titles!
* On heavily-used templates it will max out the memory.
*
- * @param array $options may be FOR UPDATE
+ * @param $options Array: may be FOR UPDATE
+ * @param $table String: table name
+ * @param $prefix String: fields prefix
* @return \type{\arrayof{Title}} the Title objects linking here
*/
public function getLinksTo( $options = array(), $table = 'pagelinks', $prefix = 'pl' ) {
* WARNING: do not use this function on arbitrary user-supplied titles!
* On heavily-used templates it will max out the memory.
*
- * @param array $options may be FOR UPDATE
+ * @param $options Array: may be FOR UPDATE
* @return \type{\arrayof{Title}} the Title objects linking here
*/
public function getTemplateLinksTo( $options = array() ) {
),
__METHOD__, array(),
array(
- 'page' => array(
- 'LEFT JOIN',
+ 'page' => array(
+ 'LEFT JOIN',
array( 'pl_namespace=page_namespace', 'pl_title=page_title' )
)
)
/**
* Move this page without authentication
- * @param &$nt \type{Title} the new page Title
+ *
+ * @param $nt \type{Title} the new page Title
+ * @return \type{\mixed} true on success, getUserPermissionsErrors()-like array on failure
*/
public function moveNoAuth( &$nt ) {
return $this->moveTo( $nt, false );
/**
* Check whether a given move operation would be valid.
* Returns true if ok, or a getUserPermissionsErrors()-like array otherwise
- * @param &$nt \type{Title} the new title
+ *
+ * @param $nt \type{Title} the new title
* @param $auth \type{\bool} indicates whether $wgUser's permissions
- * should be checked
+ * should be checked
* @param $reason \type{\string} is the log summary of the move, used for spam checking
* @return \type{\mixed} True on success, getUserPermissionsErrors()-like array on failure
*/
public function isValidMoveOperation( &$nt, $auth = true, $reason = '' ) {
global $wgUser;
- $errors = array();
+ $errors = array();
if( !$nt ) {
// Normally we'd add this to $errors, but we'll get
// lots of syntax errors if $nt is not an object
if ( strlen( $nt->getDBkey() ) < 1 ) {
$errors[] = array('articleexists');
}
- if ( ( '' == $this->getDBkey() ) ||
+ if ( ( $this->getDBkey() == '' ) ||
( !$oldid ) ||
- ( '' == $nt->getDBkey() ) ) {
+ ( $nt->getDBkey() == '' ) ) {
$errors[] = array('badarticleerror');
}
$errors[] = array('imagetypemismatch');
}
}
+ $destfile = wfLocalFile( $nt );
+ if( !$wgUser->isAllowed( 'reupload-shared' ) && !$destfile->exists() && wfFindFile( $nt ) ) {
+ $errors[] = array( 'file-exists-sharedrepo' );
+ }
+
}
if ( $auth ) {
// This is kind of lame, won't display nice
$errors[] = array('spamprotectiontext');
}
-
+
$err = null;
if( !wfRunHooks( 'AbortMove', array( $this, $nt, $wgUser, &$err, $reason ) ) ) {
$errors[] = array('hookaborted', $err);
/**
* Move a title to a new location
- * @param &$nt \type{Title} the new title
+ *
+ * @param $nt \type{Title} the new title
* @param $auth \type{\bool} indicates whether $wgUser's permissions
- * should be checked
+ * should be checked
* @param $reason \type{\string} The reason for the move
* @param $createRedirect \type{\bool} Whether to create a redirect from the old title to the new title.
* Ignored if the user doesn't have the suppressredirect right.
return $err;
}
- // If it is a file, more it first. It is done before all other moving stuff is done because it's hard to revert
+ // If it is a file, move it first. It is done before all other moving stuff is done because it's hard to revert
$dbw = wfGetDB( DB_MASTER );
if( $this->getNamespace() == NS_FILE ) {
$file = wfLocalFile( $this );
if( $protected ) {
# Protect the redirect title as the title used to be...
$dbw->insertSelect( 'page_restrictions', 'page_restrictions',
- array(
+ array(
'pr_page' => $redirid,
'pr_type' => 'pr_type',
'pr_level' => 'pr_level',
* Move page to a title which is at present a redirect to the
* source page
*
- * @param &$nt \type{Title} the page to move to, which should currently
- * be a redirect
+ * @param $nt \type{Title} the page to move to, which should currently
+ * be a redirect
* @param $reason \type{\string} The reason for the move
* @param $createRedirect \type{\bool} Whether to leave a redirect at the old title.
* Ignored if the user doesn't have the suppressredirect right
*/
private function moveOverExistingRedirect( &$nt, $reason = '', $createRedirect = true ) {
- global $wgUseSquid, $wgUser;
- $fname = 'Title::moveOverExistingRedirect';
+ global $wgUseSquid, $wgUser, $wgContLang;
+
$comment = wfMsgForContent( '1movedto2_redir', $this->getPrefixedText(), $nt->getPrefixedText() );
if ( $reason ) {
- $comment .= ": $reason";
+ $comment .= wfMsgForContent( 'colon-separator' ) . $reason;
}
+ # Truncate for whole multibyte characters. +5 bytes for ellipsis
+ $comment = $wgContLang->truncate( $comment, 250 );
$now = wfTimestampNow();
$newid = $nt->getArticleID();
$oldid = $this->getArticleID();
$latest = $this->getLatestRevID();
+
+ $dbw = wfGetDB( DB_MASTER );
+
$rcts = $dbw->timestamp( $nt->getEarliestRevTime() );
$newns = $nt->getNamespace();
$newdbk = $nt->getDBkey();
- $dbw = wfGetDB( DB_MASTER );
-
# Delete the old redirect. We don't save it to history since
# by definition if we've got here it's rather uninteresting.
# We have to remove it so that the next step doesn't trigger
# a conflict on the unique namespace+title index...
- $dbw->delete( 'page', array( 'page_id' => $newid ), $fname );
+ $dbw->delete( 'page', array( 'page_id' => $newid ), __METHOD__ );
if ( !$dbw->cascadingDeletes() ) {
$dbw->delete( 'revision', array( 'rev_page' => $newid ), __METHOD__ );
global $wgUseTrackbacks;
$dbw->delete( 'langlinks', array( 'll_from' => $newid ), __METHOD__ );
$dbw->delete( 'redirect', array( 'rd_from' => $newid ), __METHOD__ );
}
- // If the redirect was recently created, it may have an entry in recentchanges still
- $dbw->delete( 'recentchanges',
- array( 'rc_timestamp' => $rcts, 'rc_namespace' => $newns, 'rc_title' => $newdbk, 'rc_new' => 1 ),
+ // If the redirect was recently created, it may have an entry in recentchanges still
+ $dbw->delete( 'recentchanges',
+ array( 'rc_timestamp' => $rcts, 'rc_namespace' => $newns, 'rc_title' => $newdbk, 'rc_new' => 1 ),
__METHOD__
);
# Save a null revision in the page's history notifying of the move
$nullRevision = Revision::newNullRevision( $dbw, $oldid, $comment, true );
$nullRevId = $nullRevision->insertOn( $dbw );
-
+
$article = new Article( $this );
wfRunHooks( 'NewRevisionFromEditComplete', array($article, $nullRevision, $latest, $wgUser) );
'page_latest' => $nullRevId,
),
/* WHERE */ array( 'page_id' => $oldid ),
- $fname
+ __METHOD__
);
$nt->resetArticleID( $oldid );
'text' => $redirectText ) );
$redirectRevision->insertOn( $dbw );
$redirectArticle->updateRevisionOn( $dbw, $redirectRevision, 0 );
-
+
wfRunHooks( 'NewRevisionFromEditComplete', array($redirectArticle, $redirectRevision, false, $wgUser) );
# Now, we record the link from the redirect to the new title.
# It should have no other outgoing links...
- $dbw->delete( 'pagelinks', array( 'pl_from' => $newid ), $fname );
+ $dbw->delete( 'pagelinks', array( 'pl_from' => $newid ), __METHOD__ );
$dbw->insert( 'pagelinks',
array(
'pl_from' => $newid,
'pl_namespace' => $nt->getNamespace(),
'pl_title' => $nt->getDBkey() ),
- $fname );
+ __METHOD__ );
$redirectSuppressed = false;
} else {
$this->resetArticleID( 0 );
$u = new SquidUpdate( $urls );
$u->doUpdate();
}
-
+
}
/**
* Move page to non-existing title.
- * @param &$nt \type{Title} the new Title
+ *
+ * @param $nt \type{Title} the new Title
* @param $reason \type{\string} The reason for the move
* @param $createRedirect \type{\bool} Whether to create a redirect from the old title to the new title
* Ignored if the user doesn't have the suppressredirect right
*/
private function moveToNewTitle( &$nt, $reason = '', $createRedirect = true ) {
- global $wgUseSquid, $wgUser;
- $fname = 'MovePageForm::moveToNewTitle';
+ global $wgUseSquid, $wgUser, $wgContLang;
+
$comment = wfMsgForContent( '1movedto2', $this->getPrefixedText(), $nt->getPrefixedText() );
if ( $reason ) {
$comment .= wfMsgExt( 'colon-separator',
array( 'escapenoentities', 'content' ) );
$comment .= $reason;
}
+ # Truncate for whole multibyte characters. +5 bytes for ellipsis
+ $comment = $wgContLang->truncate( $comment, 250 );
$newid = $nt->getArticleID();
$oldid = $this->getArticleID();
$latest = $this->getLatestRevId();
-
+
$dbw = wfGetDB( DB_MASTER );
$now = $dbw->timestamp();
# Save a null revision in the page's history notifying of the move
$nullRevision = Revision::newNullRevision( $dbw, $oldid, $comment, true );
+ if ( !is_object( $nullRevision ) ) {
+ throw new MWException( 'No valid null revision produced in ' . __METHOD__ );
+ }
$nullRevId = $nullRevision->insertOn( $dbw );
-
+
$article = new Article( $this );
wfRunHooks( 'NewRevisionFromEditComplete', array($article, $nullRevision, $latest, $wgUser) );
'page_latest' => $nullRevId,
),
/* WHERE */ array( 'page_id' => $oldid ),
- $fname
+ __METHOD__
);
$nt->resetArticleID( $oldid );
'text' => $redirectText ) );
$redirectRevision->insertOn( $dbw );
$redirectArticle->updateRevisionOn( $dbw, $redirectRevision, 0 );
-
+
wfRunHooks( 'NewRevisionFromEditComplete', array($redirectArticle, $redirectRevision, false, $wgUser) );
# Record the just-created redirect's linking to the page
'pl_from' => $newid,
'pl_namespace' => $nt->getNamespace(),
'pl_title' => $nt->getDBkey() ),
- $fname );
+ __METHOD__ );
$redirectSuppressed = false;
} else {
$this->resetArticleID( 0 );
# Purge old title from squid
# The new title, and links to the new title, are purged in Article::onArticleCreate()
$this->purgeSquid();
-
+
}
-
+
/**
* Move this page's subpages to be subpages of $nt
+ *
* @param $nt Title Move target
* @param $auth bool Whether $wgUser's permissions should be checked
* @param $reason string The reason for the move
break;
}
- if( $oldSubpage->getArticleId() == $this->getArticleId() )
+ // We don't know whether this function was called before
+ // or after moving the root page, so check both
+ // $this and $nt
+ if( $oldSubpage->getArticleId() == $this->getArticleId() ||
+ $oldSubpage->getArticleID() == $nt->getArticleId() )
// When moving a page to a subpage of itself,
// don't move it twice
continue;
$newPageName = preg_replace(
'#^'.preg_quote( $this->getDBkey(), '#' ).'#',
- $nt->getDBkey(), $oldSubpage->getDBkey() );
+ StringUtils::escapeRegexReplacement( $nt->getDBkey() ), # bug 21234
+ $oldSubpage->getDBkey() );
if( $oldSubpage->isTalkPage() ) {
$newNs = $nt->getTalkPage()->getNamespace();
} else {
}
return $retval;
}
-
+
/**
* Checks if this page is just a one-rev redirect.
* Adds lock, so don't use just for light purposes.
*
- * @return \type{\bool} TRUE or FALSE
+ * @return \type{\bool}
*/
public function isSingleRevRedirect() {
$dbw = wfGetDB( DB_MASTER );
'page_title' => $this->getDBkey(),
'page_id=rev_page',
'page_latest != rev_id'
- ),
+ ),
__METHOD__,
array( 'FOR UPDATE' )
);
* Checks if $this can be moved to a given Title
* - Selects for update, so don't call it unless you mean business
*
- * @param &$nt \type{Title} the new title to check
+ * @param $nt \type{Title} the new title to check
* @return \type{\bool} TRUE or FALSE
*/
public function isValidMoveTarget( $nt ) {
/**
* Get a tree of parent categories
+ *
* @param $children \type{\array} an array with the children in the keys, to check for circular refs
* @return \type{\array} Tree of parent categories
*/
public function getParentCategoryTree( $children = array() ) {
- $stack = array();
+ $stack = array();
$parents = $this->getParentCategories();
if( $parents ) {
array( 'ORDER BY' => 'rev_id' )
);
}
-
+
/**
* Get the first revision of the page
*
public function getFirstRevision( $flags=0 ) {
$db = ($flags & GAID_FOR_UPDATE) ? wfGetDB( DB_MASTER ) : wfGetDB( DB_SLAVE );
$pageId = $this->getArticleId($flags);
- if( !$pageId ) return NULL;
+ if( !$pageId ) return null;
$row = $db->selectRow( 'revision', '*',
array( 'rev_page' => $pageId ),
__METHOD__,
array( 'ORDER BY' => 'rev_timestamp ASC', 'LIMIT' => 1 )
);
if( !$row ) {
- return NULL;
+ return null;
} else {
return new Revision( $row );
}
}
-
+
/**
* Check if this is a new page
*
/**
* Get the oldest revision timestamp of this page
*
- * @return string, MW timestamp
+ * @return String: MW timestamp
*/
public function getEarliestRevTime() {
$dbr = wfGetDB( DB_SLAVE );
*/
public function countRevisionsBetween( $old, $new ) {
$dbr = wfGetDB( DB_SLAVE );
- return $dbr->selectField( 'revision', 'count(*)',
+ return (int)$dbr->selectField( 'revision', 'count(*)',
'rev_page = ' . intval( $this->getArticleId() ) .
' AND rev_id > ' . intval( $old ) .
' AND rev_id < ' . intval( $new ),
/**
* Compare with another title.
*
- * @param \type{Title} $title
+ * @param $title \type{Title}
* @return \type{\bool} TRUE or FALSE
*/
public function equals( Title $title ) {
/**
* Callback for usort() to do title sorts by (namespace, title)
+ *
+ * @return Integer: result of string comparison, or namespace comparison
*/
public static function compare( $a, $b ) {
if( $a->getNamespace() == $b->getNamespace() ) {
* If you want to know if a title can be meaningfully viewed, you should
* probably call the isKnown() method instead.
*
- * @return \type{\bool} TRUE or FALSE
+ * @return \type{\bool}
*/
public function exists() {
return $this->getArticleId() != 0;
* existing code, but we might want to add an optional parameter to skip
* it and any other expensive checks.)
*
- * @return \type{\bool} TRUE or FALSE
+ * @return \type{\bool}
*/
public function isAlwaysKnown() {
if( $this->mInterwiki != '' ) {
// If the page is form Mediawiki:message/lang, calling wfMsgWeirdKey causes
// the full l10n of that language to be loaded. That takes much memory and
// isn't needed. So we strip the language part away.
- // Also, extension messages which are not loaded, are shown as red, because
- // we don't call MessageCache::loadAllMessages.
list( $basename, /* rest */ ) = explode( '/', $this->mDbkeyform, 2 );
- return wfMsgWeirdKey( $basename ); // known system message
+ return (bool)wfMsgWeirdKey( $basename ); // known system message
default:
return false;
}
* links to the title should be rendered as "bluelinks" (as opposed to
* "redlinks" to non-existent pages).
*
- * @return \type{\bool} TRUE or FALSE
+ * @return \type{\bool}
*/
public function isKnown() {
return $this->exists() || $this->isAlwaysKnown();
}
-
+
+ /**
+ * Does this page have source text?
+ *
+ * @return Boolean
+ */
+ public function hasSourceText() {
+ if ( $this->exists() )
+ return true;
+
+ if ( $this->mNamespace == NS_MEDIAWIKI ) {
+ // If the page doesn't exist but is a known system message, default
+ // message content will be displayed, same for language subpages
+ // Also, if the page is form Mediawiki:message/lang, calling wfMsgWeirdKey
+ // causes the full l10n of that language to be loaded. That takes much
+ // memory and isn't needed. So we strip the language part away.
+ list( $basename, /* rest */ ) = explode( '/', $this->mDbkeyform, 2 );
+ return (bool)wfMsgWeirdKey( $basename );
+ }
+
+ return false;
+ }
+
/**
* Is this in a namespace that allows actual pages?
*
- * @return \type{\bool} TRUE or FALSE
+ * @return \type{\bool}
+ * @internal note -- uses hardcoded namespace index instead of constants
*/
public function canExist() {
- return $this->mNamespace >= 0 && $this->mNamespace != NS_MEDIA;
+ return $this->mNamespace >=0 && $this->mNamespace != NS_MEDIA;
}
/**
/**
* Get the last touched timestamp
- * @param Database $db, optional db
+ *
+ * @param $db DatabaseBase: optional db
* @return \type{\string} Last touched timestamp
*/
- public function getTouched( $db = NULL ) {
+ public function getTouched( $db = null ) {
$db = isset($db) ? $db : wfGetDB( DB_SLAVE );
$touched = $db->selectField( 'page', 'page_touched', $this->pageCond(), __METHOD__ );
return $touched;
/**
* Get the timestamp when this page was updated since the user last saw it.
- * @param User $user
- * @return mixed string/NULL
+ *
+ * @param $user User
+ * @return Mixed: string/null
*/
- public function getNotificationTimestamp( $user = NULL ) {
+ public function getNotificationTimestamp( $user = null ) {
global $wgUser, $wgShowUpdatedMarker;
// Assume current user if none given
if( !$user ) $user = $wgUser;
/**
* Get the trackback URL for this page
+ *
* @return \type{\string} Trackback URL
*/
public function trackbackURL() {
/**
* Get the trackback RDF for this page
+ *
* @return \type{\string} Trackback RDF
*/
public function trackbackRDF() {
/**
* Generate strings used for xml 'id' names in monobook tabs
+ *
+ * @param $prepend string defaults to 'nstab-'
* @return \type{\string} XML 'id' name
*/
public function getNamespaceKey( $prepend = 'nstab-' ) {
- global $wgContLang, $wgCanonicalNamespaceNames;
+ global $wgContLang;
// Gets the subject namespace if this title
$namespace = MWNamespace::getSubject( $this->getNamespace() );
// Checks if cononical namespace name exists for namespace
- if ( isset( $wgCanonicalNamespaceNames[$namespace] ) ) {
+ if ( MWNamespace::exists( $this->getNamespace() ) ) {
// Uses canonical namespace name
- $namespaceKey = $wgCanonicalNamespaceNames[$namespace];
+ $namespaceKey = MWNamespace::getCanonicalName( $namespace );
} else {
// Uses text of namespace
$namespaceKey = $this->getSubjectNsText();
return $prepend . $namespaceKey;
}
+ /**
+ * Returns true if this is a special page.
+ *
+ * @return boolean
+ */
+ public function isSpecialPage( ) {
+ return $this->getNamespace() == NS_SPECIAL;
+ }
+
/**
* Returns true if this title resolves to the named special page
+ *
* @param $name \type{\string} The special page name
+ * @return boolean
*/
public function isSpecial( $name ) {
if ( $this->getNamespace() == NS_SPECIAL ) {
/**
* If the Title refers to a special page alias which is not the local default,
- * @return \type{Title} A new Title which points to the local default. Otherwise, returns $this.
+ *
+ * @return \type{Title} A new Title which points to the local default.
+ * Otherwise, returns $this.
*/
public function fixSpecialName() {
if ( $this->getNamespace() == NS_SPECIAL ) {
* In other words, is this a content page, for the purposes of calculating
* statistics, etc?
*
- * @return \type{\bool} TRUE or FALSE
+ * @return \type{\bool}
*/
public function isContentPage() {
return MWNamespace::isContent( $this->getNamespace() );
/**
* Get all extant redirects to this Title
*
- * @param $ns \twotypes{\int,\null} Single namespace to consider;
+ * @param $ns \twotypes{\int,\null} Single namespace to consider;
* NULL to consider all namespaces
* @return \type{\arrayof{Title}} Redirects to this title
*/
public function getRedirectsHere( $ns = null ) {
$redirs = array();
-
- $dbr = wfGetDB( DB_SLAVE );
+
+ $dbr = wfGetDB( DB_SLAVE );
$where = array(
'rd_namespace' => $this->getNamespace(),
'rd_title' => $this->getDBkey(),
'rd_from = page_id'
);
if ( !is_null($ns) ) $where['page_namespace'] = $ns;
-
+
$res = $dbr->select(
array( 'redirect', 'page' ),
array( 'page_namespace', 'page_title' ),
}
return $redirs;
}
-
+
/**
* Check if this Title is a valid redirect target
*
- * @return \type{\bool} TRUE or FALSE
+ * @return \type{\bool}
*/
public function isValidRedirectTarget() {
global $wgInvalidRedirectTargets;
-
+
// invalid redirect targets are stored in a global array, but explicity disallow Userlogout here
if( $this->isSpecial( 'Userlogout' ) ) {
return false;
}
-
+
foreach( $wgInvalidRedirectTargets as $target ) {
if( $this->isSpecial( $target ) ) {
return false;
}
}
-
+
return true;
}
/**
* Get a backlink cache object
+ *
+ * @return object BacklinkCache
*/
function getBacklinkCache() {
if ( is_null( $this->mBacklinkCache ) ) {
}
return $this->mBacklinkCache;
}
+
+ /**
+ * Whether the magic words __INDEX__ and __NOINDEX__ function for
+ * this page.
+ *
+ * @return Boolean
+ */
+ public function canUseNoindex(){
+ global $wgArticleRobotPolicies, $wgContentNamespaces,
+ $wgExemptFromUserRobotsControl;
+
+ $bannedNamespaces = is_null( $wgExemptFromUserRobotsControl )
+ ? $wgContentNamespaces
+ : $wgExemptFromUserRobotsControl;
+
+ return !in_array( $this->mNamespace, $bannedNamespaces );
+
+ }
+
+ /**
+ * Returns restriction types for the current Title
+ *
+ * @return array applicable restriction types
+ */
+ public function getRestrictionTypes() {
+ global $wgRestrictionTypes;
+ $types = $this->exists() ? $wgRestrictionTypes : array('create');
+
+ if ( $this->getNamespace() == NS_FILE ) {
+ $types[] = 'upload';
+ }
+
+ wfRunHooks( 'TitleGetRestrictionTypes', array( $this, &$types ) );
+
+ return $types;
+ }
}