Code Coverage
 
Classes and Traits
Functions and Methods
Lines
Total
0.00% covered (danger)
0.00%
0 / 1
81.25% covered (warning)
81.25%
13 / 16
CRAP
96.47% covered (success)
96.47%
82 / 85
ParsedQuery
0.00% covered (danger)
0.00%
0 / 1
81.25% covered (warning)
81.25%
13 / 16
39
96.47% covered (success)
96.47%
82 / 85
 __construct
100.00% covered (success)
100.00%
1 / 1
3
100.00% covered (success)
100.00%
11 / 11
 getRoot
100.00% covered (success)
100.00%
1 / 1
1
100.00% covered (success)
100.00%
1 / 1
 getQuery
0.00% covered (danger)
0.00%
0 / 1
2
0.00% covered (danger)
0.00%
0 / 1
 getQueryWithoutNsHeader
0.00% covered (danger)
0.00%
0 / 1
2.15
66.67% covered (warning)
66.67%
2 / 3
 getRawQuery
100.00% covered (success)
100.00%
1 / 1
1
100.00% covered (success)
100.00%
1 / 1
 hasCleanup
100.00% covered (success)
100.00%
1 / 1
1
100.00% covered (success)
100.00%
1 / 1
 getParseWarnings
100.00% covered (success)
100.00%
1 / 1
1
100.00% covered (success)
100.00%
1 / 1
 getNamespaceHeader
100.00% covered (success)
100.00%
1 / 1
1
100.00% covered (success)
100.00%
1 / 1
 getRequiredNamespaces
0.00% covered (danger)
0.00%
0 / 1
2
0.00% covered (danger)
0.00%
0 / 1
 getActualNamespaces
100.00% covered (success)
100.00%
1 / 1
10
100.00% covered (success)
100.00%
16 / 16
 getCrossSearchStrategy
100.00% covered (success)
100.00%
1 / 1
2
100.00% covered (success)
100.00%
10 / 10
 isQueryOfClass
100.00% covered (success)
100.00%
1 / 1
1
100.00% covered (success)
100.00%
1 / 1
 loadQueryClass
100.00% covered (success)
100.00%
1 / 1
2
100.00% covered (success)
100.00%
5 / 5
 preloadQueryClasses
100.00% covered (success)
100.00%
1 / 1
2
100.00% covered (success)
100.00%
3 / 3
 getFeaturesUsed
100.00% covered (success)
100.00%
1 / 1
3
100.00% covered (success)
100.00%
10 / 10
 toArray
100.00% covered (success)
100.00%
1 / 1
7
100.00% covered (success)
100.00%
19 / 19
<?php
namespace CirrusSearch\Parser\AST;
use CirrusSearch\CrossSearchStrategy;
use CirrusSearch\Parser\AST\Visitor\KeywordNodeVisitor;
use CirrusSearch\Parser\ParsedQueryClassifiersRepository;
use Wikimedia\Assert\Assert;
/**
 * Parsed query
 */
