Extension:VirtualPage

require('extensions/StubManager.php');
require('extensions/VirtualPage/VirtualPage.php');

$wgExtensionCredits[VirtualPage::thisType][] = array( 
	'name'    		=> VirtualPage::thisName, 
	'version'		=> StubManager::getRevisionId( '$Id: VirtualPage.php 619 2007-08-08 18:20:01Z jeanlou.dupont $' ),
	'author'		=> 'Jean-Lou Dupont', 
	'description'	=>  'Provides configurable per-namespace virtual pages',
	'url' 			=> StubManager::getFullUrl(__FILE__),			
);
 
class VirtualArticle extends Article
{
	var $virtualTitle;
	var $mDbkeyform;		// variable to undo THE ugly hack.
 
	/**
		The situation is the following:
		- $this contains the 'template page' content
		- $this->virtualTitle contains the virtual title (duh!)
 
		What we need to do here: display the template page
		with:
		- correct title
		- correct skin 
		- correct actions etc.
		as if the page was really the 'virtual' one.
	 */
	function view()
	{
		global $wgOut;
		global $wgNamespaceRobotPolicies;
		global $wgEnableParserCache;
		global $wgUser;
 
		// undo our little hack.
		$this->virtualTitle->mDbkeyform = $this->mDbkeyform;
 
//{{
		# Discourage indexing of printable versions, but encourage following
		if( $wgOut->isPrintable() ) {
			$policy = 'noindex,follow';
		} elseif( isset( $wgNamespaceRobotPolicies[$ns] ) ) {
			# Honour customised robot policies for this namespace
			$policy = $wgNamespaceRobotPolicies[$ns];
		} else {
			# Default to encourage indexing and following links
			$policy = 'index,follow';
		}
		$wgOut->setRobotPolicy( $policy );
//}}
 
		//case #1: the content is available in the parser cache.
		$parserCache =& ParserCache::singleton();
 
		# Should the parser cache be used?
		$pcache = $wgEnableParserCache &&
			intval( $wgUser->getOption( 'stubthreshold' ) ) == 0 &&
			$this->exists() &&
			empty( $oldid );
 
		$outputDone = false;
		wfRunHooks( 'ArticleViewHeader', array( &$this ) );
		if ( $pcache ) 
		{
			if ( $wgOut->tryParserCache( $this, $wgUser ) ) 
			{
				$outputDone = true;
			}
		}
 
		// case #2: the content is available in the database
		// We need to feed the correct 'title' object
 
		$this->mTitle = $this->templateTitle;
//{{
		if ( !$outputDone ) 
		{
			$text = $this->getContent();
			if ( $text === false ) {
				# Failed to load, replace text with error message
				$t = $this->mTitle->getPrefixedText();
				if( $oldid ) {
					$t .= ',oldid='.$oldid;
					$text = wfMsg( 'missingarticle', $t );
				} else {
					$text = wfMsg( 'noarticletext', $t );
				}
			}
		}
//}}
		// Put in place the necessary title corresponding
		// to the virtual page requested.
		$this->mTitle = $this->virtualTitle;
		global $wgTitle;
		$wgTitle = $this->mTitle;
 
		$wgOut->mTitle = $this->mTitle;
 
//{{	
		# Another whitelist check in case oldid is altering the title
		if ( !$this->mTitle->userCanRead() ) 
		{
			$wgOut->loginToUse();
			$wgOut->output();
			exit;
		}
//}}		
		# Display content and save to parser cache
		if ( $pcache )
			$this->outputWikiText( $text );
		else
			$this->outputWikiText( $text, false );
 
		$wgOut->setPageTitle( $this->mTitle->getPrefixedText() );		
 
 
		$this->viewUpdates();			
	} // view method
 
}//end class VirtualArticle
 
class VirtualPage
{
	const thisName = 'VirtualPage';
	const thisType = 'other';  // must use this type in order to display useful info in Special:Version
 
	const vdName   = 'VirtualDirectory';
 
	public function __construct() {	}
 
	/**
		This hook gets called when a title does not have
		a corresponding article in the database.
 
		The method retrieves the 'VirtualDirectory' page
		on the target namespace, parses it in order to
		derive which 'template' page should be served.
	 */
	public function hVirtualPage( &$title, &$article )
	{
		$ns = $title->getNamespace();
 
		$tvd= Title::makeTitle( $ns, self::vdName );
		$vd = new Article( $tvd );
 
		// the VirtualDirectory page might not exist;
		// in this case, just bail-out graciously
		if ($vd->getID() == 0 )
			return true;
 
		// from this point, we have a valid article
		// that serves as 'Virtual Directory'
		$vdPage = $vd->getContent();
 
		$target = $this->getTarget( $title, $vdPage );
 
		// no match? return silently
		if ($target === null)
			return true;
 
		// We have a match!  Let's try to load the
		// template article.
		$nsT  = $target['linkNs'];
		$page = $target['linkPage'];
		if (empty($nsT)) 
			$ns = NS_MAIN;
		else
			$ns	= Namespace::getCanonicalIndex( $nsT );
 
		$tmplTitle   = Title::makeTitle( $ns, $page );
		$tmplArticle = new VirtualArticle( $tmplTitle );
 
		// did we find satisfaction?
		if ( $tmplArticle->getID() == 0 )
			return true;
 
		// yes we did find a template article!
		$article = $tmplArticle;
		$article->virtualTitle   = $title;
		$article->templateTitle  = $tmplTitle;
 
		// prepare an undo for our hack below.
		$article->mDbkeyform     = $title->getDBkey();
 
		// ugly, ugly hack to get us pass 'wiki.php' hurdles		
		$title->mDbkeyform = $tmplTitle->getDBkey();
 
		return true;	
	}
	/**
		Parses the VirtualDirectory page in search
		of a match to the requested 'title'.
	 */
	private function getTarget( &$title, &$vdPage )
	{
		$m = $this->parse( $vdPage );	
 
		$pageTitle = $title->getText();
 
		$result = null;
		foreach( $m as &$e )
		{
			$regex = $e['regex'];
			$r = preg_match( $regex, $pageTitle );	
			if ( ( false === $r ) || (0 == $r) )
				continue;
			$result = array( 'linkNs' => $e['linkNs'], 'linkPage' => $e['linkPage'] );
		}
 
		return $result;
	}
	/**
		Parses the VirtualDirectory page
	 */
	private function parse( $vdPage )
	{
		// one entry per line maximum
		$e = explode( "\n", $vdPage );
 
		$m = array();		
		// some other stuff is allowed on each line;
		// just pick up what we need, namely the pair:
		// <regex> ... </regex>  and  [[NS:PAGE]]
		foreach( $e as &$line )
		{
			$mr = preg_match( "/<regex\>(.*)(?:\<.?regex)>/siU", $line, $matchRegex );
 
			// did we find a valid line?
			if ( (false === $mr) || (0 == $mr) )
				continue;
 
			// pick the regex expression
			$regex = $matchRegex[1];
 
			// now onto the page link
			$ml = preg_match( "/\[\[(.*):(.*)\]\]/siU", $line, $matchLink );			
 
			// did we find a valid link?
			if ( (false === $ml) || (0 == $ml) )
				continue;
 
			$linkNs = $matchLink[1];
			$linkP = $matchLink[2];			
 
			// at this point, we have a valid regex+link pair; get it.
			$m[] = array( 'regex' => $regex, 'linkNs' => $linkNs, 'linkPage' => $linkP );
 
		} // end foreach
 
		return $m;
	} // end parse method
 
} // end class
 
//