[DOCUMENTATION] French: zend search lucene translation

git-svn-id: http://framework.zend.com/svn/framework/standard/trunk@21012 44c647ce-9c0f-0410-b52a-842ac1e357ba

documentation/manual/fr/module_specs/Zend_Search_Lucene-Searching.xml

@@ -6,9 +6,9 @@
     <sect2 id="zend.search.lucene.searching.query_building">
         <title>Construire des requêtes</title>
         <para>
-            Il y a deux méthodes pour chercher dans un index. La première
+            Il y a deux manières de chercher dans un index. La première
             utilise le parseur de requête pour construire une requête à partir
-            d'une chaîne de caractères. La seconde méthode consiste à créer vos
+            d'une chaîne de caractères. La seconde consiste à créer vos
             propres requêtes par programme à l'aide de l'<acronym>API</acronym>
             <classname>Zend_Search_Lucene</classname>.
         </para>
@@ -59,42 +59,47 @@
             </orderedlist>
         </para>
         <para>
-            Both ways use the same <acronym>API</acronym> method to search through the index:
+            Les deux manières utilisent la même méthode d'<acronym>API</acronym> pour chercher
+            dans l'index :
         </para>
         <programlisting language="php"><![CDATA[
 $index = Zend_Search_Lucene::open('/data/my_index');
 $index->find($query);
 ]]></programlisting>
         <para>
-            The <methodname>Zend_Search_Lucene::find()</methodname> method determines the input type
-            automatically and uses the query parser to construct an appropriate
-            <classname>Zend_Search_Lucene_Search_Query</classname> object from an input of type
-            string.
+            La méthode <methodname>Zend_Search_Lucene::find()</methodname> détermine automatiquement
+            le type de données entrantes et utilise le parseur de requêtes ou construit un objet
+            approprié à partir d''une donnée entrante de type chaîne de caractères.
         </para>
         <para>
-            It is important to note that the query parser uses the standard analyzer to tokenize
-            separate parts of query string. Thus all transformations which are applied to indexed
-            text are also applied to query strings.
+            Il est important de noter que le parseur de requêtes utilise l'analyseur standard
+            pour "tokenizer" les différentes partie d'une chaîne. Ainsi, toutes les transformations
+            qui sont appliquées aux textes indexés le sont également aux chaînes de requête.
         </para>
         <para>
-            The standard analyzer may transform the query string to lower case for
-            case-insensitivity, remove stop-words, and stem among other transformations.
+            L'analyseur standard peut transformer la chaîne de requête en minuscules pour
+            gérer l'insensibilité à la casse, retirer les mots exclus (ou "stop-words"), et
+            encapsuler les autres transformations.
         </para>
         <para>
-            The <acronym>API</acronym> method doesn't transform or filter input terms in any way.
-            It's therefore more suitable for computer generated or untokenized fields.
+            La méthode de l'<acronym>API</acronym> ne transforme ni ne filtre les termes entrant
+            d'aucune façon. Elle est ainsi plus pratique pour les champs générés par le programme
+            ou ceux qui ne sont pas "tokenizés".
         </para>
         <sect3 id="zend.search.lucene.searching.query_building.parsing">
-            <title>Query Parsing</title>
+            <title>Parsage de requêtes</title>
             <para>
-                <methodname>Zend_Search_Lucene_Search_QueryParser::parse()</methodname> method may
-                be used to parse query strings into query objects.
+                La méthode <methodname>Zend_Search_Lucene_Search_QueryParser::parse()</methodname>
+                peut être utilisée pour parser des chaînes de requête en objets de requête.
             </para>
             <para>
-                This query object may be used in query construction <acronym>API</acronym> methods
-                to combine user entered queries with programmatically generated queries.
+                Cet objet de requête peut être utilisé dans une méthode de construction de requête de
+                l'<acronym>API</acronym> pour combiner des requêtes entrées par l'utilisateur avec
+                des requêtes générées par programme.
             </para>
             <para>