class ParsedQuery {
    /**
     * markup to indicate that the query was cleaned up
     * detecting a double quote used as a gershayim
     * see T66350
     */
    public const CLEANUP_GERSHAYIM_QUIRKS = 'gershayim_quirks';
    /**
     * markup to indicate that the had some question marks
     * stripped
     * @see \CirrusSearch\Util::stripQuestionMarks
     */
    public const CLEANUP_QMARK_STRIPPING = 'stripped_qmark';
    /**
     * markup to indicate that we removed a '~' at the beginning of the query
     */
    public const TILDE_HEADER = 'tilde_header';
    /**
     * @var ParsedNode
     */
    private $root;
    /**
     * @var string
     */
    private $query;
    /**
     * @var string
     */
    private $rawQuery;
    /**
     * @var bool[] indexed by cleanup type
     */
    private $queryCleanups;
    /**
     * @var ParseWarning[]
     */
    private $parseWarnings;
    /**
     * @var NamespaceHeaderNode|null namespace specified at the beginning of the query
     */
    private $namespaceHeader;
    /**
     * @var array|string (array of int or 'all') list of required namespaces
     * for the query to be able to return results.
     * This list of namespace must always be added no matter what is requested
     * before.
     * Main use-case is the prefix keyword that must supersede any other settings.
     */
    private $requiredNamespaces;
    /**
     * @var CrossSearchStrategy|null (lazy loaded)
     */
    private $crossSearchStrategy;
    /**
     * @var ParsedQueryClassifiersRepository
     */
    private $classifierRepository;
    /**
     * @var bool[] indexed by query class name
     */
    private $queryClassCache = [];
    /**
     * @var string[] list of used features in the query
     * @see \CirrusSearch\Query\KeywordFeature::getFeatureName()
     */
    private $featuresUsed;
    /**
     * @param ParsedNode $root
     * @param string $query cleaned up query string
     * @param string $rawQuery original query as received by the search engine
     * @param bool[] $queryCleanups indexed by cleanup type (non-empty when $query !== $rawQuery)
     * @param ?NamespaceHeaderNode $namespaceHeader namespace found as a "header" of the query
     *        is a int when a namespace id is provided, string with 'all' or null if none specified
     * @param array|string $requiredNamespaces
     * @param ParseWarning[] $parseWarnings list of warnings detected during parsing
     * @param ParsedQueryClassifiersRepository $repository
     */
    public function __construct(
        ParsedNode $root,
        $query,
        $rawQuery,
        $queryCleanups,
        ?NamespaceHeaderNode $namespaceHeader,
        $requiredNamespaces,
        array $parseWarnings,
        ParsedQueryClassifiersRepository $repository
    ) {
        $this->root = $root;
        $this->query = $query;
        $this->rawQuery = $rawQuery;
        $this->queryCleanups = $queryCleanups;
        $this->parseWarnings = $parseWarnings;
        $this->namespaceHeader = $namespaceHeader;
        Assert::parameter( is_array( $requiredNamespaces ) || $requiredNamespaces === 'all',
            '$requiredNamespaces', 'must be an array or "all"' );
        $this->requiredNamespaces = $requiredNamespaces;
        $this->classifierRepository = $repository;
    }
    /**
     * @return ParsedNode
     */
    public function getRoot() {
        return $this->root;
    }
    /**
     * The query being parsed
     * Some cleanups may have been made to the raw query
     * NOTE: the query may include the namespace header
     * @return string
     */
    public function getQuery() {
        return $this->query;
    }
    /**
     * The query string without the namespace header
     * @return string
     */
    public function getQueryWithoutNsHeader() {
        // TODO: remove once the AST is fully used by all building components.
        if ( $this->namespaceHeader !== null ) {
            return substr( $this->query, $this->namespaceHeader->getEndOffset() );
        }
        return $this->query;
    }
    /**
     * The raw query as received by the search engine
     * @return string
     */
    public function getRawQuery() {
        return $this->rawQuery;
    }
    /**
     * Check if the query was cleanup with this type
     * @see ParsedQuery::CLEANUP_QMARK_STRIPPING
     * @see ParsedQuery::CLEANUP_GERSHAYIM_QUIRKS
     * @param string $cleanup
     * @return bool
     */
    public function hasCleanup( $cleanup ) {
        return isset( $this->queryCleanups[$cleanup] );
    }
    /**
     * List of warnings detected at parse time
     * @return ParseWarning[]
     */
    public function getParseWarnings() {
        return $this->parseWarnings;
    }
    /**
     * Get the node of the namespace header identified in the prefix of the query
     * if specified.
     * It can be null in all other cases
     * @return NamespaceHeaderNode|null
     */
    public function getNamespaceHeader() {
        return $this->namespaceHeader;
    }
    /**
     * @return array|string array of additional namespaces or 'all' if all namespaces required
     */
    public function getRequiredNamespaces() {
        return $this->requiredNamespaces;
    }
    /**
     * Determine the actual namespaces required for this query to run
     * assuming that $namespaces is the list of namespaces initially requested
     * usually set <code>\SearchEngine::setNamespaces()</code>.
     *
     * @param int[]|null $namespaces initial namespaces
     * @param int[]|null $additionalRequiredNamespaces additional namespaces required (by ContextualFilters)
     * @return int[] the list of namespaces that have to be queried,
     * empty array means all namespaces
     * @see \SearchEngine::setNamespaces()
     * @see self::getRequiredNamespaces()
     * @see self::getNamespaceHeader()
     * @see \CirrusSearch\Query\Builder\ContextualFilter::requiredNamespaces()
     */
    public function getActualNamespaces( array $namespaces = null, array $additionalRequiredNamespaces = null ) {
        if ( $this->requiredNamespaces === 'all' ) {
            // e.g. prefix:all:foo (all namespaces must be queried no matter what is requested before
            return [];
        }
        if ( $additionalRequiredNamespaces === [] ) {
            return [];
        }
        if ( $this->namespaceHeader !== null && $this->namespaceHeader->getNamespace() === 'all' ) {
            // e.g. all:foo
            return [];
        }
        if ( $this->namespaceHeader === null && !$namespaces ) {
            // Everything was selected using SearchEngine::setNamespaces() but nothing more specific
            // was requested using a prefixed ns
            return [];
        }
        // now everything else will be an explicit list of namespaces
        Assert::postcondition( $this->namespaceHeader === null || is_int( $this->namespaceHeader->getNamespace() ),
            '$this->namespaceHeader must be null or an integer' );
        $ns = $this->namespaceHeader === null ? $namespaces : [ $this->namespaceHeader->getNamespace() ];
        Assert::postcondition( is_array( $ns ) && $ns !== [],
            'at this point we must have a list of specific namespaces' );
        return array_values( array_unique(
            array_merge( $ns, $this->requiredNamespaces, $additionalRequiredNamespaces ?? [] ),
            SORT_REGULAR
        ) );
    }
    /**
     * Get the cross search strategy supported by this query.
     *
     * @return CrossSearchStrategy
     */
    public function getCrossSearchStrategy() {
        if ( $this->crossSearchStrategy === null ) {
            $visitor = new class() extends KeywordNodeVisitor {
                public $strategy;
                public function __construct( array $excludeOccurs = [], array $keywordClasses = [] ) {
                    parent::__construct( $excludeOccurs, $keywordClasses );
                    $this->strategy = CrossSearchStrategy::allWikisStrategy();
                }
                /**
                 * @param KeywordFeatureNode $node
                 */
                public function doVisitKeyword( KeywordFeatureNode $node ) {
                    $this->strategy = $this->strategy
                        ->intersect( $node->getKeyword()->getCrossSearchStrategy( $node ) );
                }
            };
            $this->root->accept( $visitor );
            $this->crossSearchStrategy = $visitor->strategy;
        }
        return $this->crossSearchStrategy;
    }
    /**
     * @param string $class
     * @return bool
     * @throws \CirrusSearch\Parser\ParsedQueryClassifierException if the class is unknown
     */
    public function isQueryOfClass( $class ) {
        return $this->queryClassCache[$class] ?? $this->loadQueryClass( $class );
    }
    /**
     * @param string $class
     * @return bool
     * @throws \CirrusSearch\Parser\ParsedQueryClassifierException
     */
    private function loadQueryClass( $class ) {
        $classifier = $this->classifierRepository->getClassifier( $class );
        $newClasses = $classifier->classify( $this );
        foreach ( $classifier->classes() as $k ) {
            $this->queryClassCache[$k] = in_array( $k, $newClasses, true );
        }
        return $this->queryClassCache[$class];
    }
    /**
     * Preload all known query classes and classify this
     * query.
     * @throws \CirrusSearch\Parser\ParsedQueryClassifierException
     */
    public function preloadQueryClasses() {
        foreach ( $this->classifierRepository->getKnownClassifiers() as $class ) {
            $this->isQueryOfClass( $class );
        }
    }
    /**
     * Get the list of keyword features used by this query.
     * @see \CirrusSearch\Query\KeywordFeature::getFeatureName()
     * @return string[]
     */
    public function getFeaturesUsed() {
        if ( $this->featuresUsed === null ) {
            $visitor = new class() extends KeywordNodeVisitor {
                public $features = [];
                /**
                 * @param KeywordFeatureNode $node
                 */
                public function doVisitKeyword( KeywordFeatureNode $node ) {
                    $name = $node->getKeyword()
                        ->getFeatureName( $node->getKey(), $node->getDelimiter() );
                    $this->features[$name] = true;
                }
            };
            $this->root->accept( $visitor );
            $this->featuresUsed = array_keys( $visitor->features );
            if ( $this->namespaceHeader ) {
                $this->featuresUsed[] = 'namespace_header';
            }
        }