includes/Content.php

   1 <?php
   2 /**
   3  * A content object represents page content, e.g. the text to show on a page.
   4  * Content objects have no knowledge about how they relate to Wiki pages.
   5  *
   6  * @since 1.WD
   7  */
   8 abstract class Content {
   9
  10         /**
  11          * Name of the content model this Content object represents.
  12          * Use with CONTENT_MODEL_XXX constants
  13          *
  14          * @var String $model_id
  15          */
  16         protected $model_id;
  17
  18         /**
  19          * @since WD.1
  20          *
  21          * @return String a string representing the content in a way useful for building a full text search index.
  22          *         If no useful representation exists, this method returns an empty string.
  23          *
  24          * @todo: test that this actually works
  25          * @todo: make sure this also works with LuceneSearch / WikiSearch
  26          */
  27         public abstract function getTextForSearchIndex( );
  28
  29         /**
  30          * @since WD.1
  31          *
  32          * @return String the wikitext to include when another page includes this  content, or false if the content is not
  33          *         includable in a wikitext page.
  34          *
  35          * @TODO: allow native handling, bypassing wikitext representation, like for includable special pages.
  36          * @TODO: use in parser, etc!
  37          */
  38         public abstract function getWikitextForTransclusion( );
  39
  40         /**
  41          * Returns a textual representation of the content suitable for use in edit summaries and log messages.
  42          *
  43          * @since WD.1
  44          *
  45          * @param int $maxlength maximum length of the summary text
  46          * @return String the summary text
  47          */
  48         public abstract function getTextForSummary( $maxlength = 250 );
  49
  50         /**
  51          * Returns native representation of the data. Interpretation depends on the data model used,
  52          * as given by getDataModel().
  53          *
  54          * @since WD.1
  55          *
  56          * @return mixed the native representation of the content. Could be a string, a nested array
  57          *         structure, an object, a binary blob... anything, really.
  58          *
  59          * @NOTE: review all calls carefully, caller must be aware of content model!
  60          */
  61         public abstract function getNativeData( );
  62
  63         /**
  64          * returns the content's nominal size in bogo-bytes.
  65          *
  66          * @return int
  67          */
  68         public abstract function getSize( );
  69
  70         /**
  71          * @param int $model_id
  72          */
  73         public function __construct( $model_id = null ) {
  74                 $this->model_id = $model_id;
  75         }
  76
  77         /**
  78          * Returns the id of the content model used by this content objects.
  79          * Corresponds to the CONTENT_MODEL_XXX constants.
  80          *
  81          * @since WD.1
  82          *
  83          * @return int the model id
  84          */
  85         public function getModel() {
  86                 return $this->model_id;
  87         }
  88
  89         /**
  90          * Throws an MWException if $model_id is not the id of the content model
  91          * supported by this Content object.
  92          *
  93          * @param int $model_id the model to check
  94          *
  95          * @throws MWException
  96          */
  97         protected function checkModelID( $model_id ) {
  98                 if ( $model_id !== $this->model_id ) {
  99                         $model_name = ContentHandler::getContentModelName( $model_id );
 100                         $own_model_name = ContentHandler::getContentModelName( $this->model_id );
 101
 102                         throw new MWException( "Bad content model: expected {$this->model_id} ($own_model_name) but got found $model_id ($model_name)." );
 103                 }
 104         }
 105
 106         /**
 107          * Convenience method that returns the ContentHandler singleton for handling the content
 108          * model this Content object uses.
 109          *
 110          * Shorthand for ContentHandler::getForContent( $this )
 111          *
 112          * @since WD.1
 113          *
 114          * @return ContentHandler
 115          */
 116         public function getContentHandler() {
 117                 return ContentHandler::getForContent( $this );
 118         }
 119
 120         /**
 121          * Convenience method that returns the default serialization format for the content model
 122          * model this Content object uses.
 123          *
 124          * Shorthand for $this->getContentHandler()->getDefaultFormat()
 125          *
 126          * @since WD.1
 127          *
 128          * @return ContentHandler
 129          */
 130         public function getDefaultFormat() {
 131                 return $this->getContentHandler()->getDefaultFormat();
 132         }
 133
 134         /**
 135          * Convenience method that returns the list of serialization formats supported
 136          * for the content model model this Content object uses.
 137          *
 138          * Shorthand for $this->getContentHandler()->getSupportedFormats()
 139          *
 140          * @since WD.1
 141          *
 142          * @return array of supported serialization formats
 143          */
 144         public function getSupportedFormats() {
 145                 return $this->getContentHandler()->getSupportedFormats();
 146         }
 147
 148         /**
 149          * Returns true if $format is a supported serialization format for this Content object,
 150          * false if it isn't.
 151          *
 152          * Note that this will always return true if $format is null, because null stands for the
 153          * default serialization.
 154          *
 155          * Shorthand for $this->getContentHandler()->isSupportedFormat( $format )
 156          *
 157          * @since WD.1
 158          *
 159          * @param String $format the format to check
 160          * @return bool whether the format is supported
 161          */
 162         public function isSupportedFormat( $format ) {
 163                 if ( !$format ) {
 164                         return true; // this means "use the default"
 165                 }
 166
 167                 return $this->getContentHandler()->isSupportedFormat( $format );
 168         }
 169
 170         /**
 171          * Throws an MWException if $this->isSupportedFormat( $format ) doesn't return true.
 172          *
 173          * @param $format
 174          * @throws MWException
 175          */
 176         protected function checkFormat( $format ) {
 177                 if ( !$this->isSupportedFormat( $format ) ) {
 178                         throw new MWException( "Format $format is not supported for content model " . $this->getModel() );
 179                 }
 180         }
 181
 182         /**
 183          * Convenience method for serializing this Content object.
 184          *
 185          * Shorthand for $this->getContentHandler()->serializeContent( $this, $format )
 186          *
 187          * @since WD.1
 188          *
 189          * @param null|String $format the desired serialization format (or null for the default format).
 190          * @return String serialized form of this Content object
 191          */
 192         public function serialize( $format = null ) {
 193                 return $this->getContentHandler()->serializeContent( $this, $format );
 194         }
 195
 196         /**
 197          * Returns true if this Content object represents empty content.
 198          *
 199          * @since WD.1
 200          *
 201          * @return bool whether this Content object is empty
 202          */
 203         public function isEmpty() {
 204                 return $this->getSize() == 0;
 205         }
 206
 207         /**
 208          * Returns if the content is valid. This is intended for local validity checks, not considering global consistency.
 209          * It needs to be valid before it can be saved.
 210          *
 211          * This default implementation always returns true.
 212          *
 213          * @since WD.1
 214          *
 215          * @return boolean
 216          */
 217         public function isValid() {
 218                 return true;
 219         }
 220
 221         /**
 222          * Returns true if this Content objects is conceptually equivalent to the given Content object.
 223          *
 224          * Will returns false if $that is null.
 225          * Will return true if $that === $this.
 226          * Will return false if $that->getModelName() != $this->getModel().
 227          * Will return false if $that->getNativeData() is not equal to $this->getNativeData(),
 228          * where the meaning of "equal" depends on the actual data model.
 229          *
 230          * Implementations should be careful to make equals() transitive and reflexive:
 231          *
 232          * * $a->equals( $b ) <=> $b->equals( $a )
 233          * * $a->equals( $b ) &&  $b->equals( $c ) ==> $a->equals( $c )
 234          *
 235          * @since WD.1
 236          *
 237          * @param Content $that the Content object to compare to
 238          * @return bool true if this Content object is euqual to $that, false otherwise.
 239          */
 240         public function equals( Content $that = null ) {
 241                 if ( is_null( $that ) ){
 242                         return false;
 243                 }
 244
 245                 if ( $that === $this ) {
 246                         return true;
 247                 }
 248
 249                 if ( $that->getModel() !== $this->getModel() ) {
 250                         return false;
 251                 }
 252
 253                 return $this->getNativeData() === $that->getNativeData();
 254         }
 255
 256         /**
 257          * Return a copy of this Content object. The following must be true for the object returned
 258          * if $copy = $original->copy()
 259          *
 260          * * get_class($original) === get_class($copy)
 261          * * $original->getModel() === $copy->getModel()
 262          * * $original->equals( $copy )
 263          *
 264          * If and only if the Content object is immutable, the copy() method can and should
 265          * return $this. That is,  $copy === $original may be true, but only for immutable content
 266          * objects.
 267          *
 268          * @since WD.1
 269          *
 270          * @return Content. A copy of this object
 271          */
 272         public abstract function copy( );
 273
 274         /**
 275          * Returns true if this content is countable as a "real" wiki page, provided
 276          * that it's also in a countable location (e.g. a current revision in the main namespace).
 277          *
 278          * @since WD.1
 279          *
 280          * @param $hasLinks Bool: if it is known whether this content contains links, provide this information here,
 281          *                        to avoid redundant parsing to find out.
 282          * @return boolean
 283          */
 284         public abstract function isCountable( $hasLinks = null ) ;
 285
 286         /**
 287          * Convenience method, shorthand for
 288          * $this->getContentHandler()->getParserOutput( $this, $title, $revId, $options, $generateHtml )
 289          *
 290          * @param Title $title
 291          * @param null $revId
 292          * @param null|ParserOptions $options
 293          * @param Boolean $generateHtml whether to generate Html (default: true). If false,
 294          *        the result of calling getText() on the ParserOutput object returned by
 295          *        this method is undefined.
 296          *
 297          * @since WD.1
 298          *
 299          * @return ParserOutput
 300          */
 301         public function getParserOutput( Title $title, $revId = null, ParserOptions $options = null, $generateHtml = true ) {
 302                 return $this->getContentHandler()->getParserOutput( $this, $title, $revId, $options, $generateHtml );
 303         }
 304
 305         /**
 306          * Convenience method, shorthand for
 307          * $this->getContentHandler()->getSecondaryDataUpdates( $this, $title, $old, $recursive )
 308          *
 309          * @param Title $title the context for determining the necessary updates
 310          * @param Content|null $old a Content object representing the previous content, i.e. the content being
 311          *                     replaced by this Content object.
 312          * @param bool $recursive whether to include recursive updates (default: false).
 313          *
 314          * @return Array. A list of DataUpdate objects for putting information about this content object somewhere.
 315          *
 316          * @since WD.1
 317          */
 318         public function getSecondaryDataUpdates( Title $title, Content $old = null, $recursive = false ) { #TODO: remove!
 319                 return $this->getContentHandler()->getSecondaryDataUpdates( $this, $title, $old, $recursive );
 320         }
 321
 322         /**
 323          * Construct the redirect destination from this content and return an
 324          * array of Titles, or null if this content doesn't represent a redirect.
 325          * The last element in the array is the final destination after all redirects
 326          * have been resolved (up to $wgMaxRedirects times).
 327          *
 328          * @since WD.1
 329          *
 330          * @return Array of Titles, with the destination last
 331          */
 332         public function getRedirectChain() {
 333                 return null;
 334         }
 335
 336         /**
 337          * Construct the redirect destination from this content and return a Title,
 338          * or null if this content doesn't represent a redirect.
 339          * This will only return the immediate redirect target, useful for
 340          * the redirect table and other checks that don't need full recursion.
 341          *
 342          * @since WD.1
 343          *
 344          * @return Title: The corresponding Title
 345          */
 346         public function getRedirectTarget() {
 347                 return null;
 348         }
 349
 350         /**
 351          * Construct the redirect destination from this content and return the
 352          * Title, or null if this content doesn't represent a redirect.
 353          * This will recurse down $wgMaxRedirects times or until a non-redirect target is hit
 354          * in order to provide (hopefully) the Title of the final destination instead of another redirect.
 355          *
 356          * @since WD.1
 357          *
 358          * @return Title
 359          */
 360         public function getUltimateRedirectTarget() {
 361                 return null;
 362         }
 363
 364         /**
 365          * @since WD.1
 366          *
 367          * @return bool
 368          */
 369         public function isRedirect() {
 370                 return $this->getRedirectTarget() !== null;
 371         }
 372
 373         /**
 374          * Returns the section with the given id.
 375          *
 376          * The default implementation returns null.
 377          *
 378          * @since WD.1
 379          *
 380          * @param String $sectionId the section's id, given as a numeric string. The id "0" retrieves the section before
 381          *          the first heading, "1" the text between the first heading (included) and the second heading (excluded), etc.
 382          * @return Content|Boolean|null the section, or false if no such section exist, or null if sections are not supported
 383          */
 384         public function getSection( $sectionId ) {
 385                 return null;
 386         }
 387
 388         /**
 389          * Replaces a section of the content and returns a Content object with the section replaced.
 390          *
 391          * @since WD.1
 392          *
 393          * @param $section empty/null/false or a section number (0, 1, 2, T1, T2...), or "new"
 394          * @param $with Content: new content of the section
 395          * @param $sectionTitle String: new section's subject, only if $section is 'new'
 396          * @return string Complete article text, or null if error
 397          */
 398         public function replaceSection( $section, Content $with, $sectionTitle = ''  ) {
 399                 return null;
 400         }
 401
 402         /**
 403          * Returns a Content object with pre-save transformations applied (or this object if no transformations apply).
 404          *
 405          * @since WD.1
 406          *
 407          * @param Title $title
 408          * @param User $user
 409          * @param null|ParserOptions $popts
 410          * @return Content
 411          */
 412         public function preSaveTransform( Title $title, User $user, ParserOptions $popts ) {
 413                 return $this;
 414         }
 415
 416         /**
 417          * Returns a new WikitextContent object with the given section heading prepended, if supported.
 418          * The default implementation just returns this Content object unmodified, ignoring the section header.
 419          *
 420          * @since WD.1
 421          *
 422          * @param $header String
 423          * @return Content
 424          */
 425         public function addSectionHeader( $header ) {
 426                 return $this;
 427         }
 428
 429         /**
 430          * Returns a Content object with preload transformations applied (or this object if no transformations apply).
 431          *
 432          * @since WD.1
 433          *
 434          * @param Title $title
 435          * @param null|ParserOptions $popts
 436          * @return Content
 437          */
 438         public function preloadTransform( Title $title, ParserOptions $popts ) {
 439                 return $this;
 440         }
 441
 442         # TODO: handle ImagePage and CategoryPage
 443         # TODO: make sure we cover lucene search / wikisearch.
 444         # TODO: make sure ReplaceTemplates still works
 445         # FUTURE: nice&sane integration of GeSHi syntax highlighting
 446         #   [11:59] <vvv> Hooks are ugly; make CodeHighlighter interface and a config to set the class which handles syntax highlighting
 447         #   [12:00] <vvv> And default it to a DummyHighlighter
 448
 449         # TODO: make sure we cover the external editor interface (does anyone actually use that?!)
 450
 451         # TODO: tie into API to provide contentModel for Revisions
 452         # TODO: tie into API to provide serialized version and contentFormat for Revisions
 453         # TODO: tie into API edit interface
 454         # FUTURE: make EditForm plugin for EditPage
 455 }
 456         # FUTURE: special type for redirects?!
 457         # FUTURE: MultipartMultipart < WikipageContent (Main + Links + X)
 458         # FUTURE: LinksContent < LanguageLinksContent, CategoriesContent
 459
 460 /**
 461  * Content object implementation for representing flat text.
 462  *
 463  * TextContent instances are immutable
 464  *
 465  * @since WD.1
 466  */
 467 abstract class TextContent extends Content {
 468
 469         public function __construct( $text, $model_id = null ) {
 470                 parent::__construct( $model_id );
 471
 472                 $this->mText = $text;
 473         }
 474
 475         public function copy() {
 476                 return $this; #NOTE: this is ok since TextContent are immutable.
 477         }
 478
 479         public function getTextForSummary( $maxlength = 250 ) {
 480                 global $wgContLang;
 481
 482                 $text = $this->getNativeData();
 483
 484                 $truncatedtext = $wgContLang->truncate(
 485                         preg_replace( "/[\n\r]/", ' ', $text ),
 486                         max( 0, $maxlength ) );
 487
 488                 return $truncatedtext;
 489         }
 490
 491         /**
 492          * returns the text's size in bytes.
 493          *
 494          * @return int the size
 495          */
 496         public function getSize( ) {
 497                 $text = $this->getNativeData( );
 498                 return strlen( $text );
 499         }
 500
 501         /**
 502          * Returns true if this content is not a redirect, and $wgArticleCountMethod is "any".
 503          *
 504          * @param $hasLinks Bool: if it is known whether this content contains links, provide this information here,
 505          *                        to avoid redundant parsing to find out.
 506          *
 507          * @return bool true if the content is countable
 508          */
 509         public function isCountable( $hasLinks = null ) {
 510                 global $wgArticleCountMethod;
 511
 512                 if ( $this->isRedirect( ) ) {
 513                         return false;
 514                 }
 515
 516                 if (  $wgArticleCountMethod === 'any' ) {
 517                         return true;
 518                 }
 519
 520                 return false;
 521         }
 522
 523         /**
 524          * Returns the text represented by this Content object, as a string.
 525          *
 526          * @return String the raw text
 527          */
 528         public function getNativeData( ) {
 529                 $text = $this->mText;
 530                 return $text;
 531         }
 532
 533         /**
 534          * Returns the text represented by this Content object, as a string.
 535          *
 536          * @return String the raw text
 537          */
 538         public function getTextForSearchIndex( ) {
 539                 return $this->getNativeData();
 540         }
 541
 542         /**
 543          * Returns the text represented by this Content object, as a string.
 544          *
 545          * @return String the raw text
 546          */
 547         public function getWikitextForTransclusion( ) {
 548                 return $this->getNativeData();
 549         }
 550
 551         /**
 552          * Diff this content object with another content object..
 553          *
 554          * @since WD.diff
 555          *
 556          * @param Content $that the other content object to compare this content object to
 557          * @param Language $lang the language object to use for text segmentation. If not given, $wgContentLang is used.
 558          *
 559          * @return DiffResult a diff representing the changes that would have to be made to this content object
 560          *         to make it equal to $that.
 561          */
 562         public function diff( Content $that, Language $lang = null ) {
 563                 global $wgContLang;
 564
 565                 $this->checkModelID( $that->getModel() );
 566
 567                 #@todo: could implement this in DifferenceEngine and just delegate here?
 568
 569                 if ( !$lang ) $lang = $wgContLang;
 570
 571                 $otext = $this->getNativeData();
 572                 $ntext = $this->getNativeData();
 573
 574                 # Note: Use native PHP diff, external engines don't give us abstract output
 575                 $ota = explode( "\n", $wgContLang->segmentForDiff( $otext ) );
 576                 $nta = explode( "\n", $wgContLang->segmentForDiff( $ntext ) );
 577
 578                 $diff = new Diff( $ota, $nta );
 579                 return $diff;
 580         }
 581
 582
 583 }
 584
 585 /**
 586  * @since WD.1
 587  */
 588 class WikitextContent extends TextContent {
 589
 590         public function __construct( $text ) {
 591                 parent::__construct($text, CONTENT_MODEL_WIKITEXT);
 592         }
 593
 594         /**
 595          * Returns the section with the given id.
 596          *
 597          * @param String $section
 598          *
 599          * @internal param String $sectionId the section's id
 600          * @return Content|false|null the section, or false if no such section exist, or null if sections are not supported
 601          */
 602         public function getSection( $section ) {
 603                 global $wgParser;
 604
 605                 $text = $this->getNativeData();
 606                 $sect = $wgParser->getSection( $text, $section, false );
 607
 608                 return  new WikitextContent( $sect );
 609         }
 610
 611         /**
 612          * Replaces a section in the wikitext
 613          *
 614          * @param $section      empty/null/false or a section number (0, 1, 2, T1, T2...), or "new"
 615          * @param $with         Content: new content of the section
 616          * @param $sectionTitle String: new section's subject, only if $section is 'new'
 617          *
 618          * @throws MWException
 619          * @return Content Complete article content, or null if error
 620          */
 621         public function replaceSection( $section, Content $with, $sectionTitle = '' ) {
 622                 wfProfileIn( __METHOD__ );
 623
 624                 $myModelId = $this->getModel();
 625                 $sectionModelId = $with->getModel();
 626
 627                 if ( $sectionModelId != $myModelId  ) {
 628                         $myModelName = ContentHandler::getContentModelName( $myModelId );
 629                         $sectionModelName = ContentHandler::getContentModelName( $sectionModelId );
 630
 631                         throw new MWException( "Incompatible content model for section: document uses $myModelId ($myModelName), "
 632                                                                 . "section uses $sectionModelId ($sectionModelName)." );
 633                 }
 634
 635                 $oldtext = $this->getNativeData();
 636                 $text = $with->getNativeData();
 637
 638                 if ( $section === '' ) {
 639                         return $with; #XXX: copy first?
 640                 } if ( $section == 'new' ) {
 641                         # Inserting a new section
 642                         $subject = $sectionTitle ? wfMsgForContent( 'newsectionheaderdefaultlevel', $sectionTitle ) . "\n\n" : '';
 643                         if ( wfRunHooks( 'PlaceNewSection', array( $this, $oldtext, $subject, &$text ) ) ) {
 644                                 $text = strlen( trim( $oldtext ) ) > 0
 645                                         ? "{$oldtext}\n\n{$subject}{$text}"
 646                                         : "{$subject}{$text}";
 647                         }
 648                 } else {
 649                         # Replacing an existing section; roll out the big guns
 650                         global $wgParser;
 651
 652                         $text = $wgParser->replaceSection( $oldtext, $section, $text );
 653                 }
 654
 655                 $newContent = new WikitextContent( $text );
 656
 657                 wfProfileOut( __METHOD__ );
 658                 return $newContent;
 659         }
 660
 661         /**
 662          * Returns a new WikitextContent object with the given section heading prepended.
 663          *
 664          * @param $header String
 665          * @return Content
 666          */
 667         public function addSectionHeader( $header ) {
 668                 $text = wfMsgForContent( 'newsectionheaderdefaultlevel', $header ) . "\n\n" . $this->getNativeData();
 669
 670                 return new WikitextContent( $text );
 671         }
 672
 673         /**
 674          * Returns a Content object with pre-save transformations applied (or this object if no transformations apply).
 675          *
 676          * @param Title $title
 677          * @param User $user
 678          * @param ParserOptions $popts
 679          * @return Content
 680          */
 681         public function preSaveTransform( Title $title, User $user, ParserOptions $popts ) { #FIXME: also needed for JS/CSS!
 682                 global $wgParser, $wgConteLang;
 683
 684                 $text = $this->getNativeData();
 685                 $pst = $wgParser->preSaveTransform( $text, $title, $user, $popts );
 686
 687                 return new WikitextContent( $pst );
 688         }
 689
 690         /**
 691          * Returns a Content object with preload transformations applied (or this object if no transformations apply).
 692          *
 693          * @param Title $title
 694          * @param ParserOptions $popts
 695          * @return Content
 696          */
 697         public function preloadTransform( Title $title, ParserOptions $popts ) {
 698                 global $wgParser, $wgConteLang;
 699
 700                 $text = $this->getNativeData();
 701                 $plt = $wgParser->getPreloadText( $text, $title, $popts );
 702
 703                 return new WikitextContent( $plt );
 704         }
 705
 706         public function getRedirectChain() {
 707                 $text = $this->getNativeData();
 708                 return Title::newFromRedirectArray( $text );
 709         }
 710
 711         public function getRedirectTarget() {
 712                 $text = $this->getNativeData();
 713                 return Title::newFromRedirect( $text );
 714         }
 715
 716         public function getUltimateRedirectTarget() {
 717                 $text = $this->getNativeData();
 718                 return Title::newFromRedirectRecurse( $text );
 719         }
 720
 721         /**
 722          * Returns true if this content is not a redirect, and this content's text is countable according to
 723          * the criteria defined by $wgArticleCountMethod.
 724          *
 725          * @param Bool        $hasLinks  if it is known whether this content contains links, provide this information here,
 726          *                               to avoid redundant parsing to find out.
 727          * @param null|\Title $title
 728          *
 729          * @internal param \IContextSource $context context for parsing if necessary
 730          *
 731          * @return bool true if the content is countable
 732          */
 733         public function isCountable( $hasLinks = null, Title $title = null ) {
 734                 global $wgArticleCountMethod, $wgRequest;
 735
 736                 if ( $this->isRedirect( ) ) {
 737                         return false;
 738                 }
 739
 740                 $text = $this->getNativeData();
 741
 742                 switch ( $wgArticleCountMethod ) {
 743                         case 'any':
 744                                 return true;
 745                         case 'comma':
 746                                 return strpos( $text,  ',' ) !== false;
 747                         case 'link':
 748                                 if ( $hasLinks === null ) { # not known, find out
 749                                         if ( !$title ) {
 750                                                 $context = RequestContext::getMain();
 751                                                 $title = $context->getTitle();
 752                                         }
 753
 754                                         $po = $this->getParserOutput( $title, null, null, false );
 755                                         $links = $po->getLinks();
 756                                         $hasLinks = !empty( $links );
 757                                 }
 758
 759                                 return $hasLinks;
 760                 }
 761
 762                 return false;
 763         }
 764
 765         public function getTextForSummary( $maxlength = 250 ) {
 766                 $truncatedtext = parent::getTextForSummary( $maxlength );
 767
 768                 #clean up unfinished links
 769                 #XXX: make this optional? wasn't there in autosummary, but required for deletion summary.
 770                 $truncatedtext = preg_replace( '/\[\[([^\]]*)\]?$/', '$1', $truncatedtext );
 771
 772                 return $truncatedtext;
 773         }
 774
 775 }
 776
 777 /**
 778  * @since WD.1
 779  */
 780 class MessageContent extends TextContent {
 781         public function __construct( $msg_key, $params = null, $options = null ) {
 782                 parent::__construct(null, CONTENT_MODEL_WIKITEXT); #XXX: messages may be wikitext, html or plain text! and maybe even something else entirely.
 783
 784                 $this->mMessageKey = $msg_key;
 785
 786                 $this->mParameters = $params;
 787
 788                 if ( is_null( $options ) ) {
 789                         $options = array();
 790                 }
 791                 elseif ( is_string( $options ) ) {
 792                         $options = array( $options );
 793                 }
 794
 795                 $this->mOptions = $options;
 796         }
 797
 798         /**
 799          * Returns the message as rendered HTML, using the options supplied to the constructor plus "parse".
 800          * @return String the message text, parsed
 801          */
 802         public function getHtml(  ) {
 803                 $opt = array_merge( $this->mOptions, array('parse') );
 804
 805                 return wfMsgExt( $this->mMessageKey, $this->mParameters, $opt );
 806         }
 807
 808
 809         /**
 810          * Returns the message as raw text, using the options supplied to the constructor minus "parse" and "parseinline".
 811          *
 812          * @return String the message text, unparsed.
 813          */
 814         public function getNativeData( ) {
 815                 $opt = array_diff( $this->mOptions, array('parse', 'parseinline') );
 816
 817                 return wfMsgExt( $this->mMessageKey, $this->mParameters, $opt );
 818         }
 819
 820 }
 821
 822 /**
 823  * @since WD.1
 824  */
 825 class JavaScriptContent extends TextContent {
 826         public function __construct( $text ) {
 827                 parent::__construct($text, CONTENT_MODEL_JAVASCRIPT);
 828         }
 829
 830 }
 831
 832 /**
 833  * @since WD.1
 834  */
 835 class CssContent extends TextContent {
 836         public function __construct( $text ) {
 837                 parent::__construct($text, CONTENT_MODEL_CSS);
 838         }
 839 }