function setUp()
{
parent::setUp();
$parser = new Parser();
$options = new ParserOptions();
$options->setTemplateCallback(array($this, 'templateCallback'));
$parser->startExternalParse(Title::newMainPage(), $options, Parser::OT_HTML, true);
try {
$engine = new Scribunto_LuaSandboxEngine(array('parser' => $parser) + $this->sandboxOpts);
$engine->setTitle($parser->getTitle());
$engine->getInterpreter();
$this->engines['LuaSandbox'] = $engine;
} catch (Scribunto_LuaInterpreterNotFoundError $e) {
$this->markTestSkipped("LuaSandbox interpreter not available");
return;
}
try {
$engine = new Scribunto_LuaStandaloneEngine(array('parser' => $parser) + $this->standaloneOpts);
$engine->setTitle($parser->getTitle());
$engine->getInterpreter();
$this->engines['LuaStandalone'] = $engine;
} catch (Scribunto_LuaInterpreterNotFoundError $e) {
$this->markTestSkipped("LuaStandalone interpreter not available");
return;
}
}
function wfSetParserOptions()
{
global $wgParserOptions, $wgParser;
$wgParserOptions = new ParserOptions(null);
$wgParserOptions->setEditSection(false);
$wgParser->Options($wgParserOptions);
return $wgParserOptions;
}
/**
* Like msgWiki() but it ensures edit section links are never shown.
*
* Needed for Mediawiki 1.19 & 1.20 due to bug 36975:
* https://bugzilla.wikimedia.org/show_bug.cgi?id=36975
*
* @param $message Name of wikitext message to return
*/
function msgWikiNoEdit($message)
{
global $wgOut;
global $wgParser;
$popts = new ParserOptions();
$popts->setEditSection(false);
$text = wfMessage($message)->text();
return $wgParser->parse($text, $wgOut->getTitle(), $popts)->getText();
}
/**
* Helper method for processing a template transclusion by simulating template
* expensions using a callback to avoid having to integrate DB read/write
* process in order to access a Template
*
* @note Part of the routine has been taken from MW's ExtraParserTest
*
* @return text
*/
private function runTemplateTransclusion(Title $title, $text, $return)
{
$parser = new \Parser();
$options = new \ParserOptions();
$options->setTemplateCallback(function ($title, $parser = false) use($return) {
$text = $return;
$deps = array();
return array('text' => $text, 'finalTitle' => $title, 'deps' => $deps);
});
return $parser->preprocess($text, $title, $options);
}
function execute($subpage)
{
global $wgRequest, $wgParser, $wgOut;
$this->setHeaders();
$this->isNewParser = is_callable(array($wgParser, 'preprocessToDom'));
$titleStr = $wgRequest->getText('contexttitle');
$title = Title::newFromText($titleStr);
$selfTitle = $this->getTitle();
if (!$title) {
$title = $selfTitle;
}
$input = $wgRequest->getText('input');
$this->generateXML = $this->isNewParser ? $wgRequest->getBool('generate_xml') : false;
if (strlen($input)) {
$this->removeComments = $wgRequest->getBool('removecomments', false);
$this->removeNowiki = $wgRequest->getBool('removenowiki', false);
$options = new ParserOptions();
$options->setRemoveComments($this->removeComments);
$options->setTidy(true);
$options->setMaxIncludeSize(self::MAX_INCLUDE_SIZE);
if ($this->generateXML) {
$wgParser->startExternalParse($title, $options, OT_PREPROCESS);
$dom = $wgParser->preprocessToDom($input);
if (is_callable(array($dom, 'saveXML'))) {
$xml = $dom->saveXML();
} else {
$xml = $dom->__toString();
}
}
$output = $wgParser->preprocess($input, $title, $options);
} else {
$this->removeComments = $wgRequest->getBool('removecomments', true);
$this->removeNowiki = $wgRequest->getBool('removenowiki', false);
$output = false;
}
$wgOut->addWikiText(wfMsg('expand_templates_intro'));
$wgOut->addHTML($this->makeForm($titleStr, $input));
if ($output !== false) {
global $wgUseTidy, $wgAlwaysUseTidy;
if ($this->generateXML) {
$wgOut->addHTML($this->makeOutput($xml, 'expand_templates_xml_output'));
}
$tmp = $this->makeOutput($output);
if ($this->removeNowiki) {
$tmp = preg_replace(array('_<nowiki>_', '_</nowiki>_', '_<nowiki */>_'), '', $tmp);
}
if ($wgUseTidy && $options->getTidy() || $wgAlwaysUseTidy) {
$tmp = MWTidy::tidy($tmp);
}
$wgOut->addHTML($tmp);
$this->showHtmlPreview($title, $output, $wgOut);
}
}
private function makeEngine($class, $opts)
{
$parser = new Parser();
$options = new ParserOptions();
$options->setTemplateCallback(array($this, 'templateCallback'));
$parser->startExternalParse(Title::newMainPage(), $options, Parser::OT_HTML, true);
$engine = new $class(array('parser' => $parser) + $opts);
$parser->scribunto_engine = $engine;
$engine->setTitle($parser->getTitle());
$engine->getInterpreter();
return $engine;
}
function genParserOptions()
{
global $wgUser;
$this->mParserOptions = ParserOptions::newFromUser($wgUser);
$this->mParserOptions->setDateFormat(MW_DATE_DEFAULT);
$this->mParserOptions->setEditSection(false);
}
public function index()
{
$title = Title::newFromText('Version', NS_SPECIAL);
$popts = ParserOptions::newFromContext(RequestContext::getMain());
$this->wg->Title = $title;
$this->specialPage->setHeaders();
$softwareListPrepped = array();
foreach ($this->version->getSoftwareList() as $key => $val) {
$softwareListPrepped[$this->wg->Parser->parse($key, $title, $popts)->getText()] = $this->wg->Parser->parse($val, $title, $popts)->getText();
}
$this->setVal('copyRightAndAuthorList', $this->wg->Parser->parse($this->version->getCopyrightAndAuthorList(), $title, $popts)->getText());
$this->setVal('softwareInformation', $this->wg->Parser->parse($this->version->softwareInformation(), $title, $popts)->getText());
$this->setVal('extensionCredit', $this->wg->Parser->parse($this->version->getExtensionCredits(), $title, $popts)->getText());
$this->setVal('ip', str_replace('--', ' - ', htmlspecialchars($this->getContext()->getRequest()->getIP())));
$this->setVal('wikiaCodeMessage', wfMessage('wikia-version-code')->escaped());
$this->setVal('wikiaCodeVersion', $this->version->getWikiaCodeVersion());
$this->setVal('wikiaConfigMessage', wfMessage('wikia-version-config')->escaped());
$this->setVal('wikiaConfigVersion', $this->version->getWikiaConfigVersion());
$this->setVal('versionLicenseMessage', wfMessage('version-license')->escaped());
$this->setVal('versionLicenseInfoMessage', wfMessage('version-license-info')->parse());
$this->setVal('versionSoftwareMessage', wfMessage('version-software')->escaped());
$this->setVal('versionSoftwareProductMessage', wfMessage('version-software-product')->escaped());
$this->setVal('versionSoftwareVersionMessage', wfMessage('version-software-version')->escaped());
$this->setVal('versionSoftwareList', $softwareListPrepped);
}
function getMessagesFormatted($severity = self::MESSAGE_WARNING, $header = null)
{
global $wgTitle, $wgUser;
$ret = '';
foreach ($this->mMessages as $message) {
if ($message[1] <= $severity) {
$ret .= '* ' . $message[0] . "\n";
}
}
if ($ret != '') {
if (!$this->mParser) {
$parser = new Parser();
}
if ($header == null) {
$header = '';
} elseif ($header != '') {
$header = Html::rawElement('div', array('class' => 'heading'), $header);
}
$ret = Html::rawElement('div', array('class' => 'messages'), $header . "\n" . $ret);
$ret = $parser->parse($ret, $wgTitle, ParserOptions::newFromUser($wgUser));
} else {
$ret = null;
}
return $ret;
}
function genParserOptions()
{
global $wgUser;
$this->mParserOptions = ParserOptions::newFromUser($wgUser);
$this->mParserOptions->setDateFormat('default');
$this->mParserOptions->setEditSection(false);
}
function initialise(&$memCached, $useDB, $expiry, $memcPrefix)
{
$fname = 'MessageCache::initialise';
wfProfileIn($fname);
$this->mUseCache = !is_null($memCached);
$this->mMemc =& $memCached;
$this->mDisable = !$useDB;
$this->mExpiry = $expiry;
$this->mDisableTransform = false;
$this->mMemcKey = $memcPrefix . ':messages';
$this->mKeys = false;
# initialised on demand
$this->mInitialised = true;
wfProfileIn($fname . '-parseropt');
$this->mParserOptions = ParserOptions::newFromUser($u = NULL);
wfProfileOut($fname . '-parseropt');
wfProfileIn($fname . '-parser');
$this->mParser = new Parser();
wfProfileOut($fname . '-parser');
# When we first get asked for a message,
# then we'll fill up the cache. If we
# can return a cache hit, this saves
# some extra milliseconds
$this->mDeferred = true;
wfProfileOut($fname);
}
function sandboxParse($wikiText){
global $wgUser;
$myParser = new Parser();
$myParserOptions = ParserOptions::newFromUser( $wgUser );
$result = $myParser->parse($wikiText, $this->getTitle(), $myParserOptions);
return $result->getText();
}
function setUp()
{
global $wgContLang, $wgUser, $wgLanguageCode;
$wgContLang = Language::factory($wgLanguageCode);
$this->popts = ParserOptions::newFromUserAndLang($wgUser, $wgContLang);
$this->pcache = ParserCache::singleton();
}
/**
* @param \Article $article
* @return JsonFormatNode
*/
public function getJsonFormatForArticle(\Article $article)
{
$measurement = \Wikia\Measurements\Time::start([__CLASS__, __METHOD__]);
$html = $article->getPage()->getParserOutput(\ParserOptions::newFromContext($this->requestContext))->getText();
$measurement->stop();
return $this->htmlParser->parse($html);
}
public function checkOptions()
{
if ($this->hasOption('save-failed')) {
$this->saveFailed = $this->getOption('save-failed');
}
$this->stripParametersEnabled = $this->hasOption('strip-parameters');
$this->showParsedOutput = $this->hasOption('show-parsed-output');
$this->showDiff = $this->hasOption('show-diff');
if ($this->showDiff) {
$bin = $this->getOption('diff-bin', getenv('DIFF'));
if ($bin != '') {
global $wgDiff;
$wgDiff = $bin;
}
}
$user = new User();
$this->options = ParserOptions::newFromUser($user);
if ($this->hasOption('tidy')) {
global $wgUseTidy;
if (!$wgUseTidy) {
$this->error('Tidy was requested but $wgUseTidy is not set in LocalSettings.php', true);
}
$this->options->setTidy(true);
}
$this->failed = 0;
}
/**
* @see Bug 8689
* @covers Parser::parse
*/
public function testLongNumericLinesDontKillTheParser()
{
$longLine = '1.' . str_repeat('1234567890', 100000) . "\n";
$title = Title::newFromText('Unit test');
$options = ParserOptions::newFromUser(new User());
$this->assertEquals("<p>{$longLine}</p>", $this->parser->parse($longLine, $title, $options)->getText());
}
/**
* Parses the wrapped wikitext and returns an HTML block of code with rendered flags.
* @param array $templateCalls
* @param $pageId
* @return ParserOutput
*/
public function renderFlags(array $templateCalls, $pageId)
{
global $wgUser;
$wikitext = $this->wrapAllFlags($templateCalls);
$title = \Title::newFromID($pageId);
return \ParserPool::parse($wikitext, $title, \ParserOptions::newFromUser($wgUser));
}
function WidgetWikiPage($id, $params)
{
global $wgTitle, $wgParser;
wfProfileIn(__METHOD__);
if (!is_object($wgTitle)) {
$wgTitle = new Title();
}
// clean up inputs
$params['source'] = trim($params['source']);
$params['name'] = trim($params['name']);
//stopgap for 67038
$source = Title::newFromText($params['source']);
if (is_object($source) && !$source->userCan('read')) {
wfProfileOut(__METHOD__);
return array('body' => '', 'title' => $params['name']);
}
//
// parse message and clean it up
//
// fixes #2774
if (isset($params['_widgetTag'])) {
// work-around for WidgetTag
$parser = new Parser();
} else {
$parser =& $wgParser;
}
$options = new ParserOptions();
$options->setMaxIncludeSize(2048);
if (empty($params['source'])) {
// blank source pagename, use default message
$ret = $parser->parse(wfMsg('widgetwikipage', $params['source']), $wgTitle, $options)->getText();
} else {
// has a source value
// get contents
$article = WidgetFramework::getArticle($params['source']);
if ($article == false) {
// failed to get text, show error message, failed pagename is in $1
$ret = $parser->parse('<span class="widget-error-wikipage-missing">' . wfMsg('widgetwikipagemissing', $params['source']) . '</span>', $wgTitle, $options)->getText();
// TODO: change title if page missing?
} else {
// got text, parse it!
$ret = $parser->parse($article, $wgTitle, $options)->getText();
}
}
wfProfileOut(__METHOD__);
return array('body' => $ret, 'title' => $params['name']);
}
function testBug8689()
{
global $wgUser;
$longLine = '1.' . str_repeat('1234567890', 100000) . "\n";
$t = Title::newFromText('Unit test');
$options = ParserOptions::newFromUser($wgUser);
$this->assertEquals("<p>{$longLine}</p>", $this->parser->parse($longLine, $t, $options)->getText());
}
/**
* @dataProvider dataPreloadTransform
*/
public function testPreloadTransform($text, $expected)
{
global $wgContLang;
$options = ParserOptions::newFromUserAndLang($this->context->getUser(), $wgContLang);
$content = $this->newContent($text);
$content = $content->preloadTransform($this->context->getTitle(), $options);
$this->assertEquals($expected, $content->getNativeData());
}
protected function setUp()
{
global $wgParserConf, $wgContLang;
parent::setUp();
$this->mOptions = ParserOptions::newFromUserAndLang(new User(), $wgContLang);
$name = isset($wgParserConf['preprocessorClass']) ? $wgParserConf['preprocessorClass'] : 'Preprocessor_DOM';
$this->mPreprocessor = new $name($this);
}
/**
* @dataProvider provideBadNames
* @expectedException MWException
* @covers Parser::setFunctionTagHook
*/
public function testBadFunctionTagHooks($tag)
{
global $wgParserConf, $wgContLang;
$parser = new Parser($wgParserConf);
$parser->setFunctionTagHook($tag, array($this, 'functionTagCallback'), Parser::SFH_OBJECT_ARGS);
$parser->parse("Foo<{$tag}>Bar</{$tag}>Baz", Title::newFromText('Test'), ParserOptions::newFromUserAndLang(new User(), $wgContLang));
$this->fail('Exception not thrown.');
}
/**
* Get template and image versions from parsing a revision
* @param Page $article
* @param Revision $rev
* @param User $user
* @param string $regen use 'regen' to force regeneration
* @return array( templateIds, fileSHA1Keys )
* templateIds like ParserOutput->mTemplateIds
* fileSHA1Keys like ParserOutput->mImageTimeKeys
*/
public static function getRevIncludes(Page $article, Revision $rev, User $user, $regen = '')
{
global $wgParser, $wgMemc;
wfProfileIn(__METHOD__);
$versions = false;
$key = self::getCacheKey($article->getTitle(), $rev->getId());
if ($regen !== 'regen') {
// check cache
$versions = FlaggedRevs::getMemcValue($wgMemc->get($key), $article, 'allowStale');
}
if (!is_array($versions)) {
// cache miss
$pOut = false;
if ($rev->isCurrent()) {
$parserCache = ParserCache::singleton();
# Try current version parser cache (as anon)...
$pOut = $parserCache->get($article, $article->makeParserOptions($user));
if ($pOut == false && $rev->getUser()) {
// try the user who saved the change
$author = User::newFromId($rev->getUser());
$pOut = $parserCache->get($article, $article->makeParserOptions($author));
}
}
// ParserOutput::mImageTimeKeys wasn't always there
if ($pOut == false || !FlaggedRevs::parserOutputIsVersioned($pOut)) {
$title = $article->getTitle();
$pOpts = ParserOptions::newFromUser($user);
// Note: tidy off
$pOut = $wgParser->parse($rev->getText(), $title, $pOpts, true, true, $rev->getId());
}
# Get the template/file versions used...
$versions = array($pOut->getTemplateIds(), $pOut->getFileSearchOptions());
# Save to cache (check cache expiry for dynamic elements)...
$data = FlaggedRevs::makeMemcObj($versions);
$wgMemc->set($key, $data, $pOut->getCacheExpiry());
} else {
$tVersions =& $versions[0];
// templates
# Do a link batch query for page_latest...
$lb = new LinkBatch();
foreach ($tVersions as $ns => $tmps) {
foreach ($tmps as $dbKey => $revIdDraft) {
$lb->add($ns, $dbKey);
}
}
$lb->execute();
# Update array with the current page_latest values.
# This kludge is there since $newTemplates (thus $revIdDraft) is cached.
foreach ($tVersions as $ns => &$tmps) {
foreach ($tmps as $dbKey => &$revIdDraft) {
$title = Title::makeTitle($ns, $dbKey);
$revIdDraft = (int) $title->getLatestRevID();
}
}
}
wfProfileOut(__METHOD__);
return $versions;
}
/**
* Get template and image versions from parsing a revision
* @param Page $article
* @param Revision $rev
* @param User $user
* @param string $regen use 'regen' to force regeneration
* @return array( templateIds, fileSHA1Keys )
* templateIds like ParserOutput->mTemplateIds
* fileSHA1Keys like ParserOutput->mImageTimeKeys
*/
public static function getRevIncludes(Page $article, Revision $rev, User $user, $regen = '')
{
global $wgMemc;
wfProfileIn(__METHOD__);
$key = self::getCacheKey($article->getTitle(), $rev->getId());
if ($regen === 'regen') {
$versions = false;
// skip cache
} elseif ($rev->isCurrent()) {
// Check cache entry against page_touched
$versions = FlaggedRevs::getMemcValue($wgMemc->get($key), $article);
} else {
// Old revs won't always be invalidated with template/file changes.
// Also, we don't care if page_touched changed due to a direct edit.
$versions = FlaggedRevs::getMemcValue($wgMemc->get($key), $article, 'allowStale');
if (is_array($versions)) {
// entry exists
// Sanity check that the cache is reasonably up to date
list($templates, $files) = $versions;
if (self::templatesStale($templates) || self::filesStale($files)) {
$versions = false;
// no good
}
}
}
if (!is_array($versions)) {
// cache miss
$pOut = false;
if ($rev->isCurrent()) {
$parserCache = ParserCache::singleton();
# Try current version parser cache for this user...
$pOut = $parserCache->get($article, $article->makeParserOptions($user));
if ($pOut == false) {
# Try current version parser cache for the revision author...
$optsUser = $rev->getUser() ? User::newFromId($rev->getUser()) : 'canonical';
$pOut = $parserCache->get($article, $article->makeParserOptions($optsUser));
}
}
// ParserOutput::mImageTimeKeys wasn't always there
if ($pOut == false || !FlaggedRevs::parserOutputIsVersioned($pOut)) {
$content = $rev->getContent(Revision::RAW);
if (!$content) {
// Just for extra sanity
$pOut = new ParserOutput();
} else {
$pOut = $content->getParserOutput($article->getTitle(), $rev->getId(), ParserOptions::newFromUser($user));
}
}
# Get the template/file versions used...
$versions = array($pOut->getTemplateIds(), $pOut->getFileSearchOptions());
# Save to cache (check cache expiry for dynamic elements)...
$data = FlaggedRevs::makeMemcObj($versions);
$wgMemc->set($key, $data, $pOut->getCacheExpiry());
}
wfProfileOut(__METHOD__);
return $versions;
}
protected function setUp()
{
global $wgLanguageCode, $wgUser;
parent::setUp();
$langObj = Language::factory($wgLanguageCode);
$this->setMwGlobals(array('wgContLang' => $langObj, 'wgUseDynamicDates' => true));
$this->popts = ParserOptions::newFromUserAndLang($wgUser, $langObj);
$this->pcache = ParserCache::singleton();
}
/**
* Parse provided wikitext to HTML using RTE parser
*/
public static function rteparse()
{
global $wgTitle, $wgRequest, $wgUser;
wfProfileIn(__METHOD__);
$wikitext = $wgRequest->getVal('wikitext', '');
$parserOptions = new ParserOptions();
// don't show [edit] link for sections
$parserOptions->setEditSection(false);
// disable headings numbering
$parserOptions->setNumberHeadings(false);
$parser = new RTEParser();
// call preSaveTransform so signatures, {{subst:foo}}, etc. will work
$wikitext = $parser->preSaveTransform($wikitext, $wgTitle, $wgUser, $parserOptions);
// parse wikitext using RTE parser
$html = $parser->parse($wikitext, $wgTitle, $parserOptions)->getText();
$res = array('html' => $html);
wfProfileOut(__METHOD__);
return $res;
}
protected function setUp()
{
global $wgContLang;
parent::setUp();
$this->mOptions = ParserOptions::newFromUserAndLang(new User(), $wgContLang);
$this->mPreprocessors = [];
foreach (self::$classNames as $className) {
$this->mPreprocessors[$className] = new $className($this);
}
}
function getPages($query)
{
global $wgTitle, $wgParser, $wgUser;
$fname = 'NukeDPLForm::getNewPages';
$query = trim($query) . "\nmode=userformat\nlistseparators=,\\n\$\$\$%PAGE%\$\$\$,,\n";
$opt = ParserOptions::newFromUser($wgUser);
$out = $wgParser->parse("<dpl>{$query}</dpl>", $wgTitle, $opt, false, true);
preg_match_all('|\\${3}(.+?)\\${3}|m', $out->getText(), $matches);
return str_replace(array(' ', '&'), array(' ', '&'), $matches[1]);
}
/**
* @dataProvider providePreSaveTransform
* @covers Parser::preSaveTransform
*/
public function testPreSaveTransform($text, $expected)
{
global $wgParser;
$title = Title::newFromText(str_replace('::', '__', __METHOD__));
$user = new User();
$user->setName("127.0.0.1");
$popts = ParserOptions::newFromUser($user);
$text = $wgParser->preSaveTransform($text, $title, $user, $popts);
$this->assertEquals($expected, $text);
}
protected function setUp()
{
global $wgContLang;
parent::setUp();
$this->testParserOptions = ParserOptions::newFromUserAndLang(new User(), $wgContLang);
$this->testParser = new Parser();
$this->testParser->Options($this->testParserOptions);
$this->testParser->clearState();
$this->title = Title::newFromText('Preload Test');
}
