calibre - en to fr_CA translation catalogue (21 entries)

en: XPath tutorial
fr_CA: Tutoriel XPath

en: In this tutorial, you will be given a gentle introduction to `XPath <https://en.wikipedia.org/wiki/XPath>`_, a query language that can be used to select arbitrary parts of `HTML <https://en.wikipedia.org/wiki/HTML>`_ documents in calibre. XPath is a widely used standard, and googling it will yield a ton of information. This tutorial, however, focuses on using XPath for e-book related tasks like finding chapter headings in an unstructured HTML document.
fr_CA: Dans ce tutoriel, il vous sera donné une légère introduction à  `XPath <https://fr.wikipedia.org/wiki/XPath>`_, un langage de requête qui peut être utilisé pour sélectionner des parties quelconques de documents `HTML <https://fr.wikipedia.org/wiki/HTML>`_ dans calibre. XPath est un standard utilisé largement, et faire une recherche sur Google produira une tonne d'information. Ce tutoriel, toutefois, se concentrera sur l'utilisation d'XPath pour des tâches relatives aux livres numériques comme trouver les entêtes de chapitre dans un document HTML non structuré.

en: Contents
fr_CA: Contenu

en: Selecting by tag name
fr_CA: Sélection par nom de balise

en: The simplest form of selection is to select tags by name. For example, suppose you want to select all the ``<h2>`` tags in a document. The XPath query for this is simply::
fr_CA: La forme la plus simple de sélection est de sélectionner les balises par nom. Par exemple, supposons que vous voulez sélectionner toutes les balises ``<h2>`` dans un document. La requête XPath pour cela est simplement ::

en: The prefix `//` means *search at any level of the document*. Now suppose you want to search for ``<span>`` tags that are inside ``<a>`` tags. That can be achieved with::
fr_CA: Le préfixe `//`signifie *rechercher à n'importe quel niveau du document*. Maintenant supposons que vous voulez rechercher les balises ``<span>`` qui sont contenues dans des balises ``<a>``. Ceci peut être accompli avec ::

en: If you want to search for tags at a particular level in the document, change the prefix::
fr_CA: Si vous voulez rechercher des balises à un niveau particulier dans le document, changez le préfixe ::

en: This will match only ``<p>A very short e-book to demonstrate the use of XPath.</p>`` in the :ref:`sample_ebook` but not any of the other ``<p>`` tags. The ``h:`` prefix in the above examples is needed to match XHTML tags. This is because internally, calibre represents all content as XHTML. In XHTML tags have a *namespace*, and ``h:`` is the namespace prefix for HTML tags.
fr_CA: Ceci correspondra uniquement à ``<p>Un livre numérique très court pour démontrer l'utilisation d'XPath.</p>`` dans le :ref:`sample_ebook` mais dans aucune des autres balises ``<p>``. Le préfixe ``h:`` dans l'exemple plus haut est nécessaire pour correspondre aux balises XHTML. Ceci car, en interne, calibre représente tout le contenu comme du XHTML. En XHTML les balises ont un *espace de nom*, et  ``h:`` est le préfixe d'espace de nom pour les balises HTML.

en: Now suppose you want to select both ``<h1>`` and ``<h2>`` tags. To do that, we need a XPath construct called *predicate*. A :dfn:`predicate` is simply a test that is used to select tags. Tests can be arbitrarily powerful and as this tutorial progresses, you will see more powerful examples. A predicate is created by enclosing the test expression in square brackets::
fr_CA: Maintenant supposons que vous voulez sélectionner conjointement les balises ``<h1>`` et ``<h2>``. Pour faire cela, nous avons besoin d'une construction XPath appelée *prédicat*. Un :dfn:`prédicat` est simplement un test qui est utilisé pour sélectionner les balises. Les tests peuvent être arbitrairement puissants et au long de la progression de ce tutoriel, vous verrez des exemples plus puissants. Un prédicat est créé en mettant l'expression test entre crochets.

en: There are several new features in this XPath expression. The first is the use of the wildcard ``*``. It means *match any tag*. Now look at the test expression ``name()='h1' or name()='h2'``. :term:`name()` is an example of a *built-in function*. It simply evaluates to the name of the tag. So by using it, we can select tags whose names are either `h1` or `h2`. Note that the :term:`name()` function ignores namespaces so that there is no need for the ``h:`` prefix. XPath has several useful built-in functions. A few more will be introduced in this tutorial.
fr_CA: Il y a plusieurs nouvelles caractéristiques dans cette expression XPath. La première est l'utilisation du joker ``*``. Il signifie *correspond à n'importe quelle balise*. Maintenant regardez l'expression test ``name()='h1' or name()='h2'``. :term:`name()` est un exemple d'une *fonction intégrée*. Il évalue simplement le nom de la balise. Donc en l'utilisant, nous pouvons sélectionner des balises dont les noms sont soit `h1` ou `h2`. Notez que la fonction :term:`name()` ignore les espaces de nom de sorte qu'il n'est d'aucune nécessité du préfixe ``h:``. XPath a plusieurs fonctions intégrées utiles. Quelques unes de plus seront introduites dans ce tutoriel.

en: Selecting by attributes
fr_CA: Sélection par attributs

en: To select tags based on their attributes, the use of predicates is required::
fr_CA: Pour sélectionner des balises sur base de leurs attributs, l'utilisation des prédicats est requise //

en: Here, the ``@`` operator refers to the attributes of the tag. You can use some of the `XPath built-in functions`_ to perform more sophisticated matching on attribute values.
fr_CA: Ici l'opérateur ``@`` réfère aux attributs de la balise. Vous pouvez utiliser certaines des `Fonctions intégrées XPath`_ pour effectuer des correspondances plus sophistiquées sur les valeurs attribut.

en: Selecting by tag content
fr_CA: Sélection par contenu de balise

en: Using XPath, you can even select tags based on the text they contain. The best way to do this is to use the power of *regular expressions* via the built-in function :term:`re:test()`::
fr_CA: En utilisant XPath, vous pouvez même sélectionner des balises basées sur le texte qu'elles contiennent. La meilleure manière de faire cela est d'utiliser la puissance des *expressions régulières* par l'intermédiaire de la fonction intégrée :term:`re:test()`::

en: Here the ``.`` operator refers to the contents of the tag, just as the ``@`` operator referred to its attributes.
fr_CA: Ici l'opérateur ``.`` réfère au contenu de la balise, tout comme l'opérateur ``@`` réfère à ses attributs.

en: Sample e-book
fr_CA: Exemple de livre numérique

en: XPath built-in functions
fr_CA: Les fonctions XPath intégrées

en: The name of the current tag.
fr_CA: Le nom de la balise actuelle.

en: ``contains(s1, s2)`` returns `true` if s1 contains s2.
fr_CA: ``contains(s1, s2)`` renvoie `true` si s1 contient s2.

en: ``re:test(src, pattern, flags)`` returns `true` if the string `src` matches the regular expression `pattern`. A particularly useful flag is ``i``, it makes matching case insensitive. A good primer on the syntax for regular expressions can be found at `regexp syntax <https://docs.python.org/library/re.html>`_
fr_CA: ``re:test(src, pattern, flags)`` renvoie `true` si la chaîne `src` correspond au `pattern` de l'expression régulière. un indicateur particulièrement utile est ``i``, il rend les correspondances sensibles à la casse. Une bonne amorce sur la syntaxe pour les expressions régulières peut être trouvée sur `regexp syntax <https://docs.python.org/library/re.html>`_
