Example #1
0
 /**
  * Renvoie l'url rewritée complète.
  * Si l'id de la route à utiliser pour la base de l'url a déjà été défini par les méthodes
  * \Aouka\Project\Routing\UrlRewriter::setDefaultUrl() ou \Aouka\Project\Routing\UrlRewriter::setUrlId(),
  * c'est ce dernier id qui sera utilisé.
  * 
  * @param string $sRouteId Id de la route à utiliser pour rewriter l'url. Surcharge le précédent Id éventuel.
  * @param array $aParams Liste des paramètres associés à la route.
  * @return Url
  */
 public static function getUrl($sRouteId = '', $aParams = [])
 {
     $oSelf = new self();
     $cUriComponent = null;
     $aUriComponentsToRewrite = [];
     if ($sRouteId) {
         $oSelf->setRoute($sRouteId, $aParams);
         $cUriComponent = $oSelf->getComponentType($sRouteId);
         switch ($cUriComponent) {
             case self::URI_PATH:
                 $aUriComponentsToRewrite = [self::URI_BASEPATH, self::URI_PATH];
                 break;
             case self::URI_COMPLETE_PATH:
                 $aUriComponentsToRewrite = [self::URI_COMPLETE_PATH];
                 break;
         }
     }
     $oSelf->rewrite($aUriComponentsToRewrite);
     return $oSelf->get($cUriComponent);
 }
Example #2
0
 /**
  * Re-write query into primitive queries in the context of specified index
  *
  * @param \Zend\Search\Lucene\SearchIndex $index
  * @throws \Zend\Search\Lucence\Search\Exception\QueryParserException
  * @return \Zend\Search\Lucene\Search\Query\AbstractQuery
  */
 public function rewrite(Lucene\SearchIndex $index)
 {
     if ($this->_field === null) {
         $query = new Search\Query\Boolean();
         $hasInsignificantSubqueries = false;
         if (Lucene\Lucene::getDefaultSearchField() === null) {
             $searchFields = $index->getFieldNames(true);
         } else {
             $searchFields = array(Lucene\Lucene::getDefaultSearchField());
         }
         foreach ($searchFields as $fieldName) {
             $subquery = new self($this->_word, $this->_encoding, $fieldName, $this->_minimumSimilarity);
             $rewrittenSubquery = $subquery->rewrite($index);
             if (!($rewrittenSubquery instanceof Query\Insignificant || $rewrittenSubquery instanceof Query\EmptyResult)) {
                 $query->addSubquery($rewrittenSubquery);
             }
             if ($rewrittenSubquery instanceof Query\Insignificant) {
                 $hasInsignificantSubqueries = true;
             }
         }
         $subqueries = $query->getSubqueries();
         if (count($subqueries) == 0) {
             $this->_matches = array();
             if ($hasInsignificantSubqueries) {
                 return new Query\Insignificant();
             } else {
                 return new Query\EmptyResult();
             }
         }
         if (count($subqueries) == 1) {
             $query = reset($subqueries);
         }
         $query->setBoost($this->getBoost());
         $this->_matches = $query->getQueryTerms();
         return $query;
     }
     // -------------------------------------
     // Recognize exact term matching (it corresponds to Keyword fields stored in the index)
     // encoding is not used since we expect binary matching
     $term = new Index\Term($this->_word, $this->_field);
     if ($index->hasTerm($term)) {
         $query = new Query\Fuzzy($term, $this->_minimumSimilarity);
         $query->setBoost($this->getBoost());
         // Get rewritten query. Important! It also fills terms matching container.
         $rewrittenQuery = $query->rewrite($index);
         $this->_matches = $query->getQueryTerms();
         return $rewrittenQuery;
     }
     // -------------------------------------
     // Recognize wildcard queries
     /** @todo check for PCRE unicode support may be performed through Zend_Environment in some future */
     if (@preg_match('/\\pL/u', 'a') == 1) {
         $subPatterns = preg_split('/[*?]/u', iconv($this->_encoding, 'UTF-8', $this->_word));
     } else {
         $subPatterns = preg_split('/[*?]/', $this->_word);
     }
     if (count($subPatterns) > 1) {
         throw new QueryParserException('Fuzzy search doesn\'t support wildcards (except within Keyword fields).');
     }
     // -------------------------------------
     // Recognize one-term multi-term and "insignificant" queries
     $tokens = Analyzer\Analyzer::getDefault()->tokenize($this->_word, $this->_encoding);
     if (count($tokens) == 0) {
         $this->_matches = array();
         return new Query\Insignificant();
     }
     if (count($tokens) == 1) {
         $term = new Index\Term($tokens[0]->getTermText(), $this->_field);
         $query = new Query\Fuzzy($term, $this->_minimumSimilarity);
         $query->setBoost($this->getBoost());
         // Get rewritten query. Important! It also fills terms matching container.
         $rewrittenQuery = $query->rewrite($index);
         $this->_matches = $query->getQueryTerms();
         return $rewrittenQuery;
     }
     // Word is tokenized into several tokens
     throw new QueryParserException('Fuzzy search is supported only for non-multiple word terms');
 }