+                Pour l'instant, dans certains cas c'est le seul moyen de chercher des valeurs dans
+                des champs "non-tokenizés" :
                 Actually, in some cases it's the only way to search for values within untokenized
                 fields:
                 <programlisting language="php"><![CDATA[
@@ -110,20 +115,20 @@ $hits = $index->find($query);
 ]]></programlisting>
             </para>
             <para>
-                <methodname>Zend_Search_Lucene_Search_QueryParser::parse()</methodname> method also
-                takes an optional encoding parameter, which can specify query string encoding:
+                La méthode <methodname>Zend_Search_Lucene_Search_QueryParser::parse()</methodname>
+                prend également un paramètre optionnel d'encodage, qui permet de spécifier l'encodage
+                de la chaîne de requête :
                 <programlisting language="php"><![CDATA[
 $userQuery = Zend_Search_Lucene_Search_QueryParser::parse($queryStr,
                                                           'iso-8859-5');
 ]]></programlisting>
             </para>
             <para>
-                If the encoding parameter is omitted, then current locale is used.
+                Si le paramètre d'encodage est omis, la locale courante est utilisée.
             </para>
             <para>
-                It's also possible to specify the default query string encoding with
-                <methodname>Zend_Search_Lucene_Search_QueryParser::setDefaultEncoding()</methodname>
-                method:
+                Il est également possible de spécifier l'encodage par défaut de la chaîne
+                de requête avec la méthode <methodname>Zend_Search_Lucene_Search_QueryParser::setDefaultEncoding()</methodname> :
                 <programlisting language="php"><![CDATA[
 Zend_Search_Lucene_Search_QueryParser::setDefaultEncoding('iso-8859-5');
 ...
@@ -132,25 +137,25 @@ $userQuery = Zend_Search_Lucene_Search_QueryParser::parse($queryStr);
             </para>
             <para>
                 <methodname>Zend_Search_Lucene_Search_QueryParser::getDefaultEncoding()</methodname>
-                returns the current default query string encoding (the empty string means "current
-                locale").
+                retourne la valeur actuelle de l'encodage par défaut d'une chaîne de requête (une
+                chaîne vide signifiant "locale courante").
             </para>
         </sect3>
     </sect2>
     <sect2 id="zend.search.lucene.searching.results">
-        <title>Search Results</title>
+        <title>Résultats de recherche</title>
         <para>
-            The search result is an array of
-            <classname>Zend_Search_Lucene_Search_QueryHit</classname> objects. Each of these has two
-            properties: <code>$hit->id</code> is a document number within the index and
-            <code>$hit->score</code> is a score of the hit in a search result. The results are
-            ordered by score (descending from highest score).
+            Le résultat de recherche est un tableau d'objets
+            <classname>Zend_Search_Lucene_Search_QueryHit</classname>. Chacun d'eux a deux propriétés :
+            <code>$hit->id</code> est un identifiant numérique de document dans l'index et
+            <code>$hit->score</code> est le score du hit dans le résultat de recherche. Les résultats
+            sont triés par score (descendant depuis le meilleur score).
         </para>
         <para>
-            The <classname>Zend_Search_Lucene_Search_QueryHit</classname> object also exposes each
-            field of the <classname>Zend_Search_Lucene_Document</classname> found in the search as a
-            property of the hit. In the following example, a hit is returned with two fields from
-            the corresponding document: title and author.
+            L'objet <classname>Zend_Search_Lucene_Search_QueryHit</classname> expose également
+            chaque champ du <classname>Zend_Search_Lucene_Document</classname> trouvé dans la
+            recherche en tant que propriété du hit. Dans l'exemple suivant, un hit est retourné avec
+            deux champs du document correspondant : title et author.
         </para>
         <programlisting language="php"><![CDATA[
 $index = Zend_Search_Lucene::open('/data/my_index');
@@ -162,14 +167,14 @@ foreach ($hits as $hit) {
 }
 ]]></programlisting>
         <para>
-            Stored fields are always returned in UTF-8 encoding.
+            Les champs stockés sont toujours retournés encodés en UTF-8.
         </para>
         <para>
-            Optionally, the original <classname>Zend_Search_Lucene_Document</classname> object can
-            be returned from the <classname>Zend_Search_Lucene_Search_QueryHit</classname>.
-            You can retrieve stored parts of the document by using the
-            <methodname>getDocument()</methodname> method of the index object and then get them by
-            <methodname>getFieldValue()</methodname> method:
+            Optionnellement, l'objet original <classname>Zend_Search_Lucene_Document</classname>
+            peut être retourné depuis le <classname>Zend_Search_Lucene_Search_QueryHit</classname>.
+            Vous pouvez récupérer les parties stockées du document en utilisant la méthode
+            <methodname>getDocument()</methodname> de l'objet index, puis les obtenir avec la
+            méthode <methodname>getFieldValue()</methodname> :
         </para>
         <programlisting language="php"><![CDATA[
 $index = Zend_Search_Lucene::open('/data/my_index');
@@ -187,55 +192,55 @@ foreach ($hits as $hit) {
 }
 ]]></programlisting>
         <para>
-            The fields available from the <classname>Zend_Search_Lucene_Document</classname> object
-            are determined at the time of indexing. The document fields are either indexed, or
-            index and stored, in the document by the indexing application
-            (e.g. LuceneIndexCreation.jar).
+            Les champs disponibles dans l'objet <classname>Zend_Search_Lucene_Document</classname>
+            sont déterminés lors de l'indexation. Les champs sont soit indexés, soit indexés et stockés
+            dans le document par l'application d'indexage (p. ex. LuceneIndexCreation.jar).
         </para>
         <para>
-            Note that the document identity ('path' in our example) is also stored
-            in the index and must be retrieved from it.
+            Notez que l'identité du document ('path' dans notre exemple) est également
+            stocké dans l'index et doit être récupéré depuis l'index.
         </para>
     </sect2>
     <sect2 id="zend.search.lucene.searching.results-limiting">
-        <title>Limiting the Result Set</title>
+        <title>Limiter le nombre de résultats</title>
         <para>
-            The most computationally expensive part of searching is score calculation. It may take
-            several seconds for large result sets (tens of thousands of hits).
+            L'opération la plus lourde au niveau du calcul dans une recherche est la calculation
+            des scores. Cela peut prendre plusieurs secondes pour un grand ensemble de résultats
+            (dizaine de milliers de hits).
         </para>
         <para>
-            <classname>Zend_Search_Lucene</classname> gives the possibility to limit result set size
-            with <methodname>getResultSetLimit()</methodname> and
-            <methodname>setResultSetLimit()</methodname> methods:
+            <classname>Zend_Search_Lucene</classname> donne la possibilité de limiter la taille
+            de l'ensemble de résultats avec les méthodes <methodname>getResultSetLimit()</methodname>
+            et <methodname>setResultSetLimit()</methodname> :
             <programlisting language="php"><![CDATA[
 $currentResultSetLimit = Zend_Search_Lucene::getResultSetLimit();
 Zend_Search_Lucene::setResultSetLimit($newLimit);
 ]]></programlisting>
-            The default value of 0 means 'no limit'.
+            La valeur par défaut de 0 signifie 'pas de limite'.
         </para>
         <para>
-            It doesn't give the 'best N' results, but only the 'first N'
+            Cela ne retournera pas les 'N meilleurs' résultats, mais seulement les 'N premiers'.
             <footnote>
                 <para>
-                    Returned hits are still ordered by score or by the specified order, if given.
+                    Les hits retournés demeurent triés par score ou par l'ordre spécifié, s'il est spécifié.
                 </para>
             </footnote>.
         </para>
     </sect2>
     <sect2 id="zend.search.lucene.searching.results-scoring">
-        <title>Results Scoring</title>
+        <title>Etablissement des scores des résultats de recherche</title>
         <para>
-            <classname>Zend_Search_Lucene</classname> uses the same scoring algorithms as Java
-            Lucene. All hits in the search result are ordered by score by default. Hits with greater
-            score come first, and documents having higher scores should match the query more
-            precisely than documents having lower scores.
+            <classname>Zend_Search_Lucene</classname> utilise le même algorithme de scoring que
+            Java Lucene. Par défaut, tous les hits dans l'ensemble de résultats sont triés par score.
+            Les hits avec le plus grand score viennent en premier, et les documents avec des hauts scores
+            devraient mieux correspondre à la requête que ceux avec des scores moins élevés.
         </para>
         <para>
-            Roughly speaking, search hits that contain the searched term or phrase more frequently
-            will have a higher score.
+            En gros, les hits qui contiennent le terme ou la phrase cherché plus fréquemment
+            auront un score plus élevé.
         </para>
         <para>
-            A hit's score can be retrieved by accessing the <code>score</code> property of the hit:
+            Le score d'un hit peut être récupéré en accédant à la propriété <code>score</code> du hit :
         </para>
         <programlisting language="php"><![CDATA[
 $hits = $index->find($query);
@@ -245,21 +250,21 @@ foreach ($hits as $hit) {
 }
 ]]></programlisting>
         <para>
-            The <classname>Zend_Search_Lucene_Search_Similarity</classname> class is used to
-            calculate the score for each hit. See <link
+            La classe <classname>Zend_Search_Lucene_Search_Similarity</classname> est utilisée
+            pour calculer le score pour chaque hit. Consultez la section <link
                 linkend="zend.search.lucene.extending.scoring">Extensibility. Scoring
-                Algorithms</link> section for details.
+                Algorithms</link> pour des détails.
         </para>
     </sect2>
     <sect2 id="zend.search.lucene.searching.sorting">
-        <title>Search Result Sorting</title>
+        <title>Tri des résultats de recherche</title>
         <para>
-            By default, the search results are ordered by score. The programmer can change this
-            behavior by setting a sort field (or a list of fields), sort type and sort order
-            parameters.
+            Par défaut, les résultats de recherche sont triés par score. Le programmeur peut
+            changer ce comportement en définissant des paramètres pour le champ de tri (ou une liste de champs), le
+            type de tri et le sens de tri.
         </para>
         <para>
-            <code>$index->find()</code> call may take several optional parameters:
+            L'appel à <code>$index->find()</code> peut prendre plusieurs paramètres optionnels :
             <programlisting language="php"><![CDATA[
 $index->find($query [, $sortField [, $sortType [, $sortOrder]]]
                     [, $sortField2 [, $sortType [, $sortOrder]]]
@@ -267,22 +272,22 @@ $index->find($query [, $sortField [, $sortType [, $sortOrder]]]
 ]]></programlisting>
         </para>
         <para>
-             A name of stored field by which to sort result should be passed as the
-             <varname>$sortField</varname> parameter.
+            Le nom d'un champ stocké par lequel on veut trier les résultats devrait
+            être passé comme paramètre <varname>$sortField</varname>.
         </para>
         <para>
-            <varname>$sortType</varname> may be omitted or take the following enumerated values:
-            <constant>SORT_REGULAR</constant> (compare items normally- default value),
-            <constant>SORT_NUMERIC</constant> (compare items numerically),
-            <constant>SORT_STRING</constant> (compare items as strings).
+            <varname>$sortType</varname> peut être omis ou prendre l'une des valeurs suivantes :
+            <constant>SORT_REGULAR</constant> (compare les éléments normalement- valeur par défaut),
+            <constant>SORT_NUMERIC</constant> (compare les éléments comme des valeurs numériques),
+            <constant>SORT_STRING</constant> (compare les éléments comme des chaînes de caractères).
         </para>
         <para>
-            <varname>$sortOrder</varname> may be omitted or take the following enumerated values:
-            <constant>SORT_ASC</constant> (sort in ascending order- default value),
-            <constant>SORT_DESC</constant> (sort in descending order).
+            <varname>$sortOrder</varname> peut être omis ou prendre l'une des valeurs suivantes :
+            <constant>SORT_ASC</constant> (trie dans l'ordre croissant- valeur par défaut),
+            <constant>SORT_DESC</constant> (trie dans l'ordre décroissant).
         </para>
         <para>
-            Examples:
+            Exemples:
             <programlisting language="php"><![CDATA[
 $index->find($query, 'quantity', SORT_NUMERIC, SORT_DESC);
 ]]></programlisting>