calibre - en to gl translation catalogue (24 entries)

en: XPath tutorial
gl: Titorial de 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.
gl: Neste tutorial, darase unha introdución sinxela a `XPath <https://en.wikipedia.org/wiki/XPath>`_, unha linguaxe de consulta que se pode usar para seleccionar partes arbitrarias de documentos `HTML <https://en.wikipedia.org/wiki/HTML>`_ en Calibre. XPath é un estándar amplamente utilizado e buscalo en Google obterá moitísima información. Non obstante, este tutorial céntrase no uso de XPath para tarefas relacionadas con libros electrónicos, como atopar cabeceiras de capítulo nun documento HTML non estruturado.

en: Contents
gl: Contidos

en: Selecting by tag name
gl: Selección polo nome da etiqueta

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::
gl: A forma máis sinxela de selección é seleccionar etiquetas polo nome. Por exemplo, supoñamos que queres seleccionar todas as etiquetas ``<h2>`` dun documento. A consulta XPath para isto é simplemente::

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::
gl: O prefixo `//` significa *buscar en calquera nivel do documento*. Agora supoñamos que queres buscar etiquetas ``<span>`` que estean dentro de etiquetas ``<a>``. Isto pódese conseguir con::

en: If you want to search for tags at a particular level in the document, change the prefix::
gl: Se queres buscar etiquetas nun nivel concreto do documento, cambia o prefixo::

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.
gl: Isto coincidirá só con "<p>Un libro electrónico moi curto para demostrar o uso de XPath.</p>" no :ref:`libro_electrónico_de_exemplo`, pero non con ningunha das outras etiquetas ``<p>``. O prefixo "h:" nos exemplos anteriores é necesario para coincidir coas etiquetas XHTML. Isto débese a que, internamente, calibre representa todo o contido como XHTML. En XHTML, as etiquetas teñen un *espazo de nomes* e "h:" é o prefixo do espazo de nomes para as etiquetas 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::
gl: Agora supoñamos que queres seleccionar etiquetas ``<h1>`` e ``<h2>``. Para iso, necesitamos unha construción XPath chamada *predicate*. Un :dfn:`predicate` é simplemente unha proba que se usa para seleccionar etiquetas. As probas poden ser arbitrariamente potentes e, a medida que avance este tutorial, verás exemplos máis potentes. Un predicado créase encerrando a expresión de proba entre corchetes::

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.
gl: Hai varias características novas nesta expresión XPath. A primeira é o uso do comodín ``*``. Significa *coincide con calquera etiqueta*. Agora observa a expresión de proba ``name()='h1' ou name()='h2'``. :term:`name()` é un exemplo dunha *función integrada*. Simplemente avalía o nome da etiqueta. Polo tanto, usándoa, podemos seleccionar etiquetas cuxos nomes sexan `h1` ou `h2`. Ten en conta que a función :term:`name()` ignora os espazos de nomes, polo que non hai necesidade do prefixo ``h:``. XPath ten varias funcións integradas útiles. Neste tutorial presentarase unhas cantas máis.

en: Selecting by attributes
gl: Selección por atributos

en: To select tags based on their attributes, the use of predicates is required::
gl: Para seleccionar etiquetas segundo os seus atributos, requírese o uso de predicados::

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.
gl: Aquí, o operador ``@`` refírese aos atributos da etiqueta. Podes usar algunhas das `funcións integradas de XPath`_ para realizar coincidencias máis sofisticadas nos valores dos atributos.

en: Selecting by tag content
gl: Selección por contido de etiqueta

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()`::
gl: Usando XPath, podes incluso seleccionar etiquetas segundo o texto que conteñen. A mellor maneira de facelo é usar a potencia das *expresións regulares* mediante a función integrada :term:`re:test()`::

en: Here the ``.`` operator refers to the contents of the tag, just as the ``@`` operator referred to its attributes.
gl: Aquí, o operador ``.`` refírese ao contido da etiqueta, do mesmo xeito que o operador ``@`` se refería aos seus atributos.

en: Sample e-book
gl: Exemplo de libro electrónico

en: XPath built-in functions
gl: Funcións integradas de XPath

en: name()
gl: nome()

en: The name of the current tag.
gl: O nome da etiqueta actual.

en: contains()
gl: contén()

en: ``contains(s1, s2)`` returns `true` if s1 contains s2.
gl: ``contén(s1, s2)`` devolve `verdadeiro` se s1 contén s2.

en: re:test()
gl: re:proba()

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>`_
gl: ``re:test(src, pattern, flags)`` devolve `true` se a cadea `src` coincide coa expresión regular `pattern`. Un indicador particularmente útil é ``i``, xa que fai que a coincidencia non distinga entre maiúsculas e minúsculas. Unha boa introdución á sintaxe das expresións regulares pódese atopar en `regexp syntax <https://docs.python.org/library/re.html>`_
