includes/PrefixSearch.php

   1 <?php
   2 /**
   3  * Prefix search of page names.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  * http://www.gnu.org/copyleft/gpl.html
  19  *
  20  * @file
  21  */
  22
  23 /**
  24  * Handles searching prefixes of titles and finding any page
  25  * names that match. Used largely by the OpenSearch implementation.
  26  *
  27  * @ingroup Search
  28  */
  29 abstract class PrefixSearch {
  30         /**
  31          * Do a prefix search of titles and return a list of matching page names.
  32          * @deprecated Since 1.23, use TitlePrefixSearch or StringPrefixSearch classes
  33          *
  34          * @param string $search
  35          * @param int $limit
  36          * @param array $namespaces Used if query is not explicitly prefixed
  37          * @param int $offset How many results to offset from the beginning
  38          * @return array Array of strings
  39          */
  40         public static function titleSearch( $search, $limit, $namespaces = array(), $offset = 0 ) {
  41                 $prefixSearch = new StringPrefixSearch;
  42                 return $prefixSearch->search( $search, $limit, $namespaces, $offset );
  43         }
  44
  45         /**
  46          * Do a prefix search of titles and return a list of matching page names.
  47          *
  48          * @param string $search
  49          * @param int $limit
  50          * @param array $namespaces Used if query is not explicitly prefixed
  51          * @param int $offset How many results to offset from the beginning
  52          * @return array Array of strings or Title objects
  53          */
  54         public function search( $search, $limit, $namespaces = array(), $offset = 0 ) {
  55                 $search = trim( $search );
  56                 if ( $search == '' ) {
  57                         return array(); // Return empty result
  58                 }
  59                 $namespaces = $this->validateNamespaces( $namespaces );
  60
  61                 // Find a Title which is not an interwiki and is in NS_MAIN
  62                 $title = Title::newFromText( $search );
  63                 if ( $title && !$title->isExternal() ) {
  64                         $ns = array( $title->getNamespace() );
  65                         $search = $title->getText();
  66                         if ( $ns[0] == NS_MAIN ) {
  67                                 $ns = $namespaces; // no explicit prefix, use default namespaces
  68                                 Hooks::run( 'PrefixSearchExtractNamespace', array( &$ns, &$search ) );
  69                         }
  70                         return $this->searchBackend( $ns, $search, $limit, $offset );
  71                 }
  72
  73                 // Is this a namespace prefix?
  74                 $title = Title::newFromText( $search . 'Dummy' );
  75                 if ( $title && $title->getText() == 'Dummy'
  76                         && $title->getNamespace() != NS_MAIN
  77                         && !$title->isExternal() )
  78                 {
  79                         $namespaces = array( $title->getNamespace() );
  80                         $search = '';
  81                 } else {
  82                         Hooks::run( 'PrefixSearchExtractNamespace', array( &$namespaces, &$search ) );
  83                 }
  84
  85                 return $this->searchBackend( $namespaces, $search, $limit, $offset );
  86         }
  87
  88         /**
  89          * Do a prefix search for all possible variants of the prefix
  90          * @param string $search
  91          * @param int $limit
  92          * @param array $namespaces
  93          * @param int $offset How many results to offset from the beginning
  94          *
  95          * @return array
  96          */
  97         public function searchWithVariants( $search, $limit, array $namespaces, $offset = 0 ) {
  98                 $searches = $this->search( $search, $limit, $namespaces, $offset );
  99
 100                 // if the content language has variants, try to retrieve fallback results
 101                 $fallbackLimit = $limit - count( $searches );
 102                 if ( $fallbackLimit > 0 ) {
 103                         global $wgContLang;
 104
 105                         $fallbackSearches = $wgContLang->autoConvertToAllVariants( $search );
 106                         $fallbackSearches = array_diff( array_unique( $fallbackSearches ), array( $search ) );
 107
 108                         foreach ( $fallbackSearches as $fbs ) {
 109                                 $fallbackSearchResult = $this->search( $fbs, $fallbackLimit, $namespaces );
 110                                 $searches = array_merge( $searches, $fallbackSearchResult );
 111                                 $fallbackLimit -= count( $fallbackSearchResult );
 112
 113                                 if ( $fallbackLimit == 0 ) {
 114                                         break;
 115                                 }
 116                         }
 117                 }
 118                 return $searches;
 119         }
 120
 121         /**
 122          * When implemented in a descendant class, receives an array of Title objects and returns
 123          * either an unmodified array or an array of strings corresponding to titles passed to it.
 124          *
 125          * @param array $titles
 126          * @return array
 127          */
 128         abstract protected function titles( array $titles );
 129
 130         /**
 131          * When implemented in a descendant class, receives an array of titles as strings and returns
 132          * either an unmodified array or an array of Title objects corresponding to strings received.
 133          *
 134          * @param array $strings
 135          *
 136          * @return array
 137          */
 138         abstract protected function strings( array $strings );
 139
 140         /**
 141          * Do a prefix search of titles and return a list of matching page names.
 142          * @param array $namespaces
 143          * @param string $search
 144          * @param int $limit
 145          * @param int $offset How many results to offset from the beginning
 146          * @return array Array of strings
 147          */
 148         protected function searchBackend( $namespaces, $search, $limit, $offset ) {
 149                 if ( count( $namespaces ) == 1 ) {
 150                         $ns = $namespaces[0];
 151                         if ( $ns == NS_MEDIA ) {
 152                                 $namespaces = array( NS_FILE );
 153                         } elseif ( $ns == NS_SPECIAL ) {
 154                                 return $this->titles( $this->specialSearch( $search, $limit, $offset ) );
 155                         }
 156                 }
 157                 $srchres = array();
 158                 if ( Hooks::run(
 159                         'PrefixSearchBackend',
 160                         array( $namespaces, $search, $limit, &$srchres, $offset )
 161                 ) ) {
 162                         return $this->titles( $this->defaultSearchBackend( $namespaces, $search, $limit, $offset ) );
 163                 }
 164                 return $this->strings( $this->handleResultFromHook( $srchres, $namespaces, $search, $limit ) );
 165         }
 166
 167         /**
 168          * Default search backend does proper prefix searching, but custom backends
 169          * may sort based on other algorythms that may cause the exact title match
 170          * to not be in the results or be lower down the list.
 171          * @param array $srchres results from the hook
 172          * @return array munged results from the hook
 173          */
 174         private function handleResultFromHook( $srchres, $namespaces, $search, $limit ) {
 175                 // Pick namespace (based on PrefixSearch::defaultSearchBackend)
 176                 $ns = in_array( NS_MAIN, $namespaces ) ? NS_MAIN : $namespaces[0];
 177                 $t = Title::newFromText( $search, $ns );
 178                 if ( !$t || !$t->exists() ) {
 179                         // No exact match so just return the search results
 180                         return $srchres;
 181                 }
 182                 $string = $t->getPrefixedText();
 183                 $key = array_search( $string, $srchres );
 184                 if ( $key !== false ) {
 185                         // Exact match was in the results so just move it to the front
 186                         return $this->pullFront( $key, $srchres );
 187                 }
 188                 // Exact match not in the search results so check for some redirect handling cases
 189                 if ( $t->isRedirect() ) {
 190                         $target = $this->getRedirectTarget( $t );
 191                         $key = array_search( $target, $srchres );
 192                         if ( $key !== false ) {
 193                                 // Exact match is a redirect to one of the returned matches so pull the
 194                                 // returned match to the front.  This might look odd but the alternative
 195                                 // is to put the redirect in front and drop the match.  The name of the
 196                                 // found match is often more descriptive/better formed than the name of
 197                                 // the redirect AND by definition they share a prefix.  Hopefully this
 198                                 // choice is less confusing and more helpful.  But it might not be.  But
 199                                 // it is the choice we're going with for now.
 200                                 return $this->pullFront( $key, $srchres );
 201                         }
 202                         $redirectTargetsToRedirect = $this->redirectTargetsToRedirect( $srchres );
 203                         if ( isset( $redirectTargetsToRedirect[$target] ) ) {
 204                                 // The exact match and something in the results list are both redirects
 205                                 // to the same thing!  In this case we'll pull the returned match to the
 206                                 // top following the same logic above.  Again, it might not be a perfect
 207                                 // choice but it'll do.
 208                                 return $this->pullFront( $redirectTargetsToRedirect[$target], $srchres );
 209                         }
 210                 } else {
 211                         $redirectTargetsToRedirect = $this->redirectTargetsToRedirect( $srchres );
 212                         if ( isset( $redirectTargetsToRedirect[$string] ) ) {
 213                                 // The exact match is the target of a redirect already in the results list so remove
 214                                 // the redirect from the results list and push the exact match to the front
 215                                 array_splice( $srchres, $redirectTargetsToRedirect[$string], 1 );
 216                                 array_unshift( $srchres, $string );
 217                                 return $srchres;
 218                         }
 219                 }
 220
 221                 // Exact match is totally unique from the other results so just add it to the front
 222                 array_unshift( $srchres, $string );
 223                 // And roll one off the end if the results are too long
 224                 if ( count( $srchres ) > $limit ) {
 225                         array_pop( $srchres );
 226                 }
 227                 return $srchres;
 228         }
 229
 230         /**
 231          * @param Array(string) $titles as strings
 232          * @return Array(string => int) redirect target prefixedText to index of title in titles
 233          *   that is a redirect to it.
 234          */
 235         private function redirectTargetsToRedirect( $titles ) {
 236                 $result = array();
 237                 foreach ( $titles as $key => $titleText ) {
 238                         $title = Title::newFromText( $titleText );
 239                         if ( !$title || !$title->isRedirect() ) {
 240                                 continue;
 241                         }
 242                         $target = $this->getRedirectTarget( $title );
 243                         if ( !$target ) {
 244                                 continue;
 245                         }
 246                         $result[$target] = $key;
 247                 }
 248                 return $result;
 249         }
 250
 251         /**
 252          * @param int $key key to pull to the front
 253          * @return array $array with the item at $key pulled to the front
 254          */
 255         private function pullFront( $key, $array ) {
 256                 $cut = array_splice( $array, $key, 1 );
 257                 array_unshift( $array, $cut[0] );
 258                 return $array;
 259         }
 260
 261         /**
 262          * Get a redirect's destination from a title
 263          * @param Title $title A title to redirect. It may not redirect or even exist
 264          * @return null|string If title exists and redirects, get the destination's prefixed name
 265          */
 266         private function getRedirectTarget( $title ) {
 267                 $page = WikiPage::factory( $title );
 268                 if ( !$page->exists() ) {
 269                         return null;
 270                 }
 271                 $redir = $page->getRedirectTarget();
 272                 return $redir ? $redir->getPrefixedText() : null;
 273         }
 274
 275         /**
 276          * Prefix search special-case for Special: namespace.
 277          *
 278          * @param string $search Term
 279          * @param int $limit Max number of items to return
 280          * @param int $offset Number of items to offset
 281          * @return array
 282          */
 283         protected function specialSearch( $search, $limit, $offset ) {
 284                 global $wgContLang;
 285
 286                 $searchParts = explode( '/', $search, 2 );
 287                 $searchKey = $searchParts[0];
 288                 $subpageSearch = isset( $searchParts[1] ) ? $searchParts[1] : null;
 289
 290                 // Handle subpage search separately.
 291                 if ( $subpageSearch !== null ) {
 292                         // Try matching the full search string as a page name
 293                         $specialTitle = Title::makeTitleSafe( NS_SPECIAL, $searchKey );
 294                         if ( !$specialTitle ) {
 295                                 return array();
 296                         }
 297                         $special = SpecialPageFactory::getPage( $specialTitle->getText() );
 298                         if ( $special ) {
 299                                 $subpages = $special->prefixSearchSubpages( $subpageSearch, $limit, $offset );
 300                                 return array_map( function ( $sub ) use ( $specialTitle ) {
 301                                         return $specialTitle->getSubpage( $sub );
 302                                 }, $subpages );
 303                         } else {
 304                                 return array();
 305                         }
 306                 }
 307
 308                 # normalize searchKey, so aliases with spaces can be found - bug 25675
 309                 $searchKey = str_replace( ' ', '_', $searchKey );
 310                 $searchKey = $wgContLang->caseFold( $searchKey );
 311
 312                 // Unlike SpecialPage itself, we want the canonical forms of both
 313                 // canonical and alias title forms...
 314                 $keys = array();
 315                 foreach ( SpecialPageFactory::getNames() as $page ) {
 316                         $keys[$wgContLang->caseFold( $page )] = $page;
 317                 }
 318
 319                 foreach ( $wgContLang->getSpecialPageAliases() as $page => $aliases ) {
 320                         if ( !in_array( $page, SpecialPageFactory::getNames() ) ) {# bug 20885
 321                                 continue;
 322                         }
 323
 324                         foreach ( $aliases as $alias ) {
 325                                 $keys[$wgContLang->caseFold( $alias )] = $alias;
 326                         }
 327                 }
 328                 ksort( $keys );
 329
 330                 $srchres = array();
 331                 $skipped = 0;
 332                 foreach ( $keys as $pageKey => $page ) {
 333                         if ( $searchKey === '' || strpos( $pageKey, $searchKey ) === 0 ) {
 334                                 // bug 27671: Don't use SpecialPage::getTitleFor() here because it
 335                                 // localizes its input leading to searches for e.g. Special:All
 336                                 // returning Spezial:MediaWiki-Systemnachrichten and returning
 337                                 // Spezial:Alle_Seiten twice when $wgLanguageCode == 'de'
 338                                 if ( $offset > 0 && $skipped < $offset ) {
 339                                         $skipped++;
 340                                         continue;
 341                                 }
 342                                 $srchres[] = Title::makeTitleSafe( NS_SPECIAL, $page );
 343                         }
 344
 345                         if ( count( $srchres ) >= $limit ) {
 346                                 break;
 347                         }
 348                 }
 349
 350                 return $srchres;
 351         }
 352
 353         /**
 354          * Unless overridden by PrefixSearchBackend hook...
 355          * This is case-sensitive (First character may
 356          * be automatically capitalized by Title::secureAndSpit()
 357          * later on depending on $wgCapitalLinks)
 358          *
 359          * @param array $namespaces Namespaces to search in
 360          * @param string $search Term
 361          * @param int $limit Max number of items to return
 362          * @param int $offset Number of items to skip
 363          * @return array Array of Title objects
 364          */
 365         protected function defaultSearchBackend( $namespaces, $search, $limit, $offset ) {
 366                 $ns = array_shift( $namespaces ); // support only one namespace
 367                 if ( in_array( NS_MAIN, $namespaces ) ) {
 368                         $ns = NS_MAIN; // if searching on many always default to main
 369                 }
 370
 371                 $t = null;
 372                 if ( is_string( $search ) ) {
 373                         $t = Title::newFromText( $search, $ns );
 374                 }
 375
 376                 $prefix = $t ? $t->getDBkey() : '';
 377                 $dbr = wfGetDB( DB_SLAVE );
 378                 $res = $dbr->select( 'page',
 379                         array( 'page_id', 'page_namespace', 'page_title' ),
 380                         array(
 381                                 'page_namespace' => $ns,
 382                                 'page_title ' . $dbr->buildLike( $prefix, $dbr->anyString() )
 383                         ),
 384                         __METHOD__,
 385                         array(
 386                                 'LIMIT' => $limit,
 387                                 'ORDER BY' => 'page_title',
 388                                 'OFFSET' => $offset
 389                         )
 390                 );
 391                 $srchres = array();
 392                 foreach ( $res as $row ) {
 393                         $srchres[] = Title::newFromRow( $row );
 394                 }
 395                 return $srchres;
 396         }
 397
 398         /**
 399          * Validate an array of numerical namespace indexes
 400          *
 401          * @param array $namespaces
 402          * @return array (default: contains only NS_MAIN)
 403          */
 404         protected function validateNamespaces( $namespaces ) {
 405                 global $wgContLang;
 406
 407                 // We will look at each given namespace against wgContLang namespaces
 408                 $validNamespaces = $wgContLang->getNamespaces();
 409                 if ( is_array( $namespaces ) && count( $namespaces ) > 0 ) {
 410                         $valid = array();
 411                         foreach ( $namespaces as $ns ) {
 412                                 if ( is_numeric( $ns ) && array_key_exists( $ns, $validNamespaces ) ) {
 413                                         $valid[] = $ns;
 414                                 }
 415                         }
 416                         if ( count( $valid ) > 0 ) {
 417                                 return $valid;
 418                         }
 419                 }
 420
 421                 return array( NS_MAIN );
 422         }
 423 }
 424
 425 /**
 426  * Performs prefix search, returning Title objects
 427  * @ingroup Search
 428  */
 429 class TitlePrefixSearch extends PrefixSearch {
 430
 431         protected function titles( array $titles ) {
 432                 return $titles;
 433         }
 434
 435         protected function strings( array $strings ) {
 436                 $titles = array_map( 'Title::newFromText', $strings );
 437                 $lb = new LinkBatch( $titles );
 438                 $lb->setCaller( __METHOD__ );
 439                 $lb->execute();
 440                 return $titles;
 441         }
 442 }
 443
 444 /**
 445  * Performs prefix search, returning strings
 446  * @ingroup Search
 447  */
 448 class StringPrefixSearch extends PrefixSearch {
 449
 450         protected function titles( array $titles ) {
 451                 return array_map( function ( Title $t ) {
 452                         return $t->getPrefixedText();
 453                 }, $titles );
 454         }
 455
 456         protected function strings( array $strings ) {
 457                 return $strings;
 458         }
 459 